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

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