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