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

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