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