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     }
 961
 962     avcodec_get_context_defaults3(st->codec, ost->enc);
 963     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 964
 965     ost->max_frames = INT64_MAX;
 966     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 967
 968     ost->copy_prior_start = -1;
 969     MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
 970
 971     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 972     while (bsf) {
 973         if (next = strchr(bsf, ','))
 974             *next++ = 0;
 975         if (!(bsfc = av_bitstream_filter_init(bsf))) {
 976             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 977             exit(1);
 978         }
 979         if (bsfc_prev)
 980             bsfc_prev->next = bsfc;
 981         else
 982             ost->bitstream_filters = bsfc;
 983
 984         bsfc_prev = bsfc;
 985         bsf       = next;
 986     }
 987
 988     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 989     if (codec_tag) {
 990         uint32_t tag = strtol(codec_tag, &next, 0);
 991         if (*next)
 992             tag = AV_RL32(codec_tag);
 993         st->codec->codec_tag = tag;
 994     }
 995
 996     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 997     if (qscale >= 0) {
 998         st->codec->flags |= CODEC_FLAG_QSCALE;
 999         st->codec->global_quality = FF_QP2LAMBDA * qscale;
1000     }
1001
1002     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1003         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1004
1005     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1006
1007     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1008     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1009         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1010
1011     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1012
1013     ost->source_index = source_index;
1014     if (source_index >= 0) {
1015         ost->sync_ist = input_streams[source_index];
1016         input_streams[source_index]->discard = 0;
1017         input_streams[source_index]->st->discard = AVDISCARD_NONE;
1018     }
1019
1020     return ost;
1021 }
1022
1023 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1024 {
1025     int i;
1026     const char *p = str;
1027     for (i = 0;; i++) {
1028         dest[i] = atoi(p);
1029         if (i == 63)
1030             break;
1031         p = strchr(p, ',');
1032         if (!p) {
1033             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1034             exit(1);
1035         }
1036         p++;
1037     }
1038 }
1039
1040 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1041 {
1042     AVStream *st;
1043     OutputStream *ost;
1044     AVCodecContext *video_enc;
1045     char *frame_rate = NULL;
1046
1047     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1048     st  = ost->st;
1049     video_enc = st->codec;
1050
1051     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1052     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1053         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1054         exit(1);
1055     }
1056
1057     if (!ost->stream_copy) {
1058         const char *p = NULL;
1059         char *frame_size = NULL;
1060         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1061         char *intra_matrix = NULL, *inter_matrix = NULL;
1062         const char *filters = "null";
1063         int do_pass = 0;
1064         int i;
1065
1066         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1067         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1068             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1069             exit(1);
1070         }
1071
1072         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1073         if (frame_aspect_ratio) {
1074             AVRational q;
1075             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1076                 q.num <= 0 || q.den <= 0) {
1077                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1078                 exit(1);
1079             }
1080             ost->frame_aspect_ratio = av_q2d(q);
1081         }
1082
1083         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1084         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1085         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1086             ost->keep_pix_fmt = 1;
1087             if (!*++frame_pix_fmt)
1088                 frame_pix_fmt = NULL;
1089         }
1090         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1091             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1092             exit(1);
1093         }
1094         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1095
1096         if (intra_only)
1097             video_enc->gop_size = 0;
1098         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1099         if (intra_matrix) {
1100             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1101                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1102                 exit(1);
1103             }
1104             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1105         }
1106         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1107         if (inter_matrix) {
1108             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1109                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1110                 exit(1);
1111             }
1112             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1113         }
1114
1115         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1116         for (i = 0; p; i++) {
1117             int start, end, q;
1118             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1119             if (e != 3) {
1120                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1121                 exit(1);
1122             }
1123             /* FIXME realloc failure */
1124             video_enc->rc_override =
1125                 av_realloc(video_enc->rc_override,
1126                            sizeof(RcOverride) * (i + 1));
1127             video_enc->rc_override[i].start_frame = start;
1128             video_enc->rc_override[i].end_frame   = end;
1129             if (q > 0) {
1130                 video_enc->rc_override[i].qscale         = q;
1131                 video_enc->rc_override[i].quality_factor = 1.0;
1132             }
1133             else {
1134                 video_enc->rc_override[i].qscale         = 0;
1135                 video_enc->rc_override[i].quality_factor = -q/100.0;
1136             }
1137             p = strchr(p, '/');
1138             if (p) p++;
1139         }
1140         video_enc->rc_override_count = i;
1141         video_enc->intra_dc_precision = intra_dc_precision - 8;
1142
1143         if (do_psnr)
1144             video_enc->flags|= CODEC_FLAG_PSNR;
1145
1146         /* two pass mode */
1147         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1148         if (do_pass) {
1149             if (do_pass & 1) {
1150                 video_enc->flags |= CODEC_FLAG_PASS1;
1151                 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1152             }
1153             if (do_pass & 2) {
1154                 video_enc->flags |= CODEC_FLAG_PASS2;
1155                 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1156             }
1157         }
1158
1159         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1160         if (ost->logfile_prefix &&
1161             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1162             exit(1);
1163
1164         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1165         if (ost->forced_keyframes)
1166             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1167
1168         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1169
1170         ost->top_field_first = -1;
1171         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1172
1173         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1174         ost->avfilter = av_strdup(filters);
1175     } else {
1176         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1177     }
1178
1179     return ost;
1180 }
1181
1182 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1183 {
1184     int n;
1185     AVStream *st;
1186     OutputStream *ost;
1187     AVCodecContext *audio_enc;
1188
1189     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1190     st  = ost->st;
1191
1192     audio_enc = st->codec;
1193     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1194
1195     if (!ost->stream_copy) {
1196         char *sample_fmt = NULL;
1197         const char *filters = "anull";
1198
1199         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1200
1201         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1202         if (sample_fmt &&
1203             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1204             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1205             exit(1);
1206         }
1207
1208         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1209
1210         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1211
1212         av_assert1(filters);
1213         ost->avfilter = av_strdup(filters);
1214
1215         /* check for channel mapping for this audio stream */
1216         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1217             AudioChannelMap *map = &o->audio_channel_maps[n];
1218             InputStream *ist = input_streams[ost->source_index];
1219             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1220                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1221                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1222                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1223                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1224                 else
1225                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1226                            ost->file_index, ost->st->index);
1227             }
1228         }
1229     }
1230
1231     return ost;
1232 }
1233
1234 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1235 {
1236     OutputStream *ost;
1237
1238     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1239     if (!ost->stream_copy) {
1240         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1241         exit(1);
1242     }
1243
1244     return ost;
1245 }
1246
1247 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1248 {
1249     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1250     ost->stream_copy = 1;
1251     return ost;
1252 }
1253
1254 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1255 {
1256     AVStream *st;
1257     OutputStream *ost;
1258     AVCodecContext *subtitle_enc;
1259
1260     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1261     st  = ost->st;
1262     subtitle_enc = st->codec;
1263
1264     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1265
1266     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1267
1268     if (!ost->stream_copy) {
1269         char *frame_size = NULL;
1270
1271         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1272         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1273             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1274             exit(1);
1275         }
1276     }
1277
1278     return ost;
1279 }
1280
1281 /* arg format is "output-stream-index:streamid-value". */
1282 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1283 {
1284     OptionsContext *o = optctx;
1285     int idx;
1286     char *p;
1287     char idx_str[16];
1288
1289     av_strlcpy(idx_str, arg, sizeof(idx_str));
1290     p = strchr(idx_str, ':');
1291     if (!p) {
1292         av_log(NULL, AV_LOG_FATAL,
1293                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1294                arg, opt);
1295         exit(1);
1296     }
1297     *p++ = '\0';
1298     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1299     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1300     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1301     return 0;
1302 }
1303
1304 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1305 {
1306     AVFormatContext *is = ifile->ctx;
1307     AVFormatContext *os = ofile->ctx;
1308     AVChapter **tmp;
1309     int i;
1310
1311     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1312     if (!tmp)
1313         return AVERROR(ENOMEM);
1314     os->chapters = tmp;
1315
1316     for (i = 0; i < is->nb_chapters; i++) {
1317         AVChapter *in_ch = is->chapters[i], *out_ch;
1318         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1319                                        AV_TIME_BASE_Q, in_ch->time_base);
1320         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1321                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1322
1323
1324         if (in_ch->end < ts_off)
1325             continue;
1326         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1327             break;
1328
1329         out_ch = av_mallocz(sizeof(AVChapter));
1330         if (!out_ch)
1331             return AVERROR(ENOMEM);
1332
1333         out_ch->id        = in_ch->id;
1334         out_ch->time_base = in_ch->time_base;
1335         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1336         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1337
1338         if (copy_metadata)
1339             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1340
1341         os->chapters[os->nb_chapters++] = out_ch;
1342     }
1343     return 0;
1344 }
1345
1346 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1347 {
1348     int i, err;
1349     AVFormatContext *ic = avformat_alloc_context();
1350
1351     ic->interrupt_callback = int_cb;
1352     err = avformat_open_input(&ic, filename, NULL, NULL);
1353     if (err < 0)
1354         return err;
1355     /* copy stream format */
1356     for(i=0;i<ic->nb_streams;i++) {
1357         AVStream *st;
1358         OutputStream *ost;
1359         AVCodec *codec;
1360         AVCodecContext *avctx;
1361
1362         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1363         ost   = new_output_stream(o, s, codec->type, -1);
1364         st    = ost->st;
1365         avctx = st->codec;
1366         ost->enc = codec;
1367
1368         // FIXME: a more elegant solution is needed
1369         memcpy(st, ic->streams[i], sizeof(AVStream));
1370         st->cur_dts = 0;
1371         st->info = av_malloc(sizeof(*st->info));
1372         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1373         st->codec= avctx;
1374         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1375
1376         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1377             choose_sample_fmt(st, codec);
1378         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1379             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1380     }
1381
1382     /* ffserver seeking with date=... needs a date reference */
1383     err = parse_option(o, "metadata", "creation_time=now", options);
1384
1385     avformat_close_input(&ic);
1386     return err;
1387 }
1388
1389 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1390                                AVFormatContext *oc)
1391 {
1392     OutputStream *ost;
1393
1394     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1395                                   ofilter->out_tmp->pad_idx)) {
1396     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1397     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1398     default:
1399         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1400                "currently.\n");
1401         exit(1);
1402     }
1403
1404     ost->source_index = -1;
1405     ost->filter       = ofilter;
1406
1407     ofilter->ost      = ost;
1408
1409     if (ost->stream_copy) {
1410         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1411                "which is fed from a complex filtergraph. Filtering and streamcopy "
1412                "cannot be used together.\n", ost->file_index, ost->index);
1413         exit(1);
1414     }
1415
1416     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1417         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1418         exit(1);
1419     }
1420     avfilter_inout_free(&ofilter->out_tmp);
1421 }
1422
1423 static int configure_complex_filters(void)
1424 {
1425     int i, ret = 0;
1426
1427     for (i = 0; i < nb_filtergraphs; i++)
1428         if (!filtergraphs[i]->graph &&
1429             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1430             return ret;
1431     return 0;
1432 }
1433
1434 static int open_output_file(OptionsContext *o, const char *filename)
1435 {
1436     AVFormatContext *oc;
1437     int i, j, err;
1438     AVOutputFormat *file_oformat;
1439     OutputStream *ost;
1440     InputStream  *ist;
1441
1442     if (configure_complex_filters() < 0) {
1443         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1444         exit(1);
1445     }
1446
1447     if (!strcmp(filename, "-"))
1448         filename = "pipe:";
1449
1450     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1451     if (!oc) {
1452         print_error(filename, err);
1453         exit(1);
1454     }
1455     file_oformat= oc->oformat;
1456     oc->interrupt_callback = int_cb;
1457
1458     /* create streams for all unlabeled output pads */
1459     for (i = 0; i < nb_filtergraphs; i++) {
1460         FilterGraph *fg = filtergraphs[i];
1461         for (j = 0; j < fg->nb_outputs; j++) {
1462             OutputFilter *ofilter = fg->outputs[j];
1463
1464             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1465                 continue;
1466
1467             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1468                                           ofilter->out_tmp->pad_idx)) {
1469             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1470             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1471             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1472             }
1473             init_output_filter(ofilter, o, oc);
1474         }
1475     }
1476
1477     if (!strcmp(file_oformat->name, "ffm") &&
1478         av_strstart(filename, "http:", NULL)) {
1479         int j;
1480         /* special case for files sent to ffserver: we get the stream
1481            parameters from ffserver */
1482         int err = read_ffserver_streams(o, oc, filename);
1483         if (err < 0) {
1484             print_error(filename, err);
1485             exit(1);
1486         }
1487         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1488             ost = output_streams[j];
1489             for (i = 0; i < nb_input_streams; i++) {
1490                 ist = input_streams[i];
1491                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1492                     ost->sync_ist= ist;
1493                     ost->source_index= i;
1494                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1495                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1496                     ist->discard = 0;
1497                     ist->st->discard = AVDISCARD_NONE;
1498                     break;
1499                 }
1500             }
1501             if(!ost->sync_ist){
1502                 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));
1503                 exit(1);
1504             }
1505         }
1506     } else if (!o->nb_stream_maps) {
1507         char *subtitle_codec_name = NULL;
1508         /* pick the "best" stream of each type */
1509
1510         /* video: highest resolution */
1511         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1512             int area = 0, idx = -1;
1513             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1514             for (i = 0; i < nb_input_streams; i++) {
1515                 int new_area;
1516                 ist = input_streams[i];
1517                 new_area = ist->st->codec->width * ist->st->codec->height;
1518                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1519                     new_area = 1;
1520                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1521                     new_area > area) {
1522                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1523                         continue;
1524                     area = new_area;
1525                     idx = i;
1526                 }
1527             }
1528             if (idx >= 0)
1529                 new_video_stream(o, oc, idx);
1530         }
1531
1532         /* audio: most channels */
1533         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1534             int channels = 0, idx = -1;
1535             for (i = 0; i < nb_input_streams; i++) {
1536                 ist = input_streams[i];
1537                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1538                     ist->st->codec->channels > channels) {
1539                     channels = ist->st->codec->channels;
1540                     idx = i;
1541                 }
1542             }
1543             if (idx >= 0)
1544                 new_audio_stream(o, oc, idx);
1545         }
1546
1547         /* subtitles: pick first */
1548         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1549         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1550             for (i = 0; i < nb_input_streams; i++)
1551                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1552                     new_subtitle_stream(o, oc, i);
1553                     break;
1554                 }
1555         }
1556         /* do something with data? */
1557     } else {
1558         for (i = 0; i < o->nb_stream_maps; i++) {
1559             StreamMap *map = &o->stream_maps[i];
1560             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1561
1562             if (map->disabled)
1563                 continue;
1564
1565             if (map->linklabel) {
1566                 FilterGraph *fg;
1567                 OutputFilter *ofilter = NULL;
1568                 int j, k;
1569
1570                 for (j = 0; j < nb_filtergraphs; j++) {
1571                     fg = filtergraphs[j];
1572                     for (k = 0; k < fg->nb_outputs; k++) {
1573                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1574                         if (out && !strcmp(out->name, map->linklabel)) {
1575                             ofilter = fg->outputs[k];
1576                             goto loop_end;
1577                         }
1578                     }
1579                 }
1580 loop_end:
1581                 if (!ofilter) {
1582                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1583                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1584                     exit(1);
1585                 }
1586                 init_output_filter(ofilter, o, oc);
1587             } else {
1588                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1589                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1590                     continue;
1591                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1592                     continue;
1593                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1594                     continue;
1595                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1596                     continue;
1597
1598                 switch (ist->st->codec->codec_type) {
1599                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1600                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1601                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1602                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1603                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1604                 default:
1605                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1606                            map->file_index, map->stream_index);
1607                     exit(1);
1608                 }
1609             }
1610         }
1611     }
1612
1613     /* handle attached files */
1614     for (i = 0; i < o->nb_attachments; i++) {
1615         AVIOContext *pb;
1616         uint8_t *attachment;
1617         const char *p;
1618         int64_t len;
1619
1620         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1621             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1622                    o->attachments[i]);
1623             exit(1);
1624         }
1625         if ((len = avio_size(pb)) <= 0) {
1626             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1627                    o->attachments[i]);
1628             exit(1);
1629         }
1630         if (!(attachment = av_malloc(len))) {
1631             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1632                    o->attachments[i]);
1633             exit(1);
1634         }
1635         avio_read(pb, attachment, len);
1636
1637         ost = new_attachment_stream(o, oc, -1);
1638         ost->stream_copy               = 0;
1639         ost->attachment_filename       = o->attachments[i];
1640         ost->finished                  = 1;
1641         ost->st->codec->extradata      = attachment;
1642         ost->st->codec->extradata_size = len;
1643
1644         p = strrchr(o->attachments[i], '/');
1645         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1646         avio_close(pb);
1647     }
1648
1649     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1650         AVDictionaryEntry *e;
1651         ost = output_streams[i];
1652
1653         if ((ost->stream_copy || ost->attachment_filename)
1654             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1655             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1656             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1657                 exit(1);
1658     }
1659
1660     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1661         o->stop_time = INT64_MAX;
1662         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1663     }
1664
1665     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1666         if (o->stop_time <= o->start_time) {
1667             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1668             o->stop_time = INT64_MAX;
1669         } else {
1670             o->recording_time = o->stop_time - o->start_time;
1671         }
1672     }
1673
1674     GROW_ARRAY(output_files, nb_output_files);
1675     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1676         exit(1);
1677
1678     output_files[nb_output_files - 1]->ctx            = oc;
1679     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1680     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1681     if (o->recording_time != INT64_MAX)
1682         oc->duration = o->recording_time;
1683     output_files[nb_output_files - 1]->start_time     = o->start_time;
1684     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1685     output_files[nb_output_files - 1]->shortest       = o->shortest;
1686     av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1687
1688     /* check filename in case of an image number is expected */
1689     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1690         if (!av_filename_number_test(oc->filename)) {
1691             print_error(oc->filename, AVERROR(EINVAL));
1692             exit(1);
1693         }
1694     }
1695
1696     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1697         /* test if it already exists to avoid losing precious files */
1698         assert_file_overwrite(filename);
1699
1700         /* open the file */
1701         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1702                               &oc->interrupt_callback,
1703                               &output_files[nb_output_files - 1]->opts)) < 0) {
1704             print_error(filename, err);
1705             exit(1);
1706         }
1707     }
1708
1709     if (o->mux_preload) {
1710         uint8_t buf[64];
1711         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1712         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1713     }
1714     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1715
1716     /* copy metadata */
1717     for (i = 0; i < o->nb_metadata_map; i++) {
1718         char *p;
1719         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1720
1721         if (in_file_index >= nb_input_files) {
1722             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1723             exit(1);
1724         }
1725         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1726                       in_file_index >= 0 ?
1727                       input_files[in_file_index]->ctx : NULL, o);
1728     }
1729
1730     /* copy chapters */
1731     if (o->chapters_input_file >= nb_input_files) {
1732         if (o->chapters_input_file == INT_MAX) {
1733             /* copy chapters from the first input file that has them*/
1734             o->chapters_input_file = -1;
1735             for (i = 0; i < nb_input_files; i++)
1736                 if (input_files[i]->ctx->nb_chapters) {
1737                     o->chapters_input_file = i;
1738                     break;
1739                 }
1740         } else {
1741             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1742                    o->chapters_input_file);
1743             exit(1);
1744         }
1745     }
1746     if (o->chapters_input_file >= 0)
1747         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1748                       !o->metadata_chapters_manual);
1749
1750     /* copy global metadata by default */
1751     if (!o->metadata_global_manual && nb_input_files){
1752         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1753                      AV_DICT_DONT_OVERWRITE);
1754         if(o->recording_time != INT64_MAX)
1755             av_dict_set(&oc->metadata, "duration", NULL, 0);
1756         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1757     }
1758     if (!o->metadata_streams_manual)
1759         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1760             InputStream *ist;
1761             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1762                 continue;
1763             ist = input_streams[output_streams[i]->source_index];
1764             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1765         }
1766
1767     /* process manually set metadata */
1768     for (i = 0; i < o->nb_metadata; i++) {
1769         AVDictionary **m;
1770         char type, *val;
1771         const char *stream_spec;
1772         int index = 0, j, ret = 0;
1773
1774         val = strchr(o->metadata[i].u.str, '=');
1775         if (!val) {
1776             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1777                    o->metadata[i].u.str);
1778             exit(1);
1779         }
1780         *val++ = 0;
1781
1782         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1783         if (type == 's') {
1784             for (j = 0; j < oc->nb_streams; j++) {
1785                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1786                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1787                 } else if (ret < 0)
1788                     exit(1);
1789             }
1790         }
1791         else {
1792             switch (type) {
1793             case 'g':
1794                 m = &oc->metadata;
1795                 break;
1796             case 'c':
1797                 if (index < 0 || index >= oc->nb_chapters) {
1798                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1799                     exit(1);
1800                 }
1801                 m = &oc->chapters[index]->metadata;
1802                 break;
1803             default:
1804                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1805                 exit(1);
1806             }
1807             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1808         }
1809     }
1810
1811     return 0;
1812 }
1813
1814 static int opt_target(void *optctx, const char *opt, const char *arg)
1815 {
1816     OptionsContext *o = optctx;
1817     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1818     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1819
1820     if (!strncmp(arg, "pal-", 4)) {
1821         norm = PAL;
1822         arg += 4;
1823     } else if (!strncmp(arg, "ntsc-", 5)) {
1824         norm = NTSC;
1825         arg += 5;
1826     } else if (!strncmp(arg, "film-", 5)) {
1827         norm = FILM;
1828         arg += 5;
1829     } else {
1830         /* Try to determine PAL/NTSC by peeking in the input files */
1831         if (nb_input_files) {
1832             int i, j, fr;
1833             for (j = 0; j < nb_input_files; j++) {
1834                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1835                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1836                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1837                         continue;
1838                     fr = c->time_base.den * 1000 / c->time_base.num;
1839                     if (fr == 25000) {
1840                         norm = PAL;
1841                         break;
1842                     } else if ((fr == 29970) || (fr == 23976)) {
1843                         norm = NTSC;
1844                         break;
1845                     }
1846                 }
1847                 if (norm != UNKNOWN)
1848                     break;
1849             }
1850         }
1851         if (norm != UNKNOWN)
1852             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1853     }
1854
1855     if (norm == UNKNOWN) {
1856         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1857         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1858         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1859         exit(1);
1860     }
1861
1862     if (!strcmp(arg, "vcd")) {
1863         opt_video_codec(o, "c:v", "mpeg1video");
1864         opt_audio_codec(o, "c:a", "mp2");
1865         parse_option(o, "f", "vcd", options);
1866         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1867
1868         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1869         parse_option(o, "r", frame_rates[norm], options);
1870         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1871
1872         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1873         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1874         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1875         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1876
1877         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1878         parse_option(o, "ar", "44100", options);
1879         parse_option(o, "ac", "2", options);
1880
1881         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1882         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1883
1884         /* We have to offset the PTS, so that it is consistent with the SCR.
1885            SCR starts at 36000, but the first two packs contain only padding
1886            and the first pack from the other stream, respectively, may also have
1887            been written before.
1888            So the real data starts at SCR 36000+3*1200. */
1889         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1890     } else if (!strcmp(arg, "svcd")) {
1891
1892         opt_video_codec(o, "c:v", "mpeg2video");
1893         opt_audio_codec(o, "c:a", "mp2");
1894         parse_option(o, "f", "svcd", options);
1895
1896         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1897         parse_option(o, "r", frame_rates[norm], options);
1898         parse_option(o, "pix_fmt", "yuv420p", options);
1899         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1900
1901         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1902         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1903         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1904         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1905         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1906
1907         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1908         parse_option(o, "ar", "44100", options);
1909
1910         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1911
1912     } else if (!strcmp(arg, "dvd")) {
1913
1914         opt_video_codec(o, "c:v", "mpeg2video");
1915         opt_audio_codec(o, "c:a", "ac3");
1916         parse_option(o, "f", "dvd", options);
1917
1918         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1919         parse_option(o, "r", frame_rates[norm], options);
1920         parse_option(o, "pix_fmt", "yuv420p", options);
1921         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1922
1923         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1924         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1925         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1926         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1927
1928         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.
1929         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1930
1931         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1932         parse_option(o, "ar", "48000", options);
1933
1934     } else if (!strncmp(arg, "dv", 2)) {
1935
1936         parse_option(o, "f", "dv", options);
1937
1938         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1939         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1940                           norm == PAL ? "yuv420p" : "yuv411p", options);
1941         parse_option(o, "r", frame_rates[norm], options);
1942
1943         parse_option(o, "ar", "48000", options);
1944         parse_option(o, "ac", "2", options);
1945
1946     } else {
1947         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1948         return AVERROR(EINVAL);
1949     }
1950     return 0;
1951 }
1952
1953 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1954 {
1955     av_free (vstats_filename);
1956     vstats_filename = av_strdup (arg);
1957     return 0;
1958 }
1959
1960 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1961 {
1962     char filename[40];
1963     time_t today2 = time(NULL);
1964     struct tm *today = localtime(&today2);
1965
1966     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1967              today->tm_sec);
1968     return opt_vstats_file(NULL, opt, filename);
1969 }
1970
1971 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1972 {
1973     OptionsContext *o = optctx;
1974     return parse_option(o, "frames:v", arg, options);
1975 }
1976
1977 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1978 {
1979     OptionsContext *o = optctx;
1980     return parse_option(o, "frames:a", arg, options);
1981 }
1982
1983 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1984 {
1985     OptionsContext *o = optctx;
1986     return parse_option(o, "frames:d", arg, options);
1987 }
1988
1989 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1990 {
1991     int ret;
1992     AVDictionary *cbak = codec_opts;
1993     AVDictionary *fbak = format_opts;
1994     codec_opts = NULL;
1995     format_opts = NULL;
1996
1997     ret = opt_default(NULL, opt, arg);
1998
1999     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2000     av_dict_copy(&o->g->format_opts, format_opts, 0);
2001     av_dict_free(&codec_opts);
2002     av_dict_free(&format_opts);
2003     codec_opts = cbak;
2004     format_opts = fbak;
2005
2006     return ret;
2007 }
2008
2009 static int opt_preset(void *optctx, const char *opt, const char *arg)
2010 {
2011     OptionsContext *o = optctx;
2012     FILE *f=NULL;
2013     char filename[1000], line[1000], tmp_line[1000];
2014     const char *codec_name = NULL;
2015
2016     tmp_line[0] = *opt;
2017     tmp_line[1] = 0;
2018     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2019
2020     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2021         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2022             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2023         }else
2024             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2025         exit(1);
2026     }
2027
2028     while (fgets(line, sizeof(line), f)) {
2029         char *key = tmp_line, *value, *endptr;
2030
2031         if (strcspn(line, "#\n\r") == 0)
2032             continue;
2033         strcpy(tmp_line, line);
2034         if (!av_strtok(key,   "=",    &value) ||
2035             !av_strtok(value, "\r\n", &endptr)) {
2036             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2037             exit(1);
2038         }
2039         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2040
2041         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2042         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2043         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2044         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2045         else if (opt_default_new(o, key, value) < 0) {
2046             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2047                    filename, line, key, value);
2048             exit(1);
2049         }
2050     }
2051
2052     fclose(f);
2053
2054     return 0;
2055 }
2056
2057 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2058 {
2059     OptionsContext *o = optctx;
2060     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2061     int ret = parse_option(o, s, arg, options);
2062     av_free(s);
2063     return ret;
2064 }
2065
2066 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2067 {
2068     OptionsContext *o = optctx;
2069     if(!strcmp(opt, "b")){
2070         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2071         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2072         return 0;
2073     }
2074     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2075     return 0;
2076 }
2077
2078 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2079 {
2080     OptionsContext *o = optctx;
2081     char *s;
2082     int ret;
2083     if(!strcmp(opt, "qscale")){
2084         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2085         return parse_option(o, "q:v", arg, options);
2086     }
2087     s = av_asprintf("q%s", opt + 6);
2088     ret = parse_option(o, s, arg, options);
2089     av_free(s);
2090     return ret;
2091 }
2092
2093 static int opt_profile(void *optctx, const char *opt, const char *arg)
2094 {
2095     OptionsContext *o = optctx;
2096     if(!strcmp(opt, "profile")){
2097         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2098         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2099         return 0;
2100     }
2101     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2102     return 0;
2103 }
2104
2105 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2106 {
2107     OptionsContext *o = optctx;
2108     return parse_option(o, "filter:v", arg, options);
2109 }
2110
2111 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2112 {
2113     OptionsContext *o = optctx;
2114     return parse_option(o, "filter:a", arg, options);
2115 }
2116
2117 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2118 {
2119     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2120     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2121     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2122     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2123
2124     if (video_sync_method == VSYNC_AUTO)
2125         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2126     return 0;
2127 }
2128
2129 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2130 {
2131     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2132     do_deinterlace = 1;
2133     return 0;
2134 }
2135
2136 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2137 {
2138     OptionsContext *o = optctx;
2139     char *tcr = av_asprintf("timecode=%s", arg);
2140     int ret = parse_option(o, "metadata:g", tcr, options);
2141     if (ret >= 0)
2142         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2143     av_free(tcr);
2144     return 0;
2145 }
2146
2147 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2148 {
2149     OptionsContext *o = optctx;
2150     char layout_str[32];
2151     char *stream_str;
2152     char *ac_str;
2153     int ret, channels, ac_str_size;
2154     uint64_t layout;
2155
2156     layout = av_get_channel_layout(arg);
2157     if (!layout) {
2158         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2159         return AVERROR(EINVAL);
2160     }
2161     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2162     ret = opt_default_new(o, opt, layout_str);
2163     if (ret < 0)
2164         return ret;
2165
2166     /* set 'ac' option based on channel layout */
2167     channels = av_get_channel_layout_nb_channels(layout);
2168     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2169     stream_str = strchr(opt, ':');
2170     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2171     ac_str = av_mallocz(ac_str_size);
2172     if (!ac_str)
2173         return AVERROR(ENOMEM);
2174     av_strlcpy(ac_str, "ac", 3);
2175     if (stream_str)
2176         av_strlcat(ac_str, stream_str, ac_str_size);
2177     ret = parse_option(o, ac_str, layout_str, options);
2178     av_free(ac_str);
2179
2180     return ret;
2181 }
2182
2183 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2184 {
2185     OptionsContext *o = optctx;
2186     return parse_option(o, "q:a", arg, options);
2187 }
2188
2189 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2190 {
2191     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2192     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2193         return AVERROR(ENOMEM);
2194     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2195     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2196     return 0;
2197 }
2198
2199 void show_help_default(const char *opt, const char *arg)
2200 {
2201     /* per-file options have at least one of those set */
2202     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2203     int show_advanced = 0, show_avoptions = 0;
2204
2205     if (opt && *opt) {
2206         if (!strcmp(opt, "long"))
2207             show_advanced = 1;
2208         else if (!strcmp(opt, "full"))
2209             show_advanced = show_avoptions = 1;
2210         else
2211             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2212     }
2213
2214     show_usage();
2215
2216     printf("Getting help:\n"
2217            "    -h      -- print basic options\n"
2218            "    -h long -- print more options\n"
2219            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2220            "    See man %s for detailed description of the options.\n"
2221            "\n", program_name);
2222
2223     show_help_options(options, "Print help / information / capabilities:",
2224                       OPT_EXIT, 0, 0);
2225
2226     show_help_options(options, "Global options (affect whole program "
2227                       "instead of just one file:",
2228                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2229     if (show_advanced)
2230         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2231                           per_file | OPT_EXIT, 0);
2232
2233     show_help_options(options, "Per-file main options:", 0,
2234                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2235                       OPT_EXIT, per_file);
2236     if (show_advanced)
2237         show_help_options(options, "Advanced per-file options:",
2238                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2239
2240     show_help_options(options, "Video options:",
2241                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2242     if (show_advanced)
2243         show_help_options(options, "Advanced Video options:",
2244                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2245
2246     show_help_options(options, "Audio options:",
2247                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2248     if (show_advanced)
2249         show_help_options(options, "Advanced Audio options:",
2250                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2251     show_help_options(options, "Subtitle options:",
2252                       OPT_SUBTITLE, 0, 0);
2253     printf("\n");
2254
2255     if (show_avoptions) {
2256         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2257         show_help_children(avcodec_get_class(), flags);
2258         show_help_children(avformat_get_class(), flags);
2259         show_help_children(sws_get_class(), flags);
2260         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2261         show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2262     }
2263 }
2264
2265 void show_usage(void)
2266 {
2267     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2268     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2269     av_log(NULL, AV_LOG_INFO, "\n");
2270 }
2271
2272 enum OptGroup {
2273     GROUP_OUTFILE,
2274     GROUP_INFILE,
2275 };
2276
2277 static const OptionGroupDef groups[] = {
2278     [GROUP_OUTFILE] = { "output file",  NULL },
2279     [GROUP_INFILE]  = { "input file",   "i"  },
2280 };
2281
2282 static int open_files(OptionGroupList *l, const char *inout,
2283                       int (*open_file)(OptionsContext*, const char*))
2284 {
2285     int i, ret;
2286
2287     for (i = 0; i < l->nb_groups; i++) {
2288         OptionGroup *g = &l->groups[i];
2289         OptionsContext o;
2290
2291         init_options(&o, !strcmp(inout, "input"));
2292         o.g = g;
2293
2294         ret = parse_optgroup(&o, g);
2295         if (ret < 0) {
2296             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2297                    "%s.\n", inout, g->arg);
2298             return ret;
2299         }
2300
2301         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2302         ret = open_file(&o, g->arg);
2303         uninit_options(&o, !strcmp(inout, "input"));
2304         if (ret < 0) {
2305             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2306                    inout, g->arg);
2307             return ret;
2308         }
2309         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2310     }
2311
2312     return 0;
2313 }
2314
2315 int ffmpeg_parse_options(int argc, char **argv)
2316 {
2317     OptionParseContext octx;
2318     uint8_t error[128];
2319     int ret;
2320
2321     memset(&octx, 0, sizeof(octx));
2322
2323     /* split the commandline into an internal representation */
2324     ret = split_commandline(&octx, argc, argv, options, groups,
2325                             FF_ARRAY_ELEMS(groups));
2326     if (ret < 0) {
2327         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2328         goto fail;
2329     }
2330
2331     /* apply global options */
2332     ret = parse_optgroup(NULL, &octx.global_opts);
2333     if (ret < 0) {
2334         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2335         goto fail;
2336     }
2337
2338     /* open input files */
2339     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2340     if (ret < 0) {
2341         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2342         goto fail;
2343     }
2344
2345     /* open output files */
2346     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2347     if (ret < 0) {
2348         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2349         goto fail;
2350     }
2351
2352 fail:
2353     uninit_parse_context(&octx);
2354     if (ret < 0) {
2355         av_strerror(ret, error, sizeof(error));
2356         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2357     }
2358     return ret;
2359 }
2360
2361 static int opt_progress(void *optctx, const char *opt, const char *arg)
2362 {
2363     AVIOContext *avio = NULL;
2364     int ret;
2365
2366     if (!strcmp(arg, "-"))
2367         arg = "pipe:";
2368     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2369     if (ret < 0) {
2370         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2371                arg, av_err2str(ret));
2372         return ret;
2373     }
2374     progress_avio = avio;
2375     return 0;
2376 }
2377
2378 #define OFFSET(x) offsetof(OptionsContext, x)
2379 const OptionDef options[] = {
2380     /* main options */
2381 #include "cmdutils_common_opts.h"
2382     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
2383         "force format", "fmt" },
2384     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2385         "overwrite output files" },
2386     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2387         "do not overwrite output files" },
2388     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2389         "codec name", "codec" },
2390     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2391         "codec name", "codec" },
2392     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
2393         "preset name", "preset" },
2394     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map },
2395         "set input stream mapping",
2396         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2397     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map_channel },
2398         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2399     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
2400         "set metadata information of outfile from infile",
2401         "outfile[,metadata]:infile[,metadata]" },
2402     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2403         "set chapters mapping", "input_file_index" },
2404     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
2405         "record or transcode \"duration\" seconds of audio/video",
2406         "duration" },
2407     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(stop_time) },
2408         "record or transcode stop time", "time_stop" },
2409     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
2410         "set the limit file size in bytes", "limit_size" },
2411     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
2412         "set the start time offset", "time_off" },
2413     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2414         "set the input ts offset", "time_off" },
2415     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2416         "set the input ts scale", "scale" },
2417     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2418         "set the recording timestamp ('now' to set the current time)", "time" },
2419     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
2420         "add metadata", "string=string" },
2421     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_data_frames },
2422         "set the number of data frames to record", "number" },
2423     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2424         "add timings for benchmarking" },
2425     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2426       "add timings for each task" },
2427     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2428       "write program-readable progress information", "url" },
2429     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2430       "enable or disable interaction on standard input" },
2431     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2432         "set max runtime in seconds", "limit" },
2433     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2434         "dump each input packet" },
2435     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2436         "when dumping packets, also dump the payload" },
2437     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
2438         "read input at native frame rate", "" },
2439     { "target",         HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_target },
2440         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2441         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2442     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2443         "video sync method", "" },
2444     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2445         "audio sync method", "" },
2446     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2447         "audio drift threshold", "threshold" },
2448     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2449         "copy timestamps" },
2450     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2451         "copy input stream time base when stream copying", "mode" },
2452     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
2453         "finish encoding within shortest input" },
2454     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2455         "timestamp discontinuity delta threshold", "threshold" },
2456     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2457         "timestamp error delta threshold", "threshold" },
2458     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2459         "exit on error", "error" },
2460     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
2461         "copy initial non-keyframes" },
2462     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC,   { .off = OFFSET(copy_prior_start) },
2463         "copy or discard frames before start time" },
2464     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
2465         "set the number of frames to record", "number" },
2466     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2467         "force codec tag/fourcc", "fourcc/tag" },
2468     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2469         "use fixed quality scale (VBR)", "q" },
2470     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_qscale },
2471         "use fixed quality scale (VBR)", "q" },
2472     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_profile },
2473         "set profile", "profile" },
2474     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
2475         "set stream filtergraph", "filter_graph" },
2476     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC,                { .off = OFFSET(reinit_filters) },
2477         "reinit filtergraph on input parameter changes", "" },
2478     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2479         "create a complex filtergraph", "graph_description" },
2480     { "stats",          OPT_BOOL,                                    { &print_stats },
2481         "print progress report during encoding", },
2482     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_attach },
2483         "add an attachment to the output file", "filename" },
2484     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2485         "extract an attachment into a file", "filename" },
2486     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2487         "print timestamp debugging info" },
2488
2489     /* video options */
2490     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_frames },
2491         "set the number of video frames to record", "number" },
2492     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
2493         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2494     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2495         "set frame size (WxH or abbreviation)", "size" },
2496     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
2497         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2498     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2499         "set pixel format", "format" },
2500     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2501         "set the number of bits per raw sample", "number" },
2502     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2503         "deprecated use -g 1" },
2504     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
2505         "disable video" },
2506     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2507         "discard threshold", "n" },
2508     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2509         "rate control override for specific intervals", "override" },
2510     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_codec },
2511         "force video codec ('copy' to copy stream)", "codec" },
2512     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2513         "Removed" },
2514     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2515         "Removed" },
2516     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_timecode },
2517         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2518     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
2519         "select the pass number (1 to 3)", "n" },
2520     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
2521         "select two pass log file name prefix", "prefix" },
2522     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2523         "this option is deprecated, use the yadif filter instead" },
2524     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2525         "calculate PSNR of compressed frames" },
2526     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2527         "dump video coding statistics to file" },
2528     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2529         "dump video coding statistics to file", "file" },
2530     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
2531         "set video filters", "filter_graph" },
2532     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2533         "specify intra matrix coeffs", "matrix" },
2534     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2535         "specify inter matrix coeffs", "matrix" },
2536     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
2537         "top=1/bottom=0/auto=-1 field first", "" },
2538     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2539         "intra_dc_precision", "precision" },
2540     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_old2new },
2541         "force video tag/fourcc", "fourcc/tag" },
2542     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2543         "show QP histogram" },
2544     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
2545         "force the selected framerate, disable the best supported framerate selection" },
2546     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
2547         "set the value of an outfile streamid", "streamIndex:value" },
2548     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2549         { .off = OFFSET(forced_key_frames) },
2550         "force key frames at specified timestamps", "timestamps" },
2551     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_bitrate },
2552         "video bitrate (please use -b:v)", "bitrate" },
2553
2554     /* audio options */
2555     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
2556         "set the number of audio frames to record", "number" },
2557     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
2558         "set audio quality (codec-specific)", "quality", },
2559     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2560         "set audio sampling rate (in Hz)", "rate" },
2561     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2562         "set number of audio channels", "channels" },
2563     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2564         "disable audio" },
2565     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
2566         "force audio codec ('copy' to copy stream)", "codec" },
2567     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_old2new },
2568         "force audio tag/fourcc", "fourcc/tag" },
2569     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2570         "change audio volume (256=normal)" , "volume" },
2571     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2572         "set sample format", "format" },
2573     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
2574         "set channel layout", "layout" },
2575     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
2576         "set audio filters", "filter_graph" },
2577     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT,   { .off = OFFSET(guess_layout_max) },
2578       "set the maximum number of channels to try to guess the channel layout" },
2579
2580     /* subtitle options */
2581     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2582         "disable subtitle" },
2583     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2584         "force subtitle codec ('copy' to copy stream)", "codec" },
2585     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_old2new }
2586         , "force subtitle tag/fourcc", "fourcc/tag" },
2587     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2588         "fix subtitles duration" },
2589
2590     /* grab options */
2591     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2592         "deprecated, use -channel", "channel" },
2593     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2594         "deprecated, use -standard", "standard" },
2595     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2596
2597     /* muxer options */
2598     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2599         "set the maximum demux-decode delay", "seconds" },
2600     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2601         "set the initial demux-decode delay", "seconds" },
2602
2603     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2604         "A comma-separated list of bitstream filters", "bitstream_filters" },
2605     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2606         "deprecated", "audio bitstream_filters" },
2607     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2608         "deprecated", "video bitstream_filters" },
2609
2610     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2611         "set the audio options to the indicated preset", "preset" },
2612     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2613         "set the video options to the indicated preset", "preset" },
2614     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2615         "set the subtitle options to the indicated preset", "preset" },
2616     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE,                { .func_arg = opt_preset },
2617         "set options from indicated preset file", "filename" },
2618     /* data codec support */
2619     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2620         "force data codec ('copy' to copy stream)", "codec" },
2621     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2622         "disable data" },
2623
2624     { NULL, },
2625 };