ffmpeg_opt.c

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