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

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