git.sesse.net Git - ffmpeg/blob - avconv_opt.c

   1 /*
   2  * avconv option parsing
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libav is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Libav; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdint.h>
  22
  23 #include "avconv.h"
  24 #include "cmdutils.h"
  25
  26 #include "libavformat/avformat.h"
  27
  28 #include "libavcodec/avcodec.h"
  29
  30 #include "libavfilter/avfilter.h"
  31 #include "libavfilter/avfiltergraph.h"
  32
  33 #include "libavutil/avassert.h"
  34 #include "libavutil/avstring.h"
  35 #include "libavutil/avutil.h"
  36 #include "libavutil/channel_layout.h"
  37 #include "libavutil/intreadwrite.h"
  38 #include "libavutil/fifo.h"
  39 #include "libavutil/mathematics.h"
  40 #include "libavutil/opt.h"
  41 #include "libavutil/parseutils.h"
  42 #include "libavutil/pixdesc.h"
  43 #include "libavutil/pixfmt.h"
  44
  45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
  46 {\
  47     int i, ret;\
  48     for (i = 0; i < o->nb_ ## name; i++) {\
  49         char *spec = o->name[i].specifier;\
  50         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
  51             outvar = o->name[i].u.type;\
  52         else if (ret < 0)\
  53             exit(1);\
  54     }\
  55 }
  56
  57 char *vstats_filename;
  58
  59 float audio_drift_threshold = 0.1;
  60 float dts_delta_threshold   = 10;
  61
  62 int audio_volume      = 256;
  63 int audio_sync_method = 0;
  64 int video_sync_method = VSYNC_AUTO;
  65 int do_deinterlace    = 0;
  66 int do_benchmark      = 0;
  67 int do_hex_dump       = 0;
  68 int do_pkt_dump       = 0;
  69 int copy_ts           = 0;
  70 int copy_tb           = 1;
  71 int exit_on_error     = 0;
  72 int print_stats       = 1;
  73 int qp_hist           = 0;
  74
  75 static int file_overwrite     = 0;
  76 static int video_discard      = 0;
  77 static int intra_dc_precision = 8;
  78 static int using_stdin        = 0;
  79 static int input_sync;
  80
  81 static void uninit_options(OptionsContext *o)
  82 {
  83     const OptionDef *po = options;
  84     int i;
  85
  86     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
  87     while (po->name) {
  88         void *dst = (uint8_t*)o + po->u.off;
  89
  90         if (po->flags & OPT_SPEC) {
  91             SpecifierOpt **so = dst;
  92             int i, *count = (int*)(so + 1);
  93             for (i = 0; i < *count; i++) {
  94                 av_freep(&(*so)[i].specifier);
  95                 if (po->flags & OPT_STRING)
  96                     av_freep(&(*so)[i].u.str);
  97             }
  98             av_freep(so);
  99             *count = 0;
 100         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 101             av_freep(dst);
 102         po++;
 103     }
 104
 105     for (i = 0; i < o->nb_stream_maps; i++)
 106         av_freep(&o->stream_maps[i].linklabel);
 107     av_freep(&o->stream_maps);
 108     av_freep(&o->meta_data_maps);
 109     av_freep(&o->streamid_map);
 110 }
 111
 112 static void init_options(OptionsContext *o)
 113 {
 114     memset(o, 0, sizeof(*o));
 115
 116     o->mux_max_delay  = 0.7;
 117     o->recording_time = INT64_MAX;
 118     o->limit_filesize = UINT64_MAX;
 119     o->chapters_input_file = INT_MAX;
 120 }
 121
 122 /* return a copy of the input with the stream specifiers removed from the keys */
 123 static AVDictionary *strip_specifiers(AVDictionary *dict)
 124 {
 125     AVDictionaryEntry *e = NULL;
 126     AVDictionary    *ret = NULL;
 127
 128     while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
 129         char *p = strchr(e->key, ':');
 130
 131         if (p)
 132             *p = 0;
 133         av_dict_set(&ret, e->key, e->value, 0);
 134         if (p)
 135             *p = ':';
 136     }
 137     return ret;
 138 }
 139
 140 static double parse_frame_aspect_ratio(const char *arg)
 141 {
 142     int x = 0, y = 0;
 143     double ar = 0;
 144     const char *p;
 145     char *end;
 146
 147     p = strchr(arg, ':');
 148     if (p) {
 149         x = strtol(arg, &end, 10);
 150         if (end == p)
 151             y = strtol(end + 1, &end, 10);
 152         if (x > 0 && y > 0)
 153             ar = (double)x / (double)y;
 154     } else
 155         ar = strtod(arg, NULL);
 156
 157     if (!ar) {
 158         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
 159         exit(1);
 160     }
 161     return ar;
 162 }
 163
 164 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
 165 {
 166     OptionsContext *o = optctx;
 167     return parse_option(o, "codec:a", arg, options);
 168 }
 169
 170 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
 171 {
 172     OptionsContext *o = optctx;
 173     return parse_option(o, "codec:v", arg, options);
 174 }
 175
 176 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
 177 {
 178     OptionsContext *o = optctx;
 179     return parse_option(o, "codec:s", arg, options);
 180 }
 181
 182 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
 183 {
 184     OptionsContext *o = optctx;
 185     return parse_option(o, "codec:d", arg, options);
 186 }
 187
 188 static int opt_map(void *optctx, const char *opt, const char *arg)
 189 {
 190     OptionsContext *o = optctx;
 191     StreamMap *m = NULL;
 192     int i, negative = 0, file_idx;
 193     int sync_file_idx = -1, sync_stream_idx;
 194     char *p, *sync;
 195     char *map;
 196
 197     if (*arg == '-') {
 198         negative = 1;
 199         arg++;
 200     }
 201     map = av_strdup(arg);
 202
 203     /* parse sync stream first, just pick first matching stream */
 204     if (sync = strchr(map, ',')) {
 205         *sync = 0;
 206         sync_file_idx = strtol(sync + 1, &sync, 0);
 207         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
 208             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
 209             exit(1);
 210         }
 211         if (*sync)
 212             sync++;
 213         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
 214             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
 215                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
 216                 sync_stream_idx = i;
 217                 break;
 218             }
 219         if (i == input_files[sync_file_idx]->nb_streams) {
 220             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
 221                                        "match any streams.\n", arg);
 222             exit(1);
 223         }
 224     }
 225
 226
 227     if (map[0] == '[') {
 228         /* this mapping refers to lavfi output */
 229         const char *c = map + 1;
 230         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
 231         m = &o->stream_maps[o->nb_stream_maps - 1];
 232         m->linklabel = av_get_token(&c, "]");
 233         if (!m->linklabel) {
 234             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
 235             exit(1);
 236         }
 237     } else {
 238         file_idx = strtol(map, &p, 0);
 239         if (file_idx >= nb_input_files || file_idx < 0) {
 240             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
 241             exit(1);
 242         }
 243         if (negative)
 244             /* disable some already defined maps */
 245             for (i = 0; i < o->nb_stream_maps; i++) {
 246                 m = &o->stream_maps[i];
 247                 if (file_idx == m->file_index &&
 248                     check_stream_specifier(input_files[m->file_index]->ctx,
 249                                            input_files[m->file_index]->ctx->streams[m->stream_index],
 250                                            *p == ':' ? p + 1 : p) > 0)
 251                     m->disabled = 1;
 252             }
 253         else
 254             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
 255                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
 256                             *p == ':' ? p + 1 : p) <= 0)
 257                     continue;
 258                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
 259                 m = &o->stream_maps[o->nb_stream_maps - 1];
 260
 261                 m->file_index   = file_idx;
 262                 m->stream_index = i;
 263
 264                 if (sync_file_idx >= 0) {
 265                     m->sync_file_index   = sync_file_idx;
 266                     m->sync_stream_index = sync_stream_idx;
 267                 } else {
 268                     m->sync_file_index   = file_idx;
 269                     m->sync_stream_index = i;
 270                 }
 271             }
 272     }
 273
 274     if (!m) {
 275         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
 276         exit(1);
 277     }
 278
 279     av_freep(&map);
 280     return 0;
 281 }
 282
 283 static int opt_attach(void *optctx, const char *opt, const char *arg)
 284 {
 285     OptionsContext *o = optctx;
 286     GROW_ARRAY(o->attachments, o->nb_attachments);
 287     o->attachments[o->nb_attachments - 1] = arg;
 288     return 0;
 289 }
 290
 291 /**
 292  * Parse a metadata specifier passed as 'arg' parameter.
 293  * @param arg  metadata string to parse
 294  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 295  * @param index for type c/p, chapter/program index is written here
 296  * @param stream_spec for type s, the stream specifier is written here
 297  */
 298 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
 299 {
 300     if (*arg) {
 301         *type = *arg;
 302         switch (*arg) {
 303         case 'g':
 304             break;
 305         case 's':
 306             if (*(++arg) && *arg != ':') {
 307                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
 308                 exit(1);
 309             }
 310             *stream_spec = *arg == ':' ? arg + 1 : "";
 311             break;
 312         case 'c':
 313         case 'p':
 314             if (*(++arg) == ':')
 315                 *index = strtol(++arg, NULL, 0);
 316             break;
 317         default:
 318             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
 319             exit(1);
 320         }
 321     } else
 322         *type = 'g';
 323 }
 324
 325 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
 326 {
 327     AVDictionary **meta_in = NULL;
 328     AVDictionary **meta_out;
 329     int i, ret = 0;
 330     char type_in, type_out;
 331     const char *istream_spec = NULL, *ostream_spec = NULL;
 332     int idx_in = 0, idx_out = 0;
 333
 334     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
 335     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
 336
 337     if (type_in == 'g' || type_out == 'g')
 338         o->metadata_global_manual = 1;
 339     if (type_in == 's' || type_out == 's')
 340         o->metadata_streams_manual = 1;
 341     if (type_in == 'c' || type_out == 'c')
 342         o->metadata_chapters_manual = 1;
 343
 344     /* ic is NULL when just disabling automatic mappings */
 345     if (!ic)
 346         return 0;
 347
 348 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
 349     if ((index) < 0 || (index) >= (nb_elems)) {\
 350         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
 351                 (desc), (index));\
 352         exit(1);\
 353     }
 354
 355 #define SET_DICT(type, meta, context, index)\
 356         switch (type) {\
 357         case 'g':\
 358             meta = &context->metadata;\
 359             break;\
 360         case 'c':\
 361             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
 362             meta = &context->chapters[index]->metadata;\
 363             break;\
 364         case 'p':\
 365             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
 366             meta = &context->programs[index]->metadata;\
 367             break;\
 368         case 's':\
 369             break; /* handled separately below */ \
 370         default: av_assert0(0);\
 371         }\
 372
 373     SET_DICT(type_in, meta_in, ic, idx_in);
 374     SET_DICT(type_out, meta_out, oc, idx_out);
 375
 376     /* for input streams choose first matching stream */
 377     if (type_in == 's') {
 378         for (i = 0; i < ic->nb_streams; i++) {
 379             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
 380                 meta_in = &ic->streams[i]->metadata;
 381                 break;
 382             } else if (ret < 0)
 383                 exit(1);
 384         }
 385         if (!meta_in) {
 386             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
 387             exit(1);
 388         }
 389     }
 390
 391     if (type_out == 's') {
 392         for (i = 0; i < oc->nb_streams; i++) {
 393             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
 394                 meta_out = &oc->streams[i]->metadata;
 395                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 396             } else if (ret < 0)
 397                 exit(1);
 398         }
 399     } else
 400         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 401
 402     return 0;
 403 }
 404
 405 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
 406 {
 407     const AVCodecDescriptor *desc;
 408     const char *codec_string = encoder ? "encoder" : "decoder";
 409     AVCodec *codec;
 410
 411     codec = encoder ?
 412         avcodec_find_encoder_by_name(name) :
 413         avcodec_find_decoder_by_name(name);
 414
 415     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
 416         codec = encoder ? avcodec_find_encoder(desc->id) :
 417                           avcodec_find_decoder(desc->id);
 418         if (codec)
 419             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
 420                    codec_string, codec->name, desc->name);
 421     }
 422
 423     if (!codec) {
 424         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
 425         exit(1);
 426     }
 427     if (codec->type != type) {
 428         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
 429         exit(1);
 430     }
 431     return codec;
 432 }
 433
 434 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
 435 {
 436     char *codec_name = NULL;
 437
 438     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
 439     if (codec_name) {
 440         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
 441         st->codec->codec_id = codec->id;
 442         return codec;
 443     } else
 444         return avcodec_find_decoder(st->codec->codec_id);
 445 }
 446
 447 /* Add all the streams from the given input file to the global
 448  * list of input streams. */
 449 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 450 {
 451     int i;
 452
 453     for (i = 0; i < ic->nb_streams; i++) {
 454         AVStream *st = ic->streams[i];
 455         AVCodecContext *dec = st->codec;
 456         InputStream *ist = av_mallocz(sizeof(*ist));
 457         char *framerate = NULL;
 458
 459         if (!ist)
 460             exit(1);
 461
 462         GROW_ARRAY(input_streams, nb_input_streams);
 463         input_streams[nb_input_streams - 1] = ist;
 464
 465         ist->st = st;
 466         ist->file_index = nb_input_files;
 467         ist->discard = 1;
 468         st->discard  = AVDISCARD_ALL;
 469
 470         ist->ts_scale = 1.0;
 471         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
 472
 473         ist->dec = choose_decoder(o, ic, st);
 474         ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
 475
 476         switch (dec->codec_type) {
 477         case AVMEDIA_TYPE_VIDEO:
 478             ist->resample_height  = dec->height;
 479             ist->resample_width   = dec->width;
 480             ist->resample_pix_fmt = dec->pix_fmt;
 481
 482             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 483             if (framerate && av_parse_video_rate(&ist->framerate,
 484                                                  framerate) < 0) {
 485                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 486                        framerate);
 487                 exit(1);
 488             }
 489
 490             break;
 491         case AVMEDIA_TYPE_AUDIO:
 492             guess_input_channel_layout(ist);
 493
 494             ist->resample_sample_fmt     = dec->sample_fmt;
 495             ist->resample_sample_rate    = dec->sample_rate;
 496             ist->resample_channels       = dec->channels;
 497             ist->resample_channel_layout = dec->channel_layout;
 498
 499             break;
 500         case AVMEDIA_TYPE_DATA:
 501         case AVMEDIA_TYPE_SUBTITLE:
 502         case AVMEDIA_TYPE_ATTACHMENT:
 503         case AVMEDIA_TYPE_UNKNOWN:
 504             break;
 505         default:
 506             abort();
 507         }
 508     }
 509 }
 510
 511 static void assert_file_overwrite(const char *filename)
 512 {
 513     if (!file_overwrite &&
 514         (strchr(filename, ':') == NULL || filename[1] == ':' ||
 515          av_strstart(filename, "file:", NULL))) {
 516         if (avio_check(filename, 0) == 0) {
 517             if (!using_stdin) {
 518                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
 519                 fflush(stderr);
 520                 if (!read_yesno()) {
 521                     fprintf(stderr, "Not overwriting - exiting\n");
 522                     exit(1);
 523                 }
 524             }
 525             else {
 526                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
 527                 exit(1);
 528             }
 529         }
 530     }
 531 }
 532
 533 static void dump_attachment(AVStream *st, const char *filename)
 534 {
 535     int ret;
 536     AVIOContext *out = NULL;
 537     AVDictionaryEntry *e;
 538
 539     if (!st->codec->extradata_size) {
 540         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
 541                nb_input_files - 1, st->index);
 542         return;
 543     }
 544     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
 545         filename = e->value;
 546     if (!*filename) {
 547         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
 548                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
 549         exit(1);
 550     }
 551
 552     assert_file_overwrite(filename);
 553
 554     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
 555         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
 556                filename);
 557         exit(1);
 558     }
 559
 560     avio_write(out, st->codec->extradata, st->codec->extradata_size);
 561     avio_flush(out);
 562     avio_close(out);
 563 }
 564
 565 static int open_input_file(OptionsContext *o, const char *filename)
 566 {
 567     InputFile *f;
 568     AVFormatContext *ic;
 569     AVInputFormat *file_iformat = NULL;
 570     int err, i, ret;
 571     int64_t timestamp;
 572     uint8_t buf[128];
 573     AVDictionary **opts;
 574     AVDictionary *unused_opts = NULL;
 575     AVDictionaryEntry *e = NULL;
 576     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
 577
 578     if (o->format) {
 579         if (!(file_iformat = av_find_input_format(o->format))) {
 580             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
 581             exit(1);
 582         }
 583     }
 584
 585     if (!strcmp(filename, "-"))
 586         filename = "pipe:";
 587
 588     using_stdin |= !strncmp(filename, "pipe:", 5) ||
 589                     !strcmp(filename, "/dev/stdin");
 590
 591     /* get default parameters from command line */
 592     ic = avformat_alloc_context();
 593     if (!ic) {
 594         print_error(filename, AVERROR(ENOMEM));
 595         exit(1);
 596     }
 597     if (o->nb_audio_sample_rate) {
 598         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
 599         av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
 600     }
 601     if (o->nb_audio_channels) {
 602         /* because we set audio_channels based on both the "ac" and
 603          * "channel_layout" options, we need to check that the specified
 604          * demuxer actually has the "channels" option before setting it */
 605         if (file_iformat && file_iformat->priv_class &&
 606             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
 607                         AV_OPT_SEARCH_FAKE_OBJ)) {
 608             snprintf(buf, sizeof(buf), "%d",
 609                      o->audio_channels[o->nb_audio_channels - 1].u.i);
 610             av_dict_set(&o->g->format_opts, "channels", buf, 0);
 611         }
 612     }
 613     if (o->nb_frame_rates) {
 614         /* set the format-level framerate option;
 615          * this is important for video grabbers, e.g. x11 */
 616         if (file_iformat && file_iformat->priv_class &&
 617             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
 618                         AV_OPT_SEARCH_FAKE_OBJ)) {
 619             av_dict_set(&o->g->format_opts, "framerate",
 620                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
 621         }
 622     }
 623     if (o->nb_frame_sizes) {
 624         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
 625     }
 626     if (o->nb_frame_pix_fmts)
 627         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
 628
 629     ic->flags |= AVFMT_FLAG_NONBLOCK;
 630     ic->interrupt_callback = int_cb;
 631
 632     /* open the input file with generic libav function */
 633     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
 634     if (err < 0) {
 635         print_error(filename, err);
 636         exit(1);
 637     }
 638     assert_avoptions(o->g->format_opts);
 639
 640     /* apply forced codec ids */
 641     for (i = 0; i < ic->nb_streams; i++)
 642         choose_decoder(o, ic, ic->streams[i]);
 643
 644     /* Set AVCodecContext options for avformat_find_stream_info */
 645     opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
 646     orig_nb_streams = ic->nb_streams;
 647
 648     /* If not enough info to get the stream parameters, we decode the
 649        first frames to get it. (used in mpeg case for example) */
 650     ret = avformat_find_stream_info(ic, opts);
 651     if (ret < 0) {
 652         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
 653         avformat_close_input(&ic);
 654         exit(1);
 655     }
 656
 657     timestamp = o->start_time;
 658     /* add the stream start time */
 659     if (ic->start_time != AV_NOPTS_VALUE)
 660         timestamp += ic->start_time;
 661
 662     /* if seeking requested, we execute it */
 663     if (o->start_time != 0) {
 664         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
 665         if (ret < 0) {
 666             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
 667                    filename, (double)timestamp / AV_TIME_BASE);
 668         }
 669     }
 670
 671     /* update the current parameters so that they match the one of the input stream */
 672     add_input_streams(o, ic);
 673
 674     /* dump the file content */
 675     av_dump_format(ic, nb_input_files, filename, 0);
 676
 677     GROW_ARRAY(input_files, nb_input_files);
 678     f = av_mallocz(sizeof(*f));
 679     if (!f)
 680         exit(1);
 681     input_files[nb_input_files - 1] = f;
 682
 683     f->ctx        = ic;
 684     f->ist_index  = nb_input_streams - ic->nb_streams;
 685     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
 686     f->nb_streams = ic->nb_streams;
 687     f->rate_emu   = o->rate_emu;
 688
 689     /* check if all codec options have been used */
 690     unused_opts = strip_specifiers(o->g->codec_opts);
 691     for (i = f->ist_index; i < nb_input_streams; i++) {
 692         e = NULL;
 693         while ((e = av_dict_get(input_streams[i]->opts, "", e,
 694                                 AV_DICT_IGNORE_SUFFIX)))
 695             av_dict_set(&unused_opts, e->key, NULL, 0);
 696     }
 697
 698     e = NULL;
 699     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
 700         const AVClass *class = avcodec_get_class();
 701         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
 702                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
 703         if (!option)
 704             continue;
 705         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
 706             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
 707                    "input file #%d (%s) is not a decoding option.\n", e->key,
 708                    option->help ? option->help : "", nb_input_files - 1,
 709                    filename);
 710             exit(1);
 711         }
 712
 713         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
 714                "input file #%d (%s) has not been used for any stream. The most "
 715                "likely reason is either wrong type (e.g. a video option with "
 716                "no video streams) or that it is a private option of some decoder "
 717                "which was not actually used for any stream.\n", e->key,
 718                option->help ? option->help : "", nb_input_files - 1, filename);
 719     }
 720     av_dict_free(&unused_opts);
 721
 722     for (i = 0; i < o->nb_dump_attachment; i++) {
 723         int j;
 724
 725         for (j = 0; j < ic->nb_streams; j++) {
 726             AVStream *st = ic->streams[j];
 727
 728             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
 729                 dump_attachment(st, o->dump_attachment[i].u.str);
 730         }
 731     }
 732
 733     for (i = 0; i < orig_nb_streams; i++)
 734         av_dict_free(&opts[i]);
 735     av_freep(&opts);
 736
 737     return 0;
 738 }
 739
 740 static uint8_t *get_line(AVIOContext *s)
 741 {
 742     AVIOContext *line;
 743     uint8_t *buf;
 744     char c;
 745
 746     if (avio_open_dyn_buf(&line) < 0) {
 747         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 748         exit(1);
 749     }
 750
 751     while ((c = avio_r8(s)) && c != '\n')
 752         avio_w8(line, c);
 753     avio_w8(line, 0);
 754     avio_close_dyn_buf(line, &buf);
 755
 756     return buf;
 757 }
 758
 759 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 760 {
 761     int i, ret = 1;
 762     char filename[1000];
 763     const char *base[3] = { getenv("AVCONV_DATADIR"),
 764                             getenv("HOME"),
 765                             AVCONV_DATADIR,
 766                             };
 767
 768     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
 769         if (!base[i])
 770             continue;
 771         if (codec_name) {
 772             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 773                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
 774             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 775         }
 776         if (ret) {
 777             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 778                      i != 1 ? "" : "/.avconv", preset_name);
 779             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 780         }
 781     }
 782     return ret;
 783 }
 784
 785 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 786 {
 787     char *codec_name = NULL;
 788
 789     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 790     if (!codec_name) {
 791         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 792                                                   NULL, ost->st->codec->codec_type);
 793         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
 794     } else if (!strcmp(codec_name, "copy"))
 795         ost->stream_copy = 1;
 796     else {
 797         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
 798         ost->st->codec->codec_id = ost->enc->id;
 799     }
 800 }
 801
 802 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
 803 {
 804     OutputStream *ost;
 805     AVStream *st = avformat_new_stream(oc, NULL);
 806     int idx      = oc->nb_streams - 1, ret = 0;
 807     char *bsf = NULL, *next, *codec_tag = NULL;
 808     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
 809     double qscale = -1;
 810
 811     if (!st) {
 812         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 813         exit(1);
 814     }
 815
 816     if (oc->nb_streams - 1 < o->nb_streamid_map)
 817         st->id = o->streamid_map[oc->nb_streams - 1];
 818
 819     GROW_ARRAY(output_streams, nb_output_streams);
 820     if (!(ost = av_mallocz(sizeof(*ost))))
 821         exit(1);
 822     output_streams[nb_output_streams - 1] = ost;
 823
 824     ost->file_index = nb_output_files;
 825     ost->index      = idx;
 826     ost->st         = st;
 827     st->codec->codec_type = type;
 828     choose_encoder(o, oc, ost);
 829     if (ost->enc) {
 830         AVIOContext *s = NULL;
 831         char *buf = NULL, *arg = NULL, *preset = NULL;
 832
 833         ost->opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
 834
 835         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 836         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 837             do  {
 838                 buf = get_line(s);
 839                 if (!buf[0] || buf[0] == '#') {
 840                     av_free(buf);
 841                     continue;
 842                 }
 843                 if (!(arg = strchr(buf, '='))) {
 844                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 845                     exit(1);
 846                 }
 847                 *arg++ = 0;
 848                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 849                 av_free(buf);
 850             } while (!s->eof_reached);
 851             avio_close(s);
 852         }
 853         if (ret) {
 854             av_log(NULL, AV_LOG_FATAL,
 855                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
 856                    preset, ost->file_index, ost->index);
 857             exit(1);
 858         }
 859     } else {
 860         ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
 861     }
 862
 863     avcodec_get_context_defaults3(st->codec, ost->enc);
 864     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 865
 866     ost->max_frames = INT64_MAX;
 867     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 868
 869     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 870     while (bsf) {
 871         if (next = strchr(bsf, ','))
 872             *next++ = 0;
 873         if (!(bsfc = av_bitstream_filter_init(bsf))) {
 874             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 875             exit(1);
 876         }
 877         if (bsfc_prev)
 878             bsfc_prev->next = bsfc;
 879         else
 880             ost->bitstream_filters = bsfc;
 881
 882         bsfc_prev = bsfc;
 883         bsf       = next;
 884     }
 885
 886     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 887     if (codec_tag) {
 888         uint32_t tag = strtol(codec_tag, &next, 0);
 889         if (*next)
 890             tag = AV_RL32(codec_tag);
 891         st->codec->codec_tag = tag;
 892     }
 893
 894     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 895     if (qscale >= 0) {
 896         st->codec->flags |= CODEC_FLAG_QSCALE;
 897         st->codec->global_quality = FF_QP2LAMBDA * qscale;
 898     }
 899
 900     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 901         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
 902
 903     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
 904
 905     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
 906
 907     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
 908
 909     return ost;
 910 }
 911
 912 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
 913 {
 914     int i;
 915     const char *p = str;
 916     for (i = 0;; i++) {
 917         dest[i] = atoi(p);
 918         if (i == 63)
 919             break;
 920         p = strchr(p, ',');
 921         if (!p) {
 922             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
 923             exit(1);
 924         }
 925         p++;
 926     }
 927 }
 928
 929 /* read file contents into a string */
 930 static uint8_t *read_file(const char *filename)
 931 {
 932     AVIOContext *pb      = NULL;
 933     AVIOContext *dyn_buf = NULL;
 934     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
 935     uint8_t buf[1024], *str;
 936
 937     if (ret < 0) {
 938         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
 939         return NULL;
 940     }
 941
 942     ret = avio_open_dyn_buf(&dyn_buf);
 943     if (ret < 0) {
 944         avio_closep(&pb);
 945         return NULL;
 946     }
 947     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
 948         avio_write(dyn_buf, buf, ret);
 949     avio_w8(dyn_buf, 0);
 950     avio_closep(&pb);
 951
 952     ret = avio_close_dyn_buf(dyn_buf, &str);
 953     if (ret < 0)
 954         return NULL;
 955     return str;
 956 }
 957
 958 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
 959                              OutputStream *ost)
 960 {
 961     AVStream *st = ost->st;
 962     char *filter = NULL, *filter_script = NULL;
 963
 964     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
 965     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
 966
 967     if (filter_script && filter) {
 968         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
 969                "output stream #%d:%d.\n", nb_output_files, st->index);
 970         exit(1);
 971     }
 972
 973     if (filter_script)
 974         return read_file(filter_script);
 975     else if (filter)
 976         return av_strdup(filter);
 977
 978     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
 979                      "null" : "anull");
 980 }
 981
 982 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
 983 {
 984     AVStream *st;
 985     OutputStream *ost;
 986     AVCodecContext *video_enc;
 987
 988     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
 989     st  = ost->st;
 990     video_enc = st->codec;
 991
 992     if (!ost->stream_copy) {
 993         const char *p = NULL;
 994         char *frame_rate = NULL, *frame_size = NULL;
 995         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
 996         char *intra_matrix = NULL, *inter_matrix = NULL;
 997         int do_pass = 0;
 998         int i;
 999
1000         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1001         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1002             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1003             exit(1);
1004         }
1005
1006         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1007         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1008             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1009             exit(1);
1010         }
1011
1012         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1013         if (frame_aspect_ratio)
1014             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1015
1016         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1017         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1018             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1019             exit(1);
1020         }
1021         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1022
1023         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1024         if (intra_matrix) {
1025             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1026                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1027                 exit(1);
1028             }
1029             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1030         }
1031         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1032         if (inter_matrix) {
1033             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1034                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1035                 exit(1);
1036             }
1037             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1038         }
1039
1040         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1041         for (i = 0; p; i++) {
1042             int start, end, q;
1043             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1044             if (e != 3) {
1045                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1046                 exit(1);
1047             }
1048             video_enc->rc_override =
1049                 av_realloc(video_enc->rc_override,
1050                            sizeof(RcOverride) * (i + 1));
1051             video_enc->rc_override[i].start_frame = start;
1052             video_enc->rc_override[i].end_frame   = end;
1053             if (q > 0) {
1054                 video_enc->rc_override[i].qscale         = q;
1055                 video_enc->rc_override[i].quality_factor = 1.0;
1056             }
1057             else {
1058                 video_enc->rc_override[i].qscale         = 0;
1059                 video_enc->rc_override[i].quality_factor = -q/100.0;
1060             }
1061             p = strchr(p, '/');
1062             if (p) p++;
1063         }
1064         video_enc->rc_override_count = i;
1065         video_enc->intra_dc_precision = intra_dc_precision - 8;
1066
1067         /* two pass mode */
1068         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1069         if (do_pass) {
1070             if (do_pass == 1) {
1071                 video_enc->flags |= CODEC_FLAG_PASS1;
1072             } else {
1073                 video_enc->flags |= CODEC_FLAG_PASS2;
1074             }
1075         }
1076
1077         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1078         if (ost->logfile_prefix &&
1079             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1080             exit(1);
1081
1082         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1083         if (ost->forced_keyframes)
1084             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1085
1086         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1087
1088         ost->top_field_first = -1;
1089         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1090
1091
1092         ost->avfilter = get_ost_filters(o, oc, ost);
1093         if (!ost->avfilter)
1094             exit(1);
1095     } else {
1096         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1097     }
1098
1099     return ost;
1100 }
1101
1102 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1103 {
1104     AVStream *st;
1105     OutputStream *ost;
1106     AVCodecContext *audio_enc;
1107
1108     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1109     st  = ost->st;
1110
1111     audio_enc = st->codec;
1112     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1113
1114     if (!ost->stream_copy) {
1115         char *sample_fmt = NULL;
1116
1117         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1118
1119         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1120         if (sample_fmt &&
1121             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1122             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1123             exit(1);
1124         }
1125
1126         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1127
1128         ost->avfilter = get_ost_filters(o, oc, ost);
1129         if (!ost->avfilter)
1130             exit(1);
1131     }
1132
1133     return ost;
1134 }
1135
1136 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1137 {
1138     OutputStream *ost;
1139
1140     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1141     if (!ost->stream_copy) {
1142         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1143         exit(1);
1144     }
1145
1146     return ost;
1147 }
1148
1149 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1150 {
1151     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1152     ost->stream_copy = 1;
1153     ost->finished    = 1;
1154     return ost;
1155 }
1156
1157 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1158 {
1159     AVStream *st;
1160     OutputStream *ost;
1161     AVCodecContext *subtitle_enc;
1162
1163     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1164     st  = ost->st;
1165     subtitle_enc = st->codec;
1166
1167     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1168
1169     return ost;
1170 }
1171
1172 /* arg format is "output-stream-index:streamid-value". */
1173 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1174 {
1175     OptionsContext *o = optctx;
1176     int idx;
1177     char *p;
1178     char idx_str[16];
1179
1180     av_strlcpy(idx_str, arg, sizeof(idx_str));
1181     p = strchr(idx_str, ':');
1182     if (!p) {
1183         av_log(NULL, AV_LOG_FATAL,
1184                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1185                arg, opt);
1186         exit(1);
1187     }
1188     *p++ = '\0';
1189     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1190     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1191     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1192     return 0;
1193 }
1194
1195 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1196 {
1197     AVFormatContext *is = ifile->ctx;
1198     AVFormatContext *os = ofile->ctx;
1199     AVChapter **tmp;
1200     int i;
1201
1202     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1203     if (!tmp)
1204         return AVERROR(ENOMEM);
1205     os->chapters = tmp;
1206
1207     for (i = 0; i < is->nb_chapters; i++) {
1208         AVChapter *in_ch = is->chapters[i], *out_ch;
1209         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1210                                        AV_TIME_BASE_Q, in_ch->time_base);
1211         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1212                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1213
1214
1215         if (in_ch->end < ts_off)
1216             continue;
1217         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1218             break;
1219
1220         out_ch = av_mallocz(sizeof(AVChapter));
1221         if (!out_ch)
1222             return AVERROR(ENOMEM);
1223
1224         out_ch->id        = in_ch->id;
1225         out_ch->time_base = in_ch->time_base;
1226         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1227         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1228
1229         if (copy_metadata)
1230             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1231
1232         os->chapters[os->nb_chapters++] = out_ch;
1233     }
1234     return 0;
1235 }
1236
1237 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1238                                AVFormatContext *oc)
1239 {
1240     OutputStream *ost;
1241
1242     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1243                                   ofilter->out_tmp->pad_idx)) {
1244     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1245     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1246     default:
1247         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1248                "currently.\n");
1249         exit(1);
1250     }
1251
1252     ost->source_index = -1;
1253     ost->filter       = ofilter;
1254
1255     ofilter->ost      = ost;
1256
1257     if (ost->stream_copy) {
1258         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1259                "which is fed from a complex filtergraph. Filtering and streamcopy "
1260                "cannot be used together.\n", ost->file_index, ost->index);
1261         exit(1);
1262     }
1263
1264     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1265         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1266         exit(1);
1267     }
1268     avfilter_inout_free(&ofilter->out_tmp);
1269 }
1270
1271 static int configure_complex_filters(void)
1272 {
1273     int i, ret = 0;
1274
1275     for (i = 0; i < nb_filtergraphs; i++)
1276         if (!filtergraphs[i]->graph &&
1277             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1278             return ret;
1279     return 0;
1280 }
1281
1282 static int open_output_file(OptionsContext *o, const char *filename)
1283 {
1284     AVFormatContext *oc;
1285     int i, j, err;
1286     AVOutputFormat *file_oformat;
1287     OutputFile *of;
1288     OutputStream *ost;
1289     InputStream  *ist;
1290     AVDictionary *unused_opts = NULL;
1291     AVDictionaryEntry *e = NULL;
1292
1293     if (configure_complex_filters() < 0) {
1294         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1295         exit(1);
1296     }
1297
1298     if (!strcmp(filename, "-"))
1299         filename = "pipe:";
1300
1301     oc = avformat_alloc_context();
1302     if (!oc) {
1303         print_error(filename, AVERROR(ENOMEM));
1304         exit(1);
1305     }
1306
1307     if (o->format) {
1308         file_oformat = av_guess_format(o->format, NULL, NULL);
1309         if (!file_oformat) {
1310             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1311             exit(1);
1312         }
1313     } else {
1314         file_oformat = av_guess_format(NULL, filename, NULL);
1315         if (!file_oformat) {
1316             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1317                    filename);
1318             exit(1);
1319         }
1320     }
1321
1322     oc->oformat = file_oformat;
1323     oc->interrupt_callback = int_cb;
1324     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1325
1326     /* create streams for all unlabeled output pads */
1327     for (i = 0; i < nb_filtergraphs; i++) {
1328         FilterGraph *fg = filtergraphs[i];
1329         for (j = 0; j < fg->nb_outputs; j++) {
1330             OutputFilter *ofilter = fg->outputs[j];
1331
1332             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1333                 continue;
1334
1335             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1336                                           ofilter->out_tmp->pad_idx)) {
1337             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1338             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1339             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1340             }
1341             init_output_filter(ofilter, o, oc);
1342         }
1343     }
1344
1345     if (!o->nb_stream_maps) {
1346         /* pick the "best" stream of each type */
1347 #define NEW_STREAM(type, index)\
1348         if (index >= 0) {\
1349             ost = new_ ## type ## _stream(o, oc);\
1350             ost->source_index = index;\
1351             ost->sync_ist     = input_streams[index];\
1352             input_streams[index]->discard = 0;\
1353             input_streams[index]->st->discard = AVDISCARD_NONE;\
1354         }
1355
1356         /* video: highest resolution */
1357         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1358             int area = 0, idx = -1;
1359             for (i = 0; i < nb_input_streams; i++) {
1360                 ist = input_streams[i];
1361                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1362                     ist->st->codec->width * ist->st->codec->height > area) {
1363                     area = ist->st->codec->width * ist->st->codec->height;
1364                     idx = i;
1365                 }
1366             }
1367             NEW_STREAM(video, idx);
1368         }
1369
1370         /* audio: most channels */
1371         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1372             int channels = 0, idx = -1;
1373             for (i = 0; i < nb_input_streams; i++) {
1374                 ist = input_streams[i];
1375                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1376                     ist->st->codec->channels > channels) {
1377                     channels = ist->st->codec->channels;
1378                     idx = i;
1379                 }
1380             }
1381             NEW_STREAM(audio, idx);
1382         }
1383
1384         /* subtitles: pick first */
1385         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1386             for (i = 0; i < nb_input_streams; i++)
1387                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1388                     NEW_STREAM(subtitle, i);
1389                     break;
1390                 }
1391         }
1392         /* do something with data? */
1393     } else {
1394         for (i = 0; i < o->nb_stream_maps; i++) {
1395             StreamMap *map = &o->stream_maps[i];
1396
1397             if (map->disabled)
1398                 continue;
1399
1400             if (map->linklabel) {
1401                 FilterGraph *fg;
1402                 OutputFilter *ofilter = NULL;
1403                 int j, k;
1404
1405                 for (j = 0; j < nb_filtergraphs; j++) {
1406                     fg = filtergraphs[j];
1407                     for (k = 0; k < fg->nb_outputs; k++) {
1408                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1409                         if (out && !strcmp(out->name, map->linklabel)) {
1410                             ofilter = fg->outputs[k];
1411                             goto loop_end;
1412                         }
1413                     }
1414                 }
1415 loop_end:
1416                 if (!ofilter) {
1417                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1418                            "in any defined filter graph.\n", map->linklabel);
1419                     exit(1);
1420                 }
1421                 init_output_filter(ofilter, o, oc);
1422             } else {
1423                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1424                 switch (ist->st->codec->codec_type) {
1425                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1426                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1427                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1428                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1429                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1430                 default:
1431                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1432                            map->file_index, map->stream_index);
1433                     exit(1);
1434                 }
1435
1436                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1437                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1438                                                map->sync_stream_index];
1439                 ist->discard = 0;
1440                 ist->st->discard = AVDISCARD_NONE;
1441             }
1442         }
1443     }
1444
1445     /* handle attached files */
1446     for (i = 0; i < o->nb_attachments; i++) {
1447         AVIOContext *pb;
1448         uint8_t *attachment;
1449         const char *p;
1450         int64_t len;
1451
1452         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1453             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1454                    o->attachments[i]);
1455             exit(1);
1456         }
1457         if ((len = avio_size(pb)) <= 0) {
1458             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1459                    o->attachments[i]);
1460             exit(1);
1461         }
1462         if (!(attachment = av_malloc(len))) {
1463             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1464                    o->attachments[i]);
1465             exit(1);
1466         }
1467         avio_read(pb, attachment, len);
1468
1469         ost = new_attachment_stream(o, oc);
1470         ost->stream_copy               = 0;
1471         ost->source_index              = -1;
1472         ost->attachment_filename       = o->attachments[i];
1473         ost->st->codec->extradata      = attachment;
1474         ost->st->codec->extradata_size = len;
1475
1476         p = strrchr(o->attachments[i], '/');
1477         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1478         avio_close(pb);
1479     }
1480
1481     GROW_ARRAY(output_files, nb_output_files);
1482     of = av_mallocz(sizeof(*of));
1483     if (!of)
1484         exit(1);
1485     output_files[nb_output_files - 1] = of;
1486
1487     of->ctx            = oc;
1488     of->ost_index      = nb_output_streams - oc->nb_streams;
1489     of->recording_time = o->recording_time;
1490     if (o->recording_time != INT64_MAX)
1491         oc->duration = o->recording_time;
1492     of->start_time     = o->start_time;
1493     of->limit_filesize = o->limit_filesize;
1494     of->shortest       = o->shortest;
1495     av_dict_copy(&of->opts, o->g->format_opts, 0);
1496
1497
1498     /* check if all codec options have been used */
1499     unused_opts = strip_specifiers(o->g->codec_opts);
1500     for (i = of->ost_index; i < nb_output_streams; i++) {
1501         e = NULL;
1502         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1503                                 AV_DICT_IGNORE_SUFFIX)))
1504             av_dict_set(&unused_opts, e->key, NULL, 0);
1505     }
1506
1507     e = NULL;
1508     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1509         const AVClass *class = avcodec_get_class();
1510         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1511                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1512         if (!option)
1513             continue;
1514         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1515             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1516                    "output file #%d (%s) is not an encoding option.\n", e->key,
1517                    option->help ? option->help : "", nb_output_files - 1,
1518                    filename);
1519             exit(1);
1520         }
1521
1522         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1523                "output file #%d (%s) has not been used for any stream. The most "
1524                "likely reason is either wrong type (e.g. a video option with "
1525                "no video streams) or that it is a private option of some encoder "
1526                "which was not actually used for any stream.\n", e->key,
1527                option->help ? option->help : "", nb_output_files - 1, filename);
1528     }
1529     av_dict_free(&unused_opts);
1530
1531     /* check filename in case of an image number is expected */
1532     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1533         if (!av_filename_number_test(oc->filename)) {
1534             print_error(oc->filename, AVERROR(EINVAL));
1535             exit(1);
1536         }
1537     }
1538
1539     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1540         /* test if it already exists to avoid losing precious files */
1541         assert_file_overwrite(filename);
1542
1543         /* open the file */
1544         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1545                               &oc->interrupt_callback,
1546                               &of->opts)) < 0) {
1547             print_error(filename, err);
1548             exit(1);
1549         }
1550     }
1551
1552     if (o->mux_preload) {
1553         uint8_t buf[64];
1554         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1555         av_dict_set(&of->opts, "preload", buf, 0);
1556     }
1557     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1558     oc->flags |= AVFMT_FLAG_NONBLOCK;
1559
1560     /* copy metadata */
1561     for (i = 0; i < o->nb_metadata_map; i++) {
1562         char *p;
1563         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1564
1565         if (in_file_index >= nb_input_files) {
1566             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1567             exit(1);
1568         }
1569         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1570                       in_file_index >= 0 ?
1571                       input_files[in_file_index]->ctx : NULL, o);
1572     }
1573
1574     /* copy chapters */
1575     if (o->chapters_input_file >= nb_input_files) {
1576         if (o->chapters_input_file == INT_MAX) {
1577             /* copy chapters from the first input file that has them*/
1578             o->chapters_input_file = -1;
1579             for (i = 0; i < nb_input_files; i++)
1580                 if (input_files[i]->ctx->nb_chapters) {
1581                     o->chapters_input_file = i;
1582                     break;
1583                 }
1584         } else {
1585             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1586                    o->chapters_input_file);
1587             exit(1);
1588         }
1589     }
1590     if (o->chapters_input_file >= 0)
1591         copy_chapters(input_files[o->chapters_input_file], of,
1592                       !o->metadata_chapters_manual);
1593
1594     /* copy global metadata by default */
1595     if (!o->metadata_global_manual && nb_input_files)
1596         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1597                      AV_DICT_DONT_OVERWRITE);
1598     if (!o->metadata_streams_manual)
1599         for (i = of->ost_index; i < nb_output_streams; i++) {
1600             InputStream *ist;
1601             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1602                 continue;
1603             ist = input_streams[output_streams[i]->source_index];
1604             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1605         }
1606
1607     /* process manually set metadata */
1608     for (i = 0; i < o->nb_metadata; i++) {
1609         AVDictionary **m;
1610         char type, *val;
1611         const char *stream_spec;
1612         int index = 0, j, ret;
1613
1614         val = strchr(o->metadata[i].u.str, '=');
1615         if (!val) {
1616             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1617                    o->metadata[i].u.str);
1618             exit(1);
1619         }
1620         *val++ = 0;
1621
1622         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1623         if (type == 's') {
1624             for (j = 0; j < oc->nb_streams; j++) {
1625                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1626                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1627                 } else if (ret < 0)
1628                     exit(1);
1629             }
1630         }
1631         else {
1632             switch (type) {
1633             case 'g':
1634                 m = &oc->metadata;
1635                 break;
1636             case 'c':
1637                 if (index < 0 || index >= oc->nb_chapters) {
1638                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1639                     exit(1);
1640                 }
1641                 m = &oc->chapters[index]->metadata;
1642                 break;
1643             default:
1644                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1645                 exit(1);
1646             }
1647             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1648         }
1649     }
1650
1651     return 0;
1652 }
1653
1654 static int opt_target(void *optctx, const char *opt, const char *arg)
1655 {
1656     OptionsContext *o = optctx;
1657     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1658     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1659
1660     if (!strncmp(arg, "pal-", 4)) {
1661         norm = PAL;
1662         arg += 4;
1663     } else if (!strncmp(arg, "ntsc-", 5)) {
1664         norm = NTSC;
1665         arg += 5;
1666     } else if (!strncmp(arg, "film-", 5)) {
1667         norm = FILM;
1668         arg += 5;
1669     } else {
1670         /* Try to determine PAL/NTSC by peeking in the input files */
1671         if (nb_input_files) {
1672             int i, j, fr;
1673             for (j = 0; j < nb_input_files; j++) {
1674                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1675                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1676                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1677                         continue;
1678                     fr = c->time_base.den * 1000 / c->time_base.num;
1679                     if (fr == 25000) {
1680                         norm = PAL;
1681                         break;
1682                     } else if ((fr == 29970) || (fr == 23976)) {
1683                         norm = NTSC;
1684                         break;
1685                     }
1686                 }
1687                 if (norm != UNKNOWN)
1688                     break;
1689             }
1690         }
1691         if (norm != UNKNOWN)
1692             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1693     }
1694
1695     if (norm == UNKNOWN) {
1696         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1697         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1698         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1699         exit(1);
1700     }
1701
1702     if (!strcmp(arg, "vcd")) {
1703         opt_video_codec(o, "c:v", "mpeg1video");
1704         opt_audio_codec(o, "c:a", "mp2");
1705         parse_option(o, "f", "vcd", options);
1706
1707         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1708         parse_option(o, "r", frame_rates[norm], options);
1709         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1710
1711         opt_default(NULL, "b", "1150000");
1712         opt_default(NULL, "maxrate", "1150000");
1713         opt_default(NULL, "minrate", "1150000");
1714         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1715
1716         opt_default(NULL, "b:a", "224000");
1717         parse_option(o, "ar", "44100", options);
1718         parse_option(o, "ac", "2", options);
1719
1720         opt_default(NULL, "packetsize", "2324");
1721         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1722
1723         /* We have to offset the PTS, so that it is consistent with the SCR.
1724            SCR starts at 36000, but the first two packs contain only padding
1725            and the first pack from the other stream, respectively, may also have
1726            been written before.
1727            So the real data starts at SCR 36000+3*1200. */
1728         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1729     } else if (!strcmp(arg, "svcd")) {
1730
1731         opt_video_codec(o, "c:v", "mpeg2video");
1732         opt_audio_codec(o, "c:a", "mp2");
1733         parse_option(o, "f", "svcd", options);
1734
1735         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1736         parse_option(o, "r", frame_rates[norm], options);
1737         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1738
1739         opt_default(NULL, "b", "2040000");
1740         opt_default(NULL, "maxrate", "2516000");
1741         opt_default(NULL, "minrate", "0"); // 1145000;
1742         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1743         opt_default(NULL, "flags", "+scan_offset");
1744
1745
1746         opt_default(NULL, "b:a", "224000");
1747         parse_option(o, "ar", "44100", options);
1748
1749         opt_default(NULL, "packetsize", "2324");
1750
1751     } else if (!strcmp(arg, "dvd")) {
1752
1753         opt_video_codec(o, "c:v", "mpeg2video");
1754         opt_audio_codec(o, "c:a", "ac3");
1755         parse_option(o, "f", "dvd", options);
1756
1757         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1758         parse_option(o, "r", frame_rates[norm], options);
1759         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1760
1761         opt_default(NULL, "b", "6000000");
1762         opt_default(NULL, "maxrate", "9000000");
1763         opt_default(NULL, "minrate", "0"); // 1500000;
1764         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1765
1766         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1767         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1768
1769         opt_default(NULL, "b:a", "448000");
1770         parse_option(o, "ar", "48000", options);
1771
1772     } else if (!strncmp(arg, "dv", 2)) {
1773
1774         parse_option(o, "f", "dv", options);
1775
1776         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1777         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1778                           norm == PAL ? "yuv420p" : "yuv411p", options);
1779         parse_option(o, "r", frame_rates[norm], options);
1780
1781         parse_option(o, "ar", "48000", options);
1782         parse_option(o, "ac", "2", options);
1783
1784     } else {
1785         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1786         return AVERROR(EINVAL);
1787     }
1788     return 0;
1789 }
1790
1791 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1792 {
1793     av_free (vstats_filename);
1794     vstats_filename = av_strdup (arg);
1795     return 0;
1796 }
1797
1798 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1799 {
1800     char filename[40];
1801     time_t today2 = time(NULL);
1802     struct tm *today = localtime(&today2);
1803
1804     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1805              today->tm_sec);
1806     return opt_vstats_file(NULL, opt, filename);
1807 }
1808
1809 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1810 {
1811     OptionsContext *o = optctx;
1812     return parse_option(o, "frames:v", arg, options);
1813 }
1814
1815 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1816 {
1817     OptionsContext *o = optctx;
1818     return parse_option(o, "frames:a", arg, options);
1819 }
1820
1821 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1822 {
1823     OptionsContext *o = optctx;
1824     return parse_option(o, "frames:d", arg, options);
1825 }
1826
1827 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1828 {
1829     OptionsContext *o = optctx;
1830     return parse_option(o, "tag:v", arg, options);
1831 }
1832
1833 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1834 {
1835     OptionsContext *o = optctx;
1836     return parse_option(o, "tag:a", arg, options);
1837 }
1838
1839 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1840 {
1841     OptionsContext *o = optctx;
1842     return parse_option(o, "tag:s", arg, options);
1843 }
1844
1845 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1846 {
1847     OptionsContext *o = optctx;
1848     return parse_option(o, "filter:v", arg, options);
1849 }
1850
1851 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1852 {
1853     OptionsContext *o = optctx;
1854     return parse_option(o, "filter:a", arg, options);
1855 }
1856
1857 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1858 {
1859     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
1860     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
1861     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1862
1863     if (video_sync_method == VSYNC_AUTO)
1864         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1865     return 0;
1866 }
1867
1868 #if FF_API_DEINTERLACE
1869 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1870 {
1871     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1872     do_deinterlace = 1;
1873     return 0;
1874 }
1875 #endif
1876
1877 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1878 {
1879     int flags = av_parse_cpu_flags(arg);
1880
1881     if (flags < 0)
1882         return flags;
1883
1884     av_set_cpu_flags_mask(flags);
1885     return 0;
1886 }
1887
1888 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1889 {
1890     OptionsContext *o = optctx;
1891     char layout_str[32];
1892     char *stream_str;
1893     char *ac_str;
1894     int ret, channels, ac_str_size;
1895     uint64_t layout;
1896
1897     layout = av_get_channel_layout(arg);
1898     if (!layout) {
1899         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1900         return AVERROR(EINVAL);
1901     }
1902     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1903     ret = opt_default(NULL, opt, layout_str);
1904     if (ret < 0)
1905         return ret;
1906
1907     /* set 'ac' option based on channel layout */
1908     channels = av_get_channel_layout_nb_channels(layout);
1909     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1910     stream_str = strchr(opt, ':');
1911     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1912     ac_str = av_mallocz(ac_str_size);
1913     if (!ac_str)
1914         return AVERROR(ENOMEM);
1915     av_strlcpy(ac_str, "ac", 3);
1916     if (stream_str)
1917         av_strlcat(ac_str, stream_str, ac_str_size);
1918     ret = parse_option(o, ac_str, layout_str, options);
1919     av_free(ac_str);
1920
1921     return ret;
1922 }
1923
1924 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1925 {
1926     OptionsContext *o = optctx;
1927     return parse_option(o, "q:a", arg, options);
1928 }
1929
1930 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1931 {
1932     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1933     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1934         return AVERROR(ENOMEM);
1935     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
1936     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
1937     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1938         return AVERROR(ENOMEM);
1939     return 0;
1940 }
1941
1942 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1943 {
1944     uint8_t *graph_desc = read_file(arg);
1945     if (!graph_desc)
1946         return AVERROR(EINVAL);
1947
1948     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1949     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1950         return AVERROR(ENOMEM);
1951     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
1952     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1953     return 0;
1954 }
1955
1956 void show_help_default(const char *opt, const char *arg)
1957 {
1958     /* per-file options have at least one of those set */
1959     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1960     int show_advanced = 0, show_avoptions = 0;
1961
1962     if (opt && *opt) {
1963         if (!strcmp(opt, "long"))
1964             show_advanced = 1;
1965         else if (!strcmp(opt, "full"))
1966             show_advanced = show_avoptions = 1;
1967         else
1968             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1969     }
1970
1971     show_usage();
1972
1973     printf("Getting help:\n"
1974            "    -h      -- print basic options\n"
1975            "    -h long -- print more options\n"
1976            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1977            "    See man %s for detailed description of the options.\n"
1978            "\n", program_name);
1979
1980     show_help_options(options, "Print help / information / capabilities:",
1981                       OPT_EXIT, 0, 0);
1982
1983     show_help_options(options, "Global options (affect whole program "
1984                       "instead of just one file:",
1985                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1986     if (show_advanced)
1987         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1988                           per_file | OPT_EXIT, 0);
1989
1990     show_help_options(options, "Per-file main options:", 0,
1991                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1992                       OPT_EXIT, per_file);
1993     if (show_advanced)
1994         show_help_options(options, "Advanced per-file options:",
1995                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1996
1997     show_help_options(options, "Video options:",
1998                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1999     if (show_advanced)
2000         show_help_options(options, "Advanced Video options:",
2001                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2002
2003     show_help_options(options, "Audio options:",
2004                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2005     if (show_advanced)
2006         show_help_options(options, "Advanced Audio options:",
2007                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2008     show_help_options(options, "Subtitle options:",
2009                       OPT_SUBTITLE, 0, 0);
2010     printf("\n");
2011
2012     if (show_avoptions) {
2013         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2014         show_help_children(avcodec_get_class(), flags);
2015         show_help_children(avformat_get_class(), flags);
2016         show_help_children(sws_get_class(), flags);
2017     }
2018 }
2019
2020 void show_usage(void)
2021 {
2022     printf("Hyper fast Audio and Video encoder\n");
2023     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2024     printf("\n");
2025 }
2026
2027 enum OptGroup {
2028     GROUP_OUTFILE,
2029     GROUP_INFILE,
2030 };
2031
2032 static const OptionGroupDef groups[] = {
2033     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2034     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2035 };
2036
2037 static int open_files(OptionGroupList *l, const char *inout,
2038                       int (*open_file)(OptionsContext*, const char*))
2039 {
2040     int i, ret;
2041
2042     for (i = 0; i < l->nb_groups; i++) {
2043         OptionGroup *g = &l->groups[i];
2044         OptionsContext o;
2045
2046         init_options(&o);
2047         o.g = g;
2048
2049         ret = parse_optgroup(&o, g);
2050         if (ret < 0) {
2051             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2052                    "%s.\n", inout, g->arg);
2053             return ret;
2054         }
2055
2056         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2057         ret = open_file(&o, g->arg);
2058         uninit_options(&o);
2059         if (ret < 0) {
2060             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2061                    inout, g->arg);
2062             return ret;
2063         }
2064         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2065     }
2066
2067     return 0;
2068 }
2069
2070 int avconv_parse_options(int argc, char **argv)
2071 {
2072     OptionParseContext octx;
2073     uint8_t error[128];
2074     int ret;
2075
2076     memset(&octx, 0, sizeof(octx));
2077
2078     /* split the commandline into an internal representation */
2079     ret = split_commandline(&octx, argc, argv, options, groups,
2080                             FF_ARRAY_ELEMS(groups));
2081     if (ret < 0) {
2082         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2083         goto fail;
2084     }
2085
2086     /* apply global options */
2087     ret = parse_optgroup(NULL, &octx.global_opts);
2088     if (ret < 0) {
2089         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2090         goto fail;
2091     }
2092
2093     /* open input files */
2094     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2095     if (ret < 0) {
2096         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2097         goto fail;
2098     }
2099
2100     /* open output files */
2101     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2102     if (ret < 0) {
2103         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2104         goto fail;
2105     }
2106
2107 fail:
2108     uninit_parse_context(&octx);
2109     if (ret < 0) {
2110         av_strerror(ret, error, sizeof(error));
2111         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2112     }
2113     return ret;
2114 }
2115
2116 #define OFFSET(x) offsetof(OptionsContext, x)
2117 const OptionDef options[] = {
2118     /* main options */
2119 #include "cmdutils_common_opts.h"
2120     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2121                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2122         "force format", "fmt" },
2123     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2124         "overwrite output files" },
2125     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2126                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2127         "codec name", "codec" },
2128     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2129                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2130         "codec name", "codec" },
2131     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2132                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2133         "preset name", "preset" },
2134     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2135                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2136         "set input stream mapping",
2137         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2138     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2139                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2140         "set metadata information of outfile from infile",
2141         "outfile[,metadata]:infile[,metadata]" },
2142     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2143                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2144         "set chapters mapping", "input_file_index" },
2145     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2146         "record or transcode \"duration\" seconds of audio/video",
2147         "duration" },
2148     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2149         "set the limit file size in bytes", "limit_size" },
2150     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2151                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2152         "set the start time offset", "time_off" },
2153     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2154                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2155         "set the input ts offset", "time_off" },
2156     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2157                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2158         "set the input ts scale", "scale" },
2159     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2160         "add metadata", "string=string" },
2161     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2162                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2163         "set the number of data frames to record", "number" },
2164     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2165         "add timings for benchmarking" },
2166     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2167         "set max runtime in seconds", "limit" },
2168     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2169         "dump each input packet" },
2170     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2171         "when dumping packets, also dump the payload" },
2172     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2173                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2174         "read input at native frame rate", "" },
2175     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2176         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2177         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2178     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2179         "video sync method", "" },
2180     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2181         "audio sync method", "" },
2182     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2183         "audio drift threshold", "threshold" },
2184     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2185         "copy timestamps" },
2186     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2187         "copy input stream time base when stream copying" },
2188     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2189                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2190         "finish encoding within shortest input" },
2191     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2192         "timestamp discontinuity delta threshold", "threshold" },
2193     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2194         "exit on error", "error" },
2195     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2196                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2197         "copy initial non-keyframes" },
2198     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2199         "set the number of frames to record", "number" },
2200     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2201                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2202         "force codec tag/fourcc", "fourcc/tag" },
2203     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2204                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2205         "use fixed quality scale (VBR)", "q" },
2206     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2207                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2208         "use fixed quality scale (VBR)", "q" },
2209     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2210         "set stream filterchain", "filter_list" },
2211     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2212         "read stream filtergraph description from a file", "filename" },
2213     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2214         "create a complex filtergraph", "graph_description" },
2215     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2216         "read complex filtergraph description from a file", "filename" },
2217     { "stats",          OPT_BOOL,                                    { &print_stats },
2218         "print progress report during encoding", },
2219     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2220                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2221         "add an attachment to the output file", "filename" },
2222     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2223                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2224         "extract an attachment into a file", "filename" },
2225     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
2226         "set CPU flags mask", "mask" },
2227
2228     /* video options */
2229     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2230         "set the number of video frames to record", "number" },
2231     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2232                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2233         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2234     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2235                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2236         "set frame size (WxH or abbreviation)", "size" },
2237     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2238                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2239         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2240     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2241                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2242         "set pixel format", "format" },
2243     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2244         "disable video" },
2245     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2246         "discard threshold", "n" },
2247     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2248                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2249         "rate control override for specific intervals", "override" },
2250     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2251                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2252         "force video codec ('copy' to copy stream)", "codec" },
2253     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2254         "select the pass number (1 or 2)", "n" },
2255     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2256                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2257         "select two pass log file name prefix", "prefix" },
2258 #if FF_API_DEINTERLACE
2259     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2260         "this option is deprecated, use the yadif filter instead" },
2261 #endif
2262     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2263         "dump video coding statistics to file" },
2264     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2265         "dump video coding statistics to file", "file" },
2266     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2267         "video filters", "filter list" },
2268     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2269                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2270         "specify intra matrix coeffs", "matrix" },
2271     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2272                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2273         "specify inter matrix coeffs", "matrix" },
2274     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2275                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2276         "top=1/bottom=0/auto=-1 field first", "" },
2277     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2278         "intra_dc_precision", "precision" },
2279     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2280                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2281         "force video tag/fourcc", "fourcc/tag" },
2282     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2283         "show QP histogram" },
2284     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2285                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2286         "force the selected framerate, disable the best supported framerate selection" },
2287     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2288                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2289         "set the value of an outfile streamid", "streamIndex:value" },
2290     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2291                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2292         "force key frames at specified timestamps", "timestamps" },
2293
2294     /* audio options */
2295     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2296         "set the number of audio frames to record", "number" },
2297     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2298         "set audio quality (codec-specific)", "quality", },
2299     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2300                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2301         "set audio sampling rate (in Hz)", "rate" },
2302     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2303                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2304         "set number of audio channels", "channels" },
2305     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2306         "disable audio" },
2307     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2308                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2309         "force audio codec ('copy' to copy stream)", "codec" },
2310     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2311                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2312         "force audio tag/fourcc", "fourcc/tag" },
2313     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2314         "change audio volume (256=normal)" , "volume" },
2315     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2316                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2317         "set sample format", "format" },
2318     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2319                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2320         "set channel layout", "layout" },
2321     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2322         "audio filters", "filter list" },
2323
2324     /* subtitle options */
2325     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2326         "disable subtitle" },
2327     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2328         "force subtitle codec ('copy' to copy stream)", "codec" },
2329     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2330         , "force subtitle tag/fourcc", "fourcc/tag" },
2331
2332     /* grab options */
2333     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2334
2335     /* muxer options */
2336     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2337         "set the maximum demux-decode delay", "seconds" },
2338     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2339         "set the initial demux-decode delay", "seconds" },
2340
2341     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2342         "A comma-separated list of bitstream filters", "bitstream_filters" },
2343
2344     /* data codec support */
2345     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2346         "force data codec ('copy' to copy stream)", "codec" },
2347
2348     { NULL, },
2349 };