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