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

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