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         if (next = strchr(bsf, ','))
1142             *next++ = 0;
1143         if (!(bsfc = av_bitstream_filter_init(bsf))) {
1144             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1145             exit_program(1);
1146         }
1147         if (bsfc_prev)
1148             bsfc_prev->next = bsfc;
1149         else
1150             ost->bitstream_filters = bsfc;
1151
1152         bsfc_prev = bsfc;
1153         bsf       = next;
1154     }
1155
1156     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1157     if (codec_tag) {
1158         uint32_t tag = strtol(codec_tag, &next, 0);
1159         if (*next)
1160             tag = AV_RL32(codec_tag);
1161         ost->enc_ctx->codec_tag = tag;
1162     }
1163
1164     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1165     if (qscale >= 0) {
1166         ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1167         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1168     }
1169
1170     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1171         ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1172
1173     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1174
1175     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1176     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1177         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1178
1179     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1180
1181     ost->source_index = source_index;
1182     if (source_index >= 0) {
1183         ost->sync_ist = input_streams[source_index];
1184         input_streams[source_index]->discard = 0;
1185         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1186     }
1187     ost->last_mux_dts = AV_NOPTS_VALUE;
1188
1189     return ost;
1190 }
1191
1192 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1193 {
1194     int i;
1195     const char *p = str;
1196     for (i = 0;; i++) {
1197         dest[i] = atoi(p);
1198         if (i == 63)
1199             break;
1200         p = strchr(p, ',');
1201         if (!p) {
1202             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1203             exit_program(1);
1204         }
1205         p++;
1206     }
1207 }
1208
1209 /* read file contents into a string */
1210 static uint8_t *read_file(const char *filename)
1211 {
1212     AVIOContext *pb      = NULL;
1213     AVIOContext *dyn_buf = NULL;
1214     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1215     uint8_t buf[1024], *str;
1216
1217     if (ret < 0) {
1218         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1219         return NULL;
1220     }
1221
1222     ret = avio_open_dyn_buf(&dyn_buf);
1223     if (ret < 0) {
1224         avio_closep(&pb);
1225         return NULL;
1226     }
1227     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1228         avio_write(dyn_buf, buf, ret);
1229     avio_w8(dyn_buf, 0);
1230     avio_closep(&pb);
1231
1232     ret = avio_close_dyn_buf(dyn_buf, &str);
1233     if (ret < 0)
1234         return NULL;
1235     return str;
1236 }
1237
1238 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1239                              OutputStream *ost)
1240 {
1241     AVStream *st = ost->st;
1242
1243     if (ost->filters_script && ost->filters) {
1244         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1245                "output stream #%d:%d.\n", nb_output_files, st->index);
1246         exit_program(1);
1247     }
1248
1249     if (ost->filters_script)
1250         return read_file(ost->filters_script);
1251     else if (ost->filters)
1252         return av_strdup(ost->filters);
1253
1254     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1255                      "null" : "anull");
1256 }
1257
1258 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1259                                      const OutputStream *ost, enum AVMediaType type)
1260 {
1261     if (ost->filters_script || ost->filters) {
1262         av_log(NULL, AV_LOG_ERROR,
1263                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1264                "Filtering and streamcopy cannot be used together.\n",
1265                ost->filters ? "Filtergraph" : "Filtergraph script",
1266                ost->filters ? ost->filters : ost->filters_script,
1267                av_get_media_type_string(type), ost->file_index, ost->index);
1268         exit_program(1);
1269     }
1270 }
1271
1272 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1273 {
1274     AVStream *st;
1275     OutputStream *ost;
1276     AVCodecContext *video_enc;
1277     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1278
1279     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1280     st  = ost->st;
1281     video_enc = ost->enc_ctx;
1282
1283     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1284     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1285         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1286         exit_program(1);
1287     }
1288     if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1289         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1290
1291     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1292     if (frame_aspect_ratio) {
1293         AVRational q;
1294         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1295             q.num <= 0 || q.den <= 0) {
1296             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1297             exit_program(1);
1298         }
1299         ost->frame_aspect_ratio = q;
1300     }
1301
1302     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1303     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1304
1305     if (!ost->stream_copy) {
1306         const char *p = NULL;
1307         char *frame_size = NULL;
1308         char *frame_pix_fmt = NULL;
1309         char *intra_matrix = NULL, *inter_matrix = NULL;
1310         char *chroma_intra_matrix = NULL;
1311         int do_pass = 0;
1312         int i;
1313
1314         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1315         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1316             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1317             exit_program(1);
1318         }
1319
1320         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1321         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1322         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1323             ost->keep_pix_fmt = 1;
1324             if (!*++frame_pix_fmt)
1325                 frame_pix_fmt = NULL;
1326         }
1327         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1328             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1329             exit_program(1);
1330         }
1331         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1332
1333         if (intra_only)
1334             video_enc->gop_size = 0;
1335         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1336         if (intra_matrix) {
1337             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1338                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1339                 exit_program(1);
1340             }
1341             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1342         }
1343         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1344         if (chroma_intra_matrix) {
1345             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1346             if (!p) {
1347                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1348                 exit_program(1);
1349             }
1350             av_codec_set_chroma_intra_matrix(video_enc, p);
1351             parse_matrix_coeffs(p, chroma_intra_matrix);
1352         }
1353         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1354         if (inter_matrix) {
1355             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1356                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1357                 exit_program(1);
1358             }
1359             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1360         }
1361
1362         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1363         for (i = 0; p; i++) {
1364             int start, end, q;
1365             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1366             if (e != 3) {
1367                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1368                 exit_program(1);
1369             }
1370             /* FIXME realloc failure */
1371             video_enc->rc_override =
1372                 av_realloc(video_enc->rc_override,
1373                            sizeof(RcOverride) * (i + 1));
1374             video_enc->rc_override[i].start_frame = start;
1375             video_enc->rc_override[i].end_frame   = end;
1376             if (q > 0) {
1377                 video_enc->rc_override[i].qscale         = q;
1378                 video_enc->rc_override[i].quality_factor = 1.0;
1379             }
1380             else {
1381                 video_enc->rc_override[i].qscale         = 0;
1382                 video_enc->rc_override[i].quality_factor = -q/100.0;
1383             }
1384             p = strchr(p, '/');
1385             if (p) p++;
1386         }
1387         video_enc->rc_override_count = i;
1388
1389         if (do_psnr)
1390             video_enc->flags|= CODEC_FLAG_PSNR;
1391
1392         /* two pass mode */
1393         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1394         if (do_pass) {
1395             if (do_pass & 1) {
1396                 video_enc->flags |= CODEC_FLAG_PASS1;
1397                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1398             }
1399             if (do_pass & 2) {
1400                 video_enc->flags |= CODEC_FLAG_PASS2;
1401                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1402             }
1403         }
1404
1405         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1406         if (ost->logfile_prefix &&
1407             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1408             exit_program(1);
1409
1410         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1411         if (ost->forced_keyframes)
1412             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1413
1414         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1415
1416         ost->top_field_first = -1;
1417         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1418
1419
1420         ost->avfilter = get_ost_filters(o, oc, ost);
1421         if (!ost->avfilter)
1422             exit_program(1);
1423     } else {
1424         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1425     }
1426
1427     if (ost->stream_copy)
1428         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1429
1430     return ost;
1431 }
1432
1433 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1434 {
1435     int n;
1436     AVStream *st;
1437     OutputStream *ost;
1438     AVCodecContext *audio_enc;
1439
1440     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1441     st  = ost->st;
1442
1443     audio_enc = ost->enc_ctx;
1444     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1445
1446     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1447     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1448
1449     if (!ost->stream_copy) {
1450         char *sample_fmt = NULL;
1451
1452         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1453
1454         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1455         if (sample_fmt &&
1456             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1457             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1458             exit_program(1);
1459         }
1460
1461         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1462
1463         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1464         ost->apad = av_strdup(ost->apad);
1465
1466         ost->avfilter = get_ost_filters(o, oc, ost);
1467         if (!ost->avfilter)
1468             exit_program(1);
1469
1470         /* check for channel mapping for this audio stream */
1471         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1472             AudioChannelMap *map = &o->audio_channel_maps[n];
1473             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1474                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1475                 InputStream *ist;
1476
1477                 if (map->channel_idx == -1) {
1478                     ist = NULL;
1479                 } else if (ost->source_index < 0) {
1480                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1481                            ost->file_index, ost->st->index);
1482                     continue;
1483                 } else {
1484                     ist = input_streams[ost->source_index];
1485                 }
1486
1487                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1488                     if (av_reallocp_array(&ost->audio_channels_map,
1489                                           ost->audio_channels_mapped + 1,
1490                                           sizeof(*ost->audio_channels_map)
1491                                           ) < 0 )
1492                         exit_program(1);
1493
1494                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1495                 }
1496             }
1497         }
1498     }
1499
1500     if (ost->stream_copy)
1501         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1502
1503     return ost;
1504 }
1505
1506 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1507 {
1508     OutputStream *ost;
1509
1510     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1511     if (!ost->stream_copy) {
1512         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1513         exit_program(1);
1514     }
1515
1516     return ost;
1517 }
1518
1519 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1520 {
1521     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1522     ost->stream_copy = 1;
1523     ost->finished    = 1;
1524     return ost;
1525 }
1526
1527 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1528 {
1529     AVStream *st;
1530     OutputStream *ost;
1531     AVCodecContext *subtitle_enc;
1532
1533     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1534     st  = ost->st;
1535     subtitle_enc = ost->enc_ctx;
1536
1537     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1538
1539     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1540
1541     if (!ost->stream_copy) {
1542         char *frame_size = NULL;
1543
1544         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1545         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1546             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1547             exit_program(1);
1548         }
1549     }
1550
1551     return ost;
1552 }
1553
1554 /* arg format is "output-stream-index:streamid-value". */
1555 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1556 {
1557     OptionsContext *o = optctx;
1558     int idx;
1559     char *p;
1560     char idx_str[16];
1561
1562     av_strlcpy(idx_str, arg, sizeof(idx_str));
1563     p = strchr(idx_str, ':');
1564     if (!p) {
1565         av_log(NULL, AV_LOG_FATAL,
1566                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1567                arg, opt);
1568         exit_program(1);
1569     }
1570     *p++ = '\0';
1571     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1572     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1573     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1574     return 0;
1575 }
1576
1577 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1578 {
1579     AVFormatContext *is = ifile->ctx;
1580     AVFormatContext *os = ofile->ctx;
1581     AVChapter **tmp;
1582     int i;
1583
1584     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1585     if (!tmp)
1586         return AVERROR(ENOMEM);
1587     os->chapters = tmp;
1588
1589     for (i = 0; i < is->nb_chapters; i++) {
1590         AVChapter *in_ch = is->chapters[i], *out_ch;
1591         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1592         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1593                                        AV_TIME_BASE_Q, in_ch->time_base);
1594         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1595                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1596
1597
1598         if (in_ch->end < ts_off)
1599             continue;
1600         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1601             break;
1602
1603         out_ch = av_mallocz(sizeof(AVChapter));
1604         if (!out_ch)
1605             return AVERROR(ENOMEM);
1606
1607         out_ch->id        = in_ch->id;
1608         out_ch->time_base = in_ch->time_base;
1609         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1610         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1611
1612         if (copy_metadata)
1613             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1614
1615         os->chapters[os->nb_chapters++] = out_ch;
1616     }
1617     return 0;
1618 }
1619
1620 static int ffserver_streams_copy_context(AVCodecContext *dest, const AVCodecContext *src,
1621                                          const char *configuration)
1622 {
1623     int ret;
1624     if ((ret = avcodec_copy_context(dest, src)) < 0)
1625         return ret;
1626     dest->codec = avcodec_find_encoder(src->codec_id);
1627     if (!dest->codec)
1628         return AVERROR(EINVAL);
1629     if (!dest->codec->priv_class || !dest->codec->priv_data_size)
1630         return 0;
1631     if (!dest->priv_data) {
1632         dest->priv_data = av_mallocz(dest->codec->priv_data_size);
1633         if (!dest->priv_data)
1634             return AVERROR(ENOMEM);
1635         *(const AVClass**)dest->priv_data = dest->codec->priv_class;
1636     }
1637     av_opt_set_defaults(dest->priv_data);
1638     if (av_set_options_string(dest->priv_data, configuration, "=", ",") < 0) {
1639         av_log(dest, AV_LOG_WARNING, "Cannot copy private codec options. Using defaults.\n");
1640         av_opt_set_defaults(dest->priv_data);
1641     }
1642     return 0;
1643 }
1644
1645 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1646 {
1647     int i, err;
1648     AVFormatContext *ic = avformat_alloc_context();
1649
1650     ic->interrupt_callback = int_cb;
1651     err = avformat_open_input(&ic, filename, NULL, NULL);
1652     if (err < 0)
1653         return err;
1654     /* copy stream format */
1655     for(i=0;i<ic->nb_streams;i++) {
1656         AVStream *st;
1657         OutputStream *ost;
1658         AVCodec *codec;
1659
1660         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1661         if (!codec) {
1662             av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1663             return AVERROR(EINVAL);
1664         }
1665         if (codec->type == AVMEDIA_TYPE_AUDIO)
1666             opt_audio_codec(o, "c:a", codec->name);
1667         else if (codec->type == AVMEDIA_TYPE_VIDEO)
1668             opt_video_codec(o, "c:v", codec->name);
1669         ost   = new_output_stream(o, s, codec->type, -1);
1670         st    = ost->st;
1671
1672         ffserver_streams_copy_context(st->codec, ic->streams[i]->codec,
1673                                       av_stream_get_recommended_encoder_configuration(ic->streams[i]));
1674
1675         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1676             choose_sample_fmt(st, codec);
1677         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1678             choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1679         ffserver_streams_copy_context(ost->enc_ctx, st->codec,
1680                                       av_stream_get_recommended_encoder_configuration(ic->streams[i]));
1681     }
1682
1683     avformat_close_input(&ic);
1684     return err;
1685 }
1686
1687 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1688                                AVFormatContext *oc)
1689 {
1690     OutputStream *ost;
1691
1692     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1693                                   ofilter->out_tmp->pad_idx)) {
1694     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1695     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1696     default:
1697         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1698                "currently.\n");
1699         exit_program(1);
1700     }
1701
1702     ost->source_index = -1;
1703     ost->filter       = ofilter;
1704
1705     ofilter->ost      = ost;
1706
1707     if (ost->stream_copy) {
1708         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1709                "which is fed from a complex filtergraph. Filtering and streamcopy "
1710                "cannot be used together.\n", ost->file_index, ost->index);
1711         exit_program(1);
1712     }
1713
1714     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1715         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1716         av_log(NULL, AV_LOG_ERROR,
1717                "%s '%s' was specified through the %s option "
1718                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1719                "%s and -filter_complex cannot be used together for the same stream.\n",
1720                ost->filters ? "Filtergraph" : "Filtergraph script",
1721                ost->filters ? ost->filters : ost->filters_script,
1722                opt, ost->file_index, ost->index, opt);
1723         exit_program(1);
1724     }
1725
1726     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1727         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1728         exit_program(1);
1729     }
1730     avfilter_inout_free(&ofilter->out_tmp);
1731 }
1732
1733 static int configure_complex_filters(void)
1734 {
1735     int i, ret = 0;
1736
1737     for (i = 0; i < nb_filtergraphs; i++)
1738         if (!filtergraphs[i]->graph &&
1739             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1740             return ret;
1741     return 0;
1742 }
1743
1744 static int open_output_file(OptionsContext *o, const char *filename)
1745 {
1746     AVFormatContext *oc;
1747     int i, j, err;
1748     AVOutputFormat *file_oformat;
1749     OutputFile *of;
1750     OutputStream *ost;
1751     InputStream  *ist;
1752     AVDictionary *unused_opts = NULL;
1753     AVDictionaryEntry *e = NULL;
1754
1755     if (configure_complex_filters() < 0) {
1756         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1757         exit_program(1);
1758     }
1759
1760     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1761         o->stop_time = INT64_MAX;
1762         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1763     }
1764
1765     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1766         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1767         if (o->stop_time <= start_time) {
1768             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1769             exit_program(1);
1770         } else {
1771             o->recording_time = o->stop_time - start_time;
1772         }
1773     }
1774
1775     GROW_ARRAY(output_files, nb_output_files);
1776     of = av_mallocz(sizeof(*of));
1777     if (!of)
1778         exit_program(1);
1779     output_files[nb_output_files - 1] = of;
1780
1781     of->ost_index      = nb_output_streams;
1782     of->recording_time = o->recording_time;
1783     of->start_time     = o->start_time;
1784     of->limit_filesize = o->limit_filesize;
1785     of->shortest       = o->shortest;
1786     av_dict_copy(&of->opts, o->g->format_opts, 0);
1787
1788     if (!strcmp(filename, "-"))
1789         filename = "pipe:";
1790
1791     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1792     if (!oc) {
1793         print_error(filename, err);
1794         exit_program(1);
1795     }
1796
1797     of->ctx = oc;
1798     if (o->recording_time != INT64_MAX)
1799         oc->duration = o->recording_time;
1800
1801     file_oformat= oc->oformat;
1802     oc->interrupt_callback = int_cb;
1803
1804     /* create streams for all unlabeled output pads */
1805     for (i = 0; i < nb_filtergraphs; i++) {
1806         FilterGraph *fg = filtergraphs[i];
1807         for (j = 0; j < fg->nb_outputs; j++) {
1808             OutputFilter *ofilter = fg->outputs[j];
1809
1810             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1811                 continue;
1812
1813             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1814                                           ofilter->out_tmp->pad_idx)) {
1815             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1816             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1817             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1818             }
1819             init_output_filter(ofilter, o, oc);
1820         }
1821     }
1822
1823     /* ffserver seeking with date=... needs a date reference */
1824     if (!strcmp(file_oformat->name, "ffm") &&
1825         av_strstart(filename, "http:", NULL)) {
1826         int err = parse_option(o, "metadata", "creation_time=now", options);
1827         if (err < 0) {
1828             print_error(filename, err);
1829             exit_program(1);
1830         }
1831     }
1832
1833     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1834         av_strstart(filename, "http:", NULL)) {
1835         int j;
1836         /* special case for files sent to ffserver: we get the stream
1837            parameters from ffserver */
1838         int err = read_ffserver_streams(o, oc, filename);
1839         if (err < 0) {
1840             print_error(filename, err);
1841             exit_program(1);
1842         }
1843         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1844             ost = output_streams[j];
1845             for (i = 0; i < nb_input_streams; i++) {
1846                 ist = input_streams[i];
1847                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1848                     ost->sync_ist= ist;
1849                     ost->source_index= i;
1850                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1851                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1852                     ist->discard = 0;
1853                     ist->st->discard = ist->user_set_discard;
1854                     break;
1855                 }
1856             }
1857             if(!ost->sync_ist){
1858                 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));
1859                 exit_program(1);
1860             }
1861         }
1862     } else if (!o->nb_stream_maps) {
1863         char *subtitle_codec_name = NULL;
1864         /* pick the "best" stream of each type */
1865
1866         /* video: highest resolution */
1867         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1868             int area = 0, idx = -1;
1869             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1870             for (i = 0; i < nb_input_streams; i++) {
1871                 int new_area;
1872                 ist = input_streams[i];
1873                 new_area = ist->st->codec->width * ist->st->codec->height;
1874                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1875                     new_area = 1;
1876                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1877                     new_area > area) {
1878                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1879                         continue;
1880                     area = new_area;
1881                     idx = i;
1882                 }
1883             }
1884             if (idx >= 0)
1885                 new_video_stream(o, oc, idx);
1886         }
1887
1888         /* audio: most channels */
1889         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1890             int channels = 0, idx = -1;
1891             for (i = 0; i < nb_input_streams; i++) {
1892                 ist = input_streams[i];
1893                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1894                     ist->st->codec->channels > channels) {
1895                     channels = ist->st->codec->channels;
1896                     idx = i;
1897                 }
1898             }
1899             if (idx >= 0)
1900                 new_audio_stream(o, oc, idx);
1901         }
1902
1903         /* subtitles: pick first */
1904         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1905         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1906             for (i = 0; i < nb_input_streams; i++)
1907                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1908                     AVCodecDescriptor const *input_descriptor =
1909                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1910                     AVCodecDescriptor const *output_descriptor = NULL;
1911                     AVCodec const *output_codec =
1912                         avcodec_find_encoder(oc->oformat->subtitle_codec);
1913                     int input_props = 0, output_props = 0;
1914                     if (output_codec)
1915                         output_descriptor = avcodec_descriptor_get(output_codec->id);
1916                     if (input_descriptor)
1917                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1918                     if (output_descriptor)
1919                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1920                     if (subtitle_codec_name ||
1921                         input_props & output_props ||
1922                         // Map dvb teletext which has neither property to any output subtitle encoder
1923                         input_descriptor && output_descriptor &&
1924                         (!input_descriptor->props ||
1925                          !output_descriptor->props)) {
1926                         new_subtitle_stream(o, oc, i);
1927                         break;
1928                     }
1929                 }
1930         }
1931         /* do something with data? */
1932     } else {
1933         for (i = 0; i < o->nb_stream_maps; i++) {
1934             StreamMap *map = &o->stream_maps[i];
1935
1936             if (map->disabled)
1937                 continue;
1938
1939             if (map->linklabel) {
1940                 FilterGraph *fg;
1941                 OutputFilter *ofilter = NULL;
1942                 int j, k;
1943
1944                 for (j = 0; j < nb_filtergraphs; j++) {
1945                     fg = filtergraphs[j];
1946                     for (k = 0; k < fg->nb_outputs; k++) {
1947                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1948                         if (out && !strcmp(out->name, map->linklabel)) {
1949                             ofilter = fg->outputs[k];
1950                             goto loop_end;
1951                         }
1952                     }
1953                 }
1954 loop_end:
1955                 if (!ofilter) {
1956                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1957                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1958                     exit_program(1);
1959                 }
1960                 init_output_filter(ofilter, o, oc);
1961             } else {
1962                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1963
1964                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1965                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1966                     continue;
1967                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1968                     continue;
1969                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1970                     continue;
1971                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1972                     continue;
1973
1974                 switch (ist->st->codec->codec_type) {
1975                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1976                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1977                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1978                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1979                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1980                 default:
1981                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1982                            map->file_index, map->stream_index);
1983                     exit_program(1);
1984                 }
1985             }
1986         }
1987     }
1988
1989     /* handle attached files */
1990     for (i = 0; i < o->nb_attachments; i++) {
1991         AVIOContext *pb;
1992         uint8_t *attachment;
1993         const char *p;
1994         int64_t len;
1995
1996         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1997             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1998                    o->attachments[i]);
1999             exit_program(1);
2000         }
2001         if ((len = avio_size(pb)) <= 0) {
2002             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2003                    o->attachments[i]);
2004             exit_program(1);
2005         }
2006         if (!(attachment = av_malloc(len))) {
2007             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2008                    o->attachments[i]);
2009             exit_program(1);
2010         }
2011         avio_read(pb, attachment, len);
2012
2013         ost = new_attachment_stream(o, oc, -1);
2014         ost->stream_copy               = 0;
2015         ost->attachment_filename       = o->attachments[i];
2016         ost->finished                  = 1;
2017         ost->enc_ctx->extradata      = attachment;
2018         ost->enc_ctx->extradata_size = len;
2019
2020         p = strrchr(o->attachments[i], '/');
2021         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2022         avio_close(pb);
2023     }
2024
2025     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2026         AVDictionaryEntry *e;
2027         ost = output_streams[i];
2028
2029         if ((ost->stream_copy || ost->attachment_filename)
2030             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2031             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2032             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2033                 exit_program(1);
2034     }
2035
2036     /* check if all codec options have been used */
2037     unused_opts = strip_specifiers(o->g->codec_opts);
2038     for (i = of->ost_index; i < nb_output_streams; i++) {
2039         e = NULL;
2040         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2041                                 AV_DICT_IGNORE_SUFFIX)))
2042             av_dict_set(&unused_opts, e->key, NULL, 0);
2043     }
2044
2045     e = NULL;
2046     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2047         const AVClass *class = avcodec_get_class();
2048         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2049                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2050         const AVClass *fclass = avformat_get_class();
2051         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2052                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2053         if (!option || foption)
2054             continue;
2055
2056
2057         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2058             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2059                    "output file #%d (%s) is not an encoding option.\n", e->key,
2060                    option->help ? option->help : "", nb_output_files - 1,
2061                    filename);
2062             exit_program(1);
2063         }
2064
2065         // gop_timecode is injected by generic code but not always used
2066         if (!strcmp(e->key, "gop_timecode"))
2067             continue;
2068
2069         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2070                "output file #%d (%s) has not been used for any stream. The most "
2071                "likely reason is either wrong type (e.g. a video option with "
2072                "no video streams) or that it is a private option of some encoder "
2073                "which was not actually used for any stream.\n", e->key,
2074                option->help ? option->help : "", nb_output_files - 1, filename);
2075     }
2076     av_dict_free(&unused_opts);
2077
2078     /* check filename in case of an image number is expected */
2079     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2080         if (!av_filename_number_test(oc->filename)) {
2081             print_error(oc->filename, AVERROR(EINVAL));
2082             exit_program(1);
2083         }
2084     }
2085
2086     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2087         /* test if it already exists to avoid losing precious files */
2088         assert_file_overwrite(filename);
2089
2090         /* open the file */
2091         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2092                               &oc->interrupt_callback,
2093                               &of->opts)) < 0) {
2094             print_error(filename, err);
2095             exit_program(1);
2096         }
2097     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2098         assert_file_overwrite(filename);
2099
2100     if (o->mux_preload) {
2101         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2102     }
2103     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2104
2105     /* copy metadata */
2106     for (i = 0; i < o->nb_metadata_map; i++) {
2107         char *p;
2108         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2109
2110         if (in_file_index >= nb_input_files) {
2111             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2112             exit_program(1);
2113         }
2114         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2115                       in_file_index >= 0 ?
2116                       input_files[in_file_index]->ctx : NULL, o);
2117     }
2118
2119     /* copy chapters */
2120     if (o->chapters_input_file >= nb_input_files) {
2121         if (o->chapters_input_file == INT_MAX) {
2122             /* copy chapters from the first input file that has them*/
2123             o->chapters_input_file = -1;
2124             for (i = 0; i < nb_input_files; i++)
2125                 if (input_files[i]->ctx->nb_chapters) {
2126                     o->chapters_input_file = i;
2127                     break;
2128                 }
2129         } else {
2130             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2131                    o->chapters_input_file);
2132             exit_program(1);
2133         }
2134     }
2135     if (o->chapters_input_file >= 0)
2136         copy_chapters(input_files[o->chapters_input_file], of,
2137                       !o->metadata_chapters_manual);
2138
2139     /* copy global metadata by default */
2140     if (!o->metadata_global_manual && nb_input_files){
2141         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2142                      AV_DICT_DONT_OVERWRITE);
2143         if(o->recording_time != INT64_MAX)
2144             av_dict_set(&oc->metadata, "duration", NULL, 0);
2145         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2146     }
2147     if (!o->metadata_streams_manual)
2148         for (i = of->ost_index; i < nb_output_streams; i++) {
2149             InputStream *ist;
2150             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2151                 continue;
2152             ist = input_streams[output_streams[i]->source_index];
2153             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2154             if (!output_streams[i]->stream_copy)
2155                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2156         }
2157
2158     /* process manually set metadata */
2159     for (i = 0; i < o->nb_metadata; i++) {
2160         AVDictionary **m;
2161         char type, *val;
2162         const char *stream_spec;
2163         int index = 0, j, ret = 0;
2164
2165         val = strchr(o->metadata[i].u.str, '=');
2166         if (!val) {
2167             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2168                    o->metadata[i].u.str);
2169             exit_program(1);
2170         }
2171         *val++ = 0;
2172
2173         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2174         if (type == 's') {
2175             for (j = 0; j < oc->nb_streams; j++) {
2176                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2177                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2178                 } else if (ret < 0)
2179                     exit_program(1);
2180             }
2181         }
2182         else {
2183             switch (type) {
2184             case 'g':
2185                 m = &oc->metadata;
2186                 break;
2187             case 'c':
2188                 if (index < 0 || index >= oc->nb_chapters) {
2189                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2190                     exit_program(1);
2191                 }
2192                 m = &oc->chapters[index]->metadata;
2193                 break;
2194             default:
2195                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2196                 exit_program(1);
2197             }
2198             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2199         }
2200     }
2201
2202     return 0;
2203 }
2204
2205 static int opt_target(void *optctx, const char *opt, const char *arg)
2206 {
2207     OptionsContext *o = optctx;
2208     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2209     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2210
2211     if (!strncmp(arg, "pal-", 4)) {
2212         norm = PAL;
2213         arg += 4;
2214     } else if (!strncmp(arg, "ntsc-", 5)) {
2215         norm = NTSC;
2216         arg += 5;
2217     } else if (!strncmp(arg, "film-", 5)) {
2218         norm = FILM;
2219         arg += 5;
2220     } else {
2221         /* Try to determine PAL/NTSC by peeking in the input files */
2222         if (nb_input_files) {
2223             int i, j, fr;
2224             for (j = 0; j < nb_input_files; j++) {
2225                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2226                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2227                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2228                         !c->time_base.num)
2229                         continue;
2230                     fr = c->time_base.den * 1000 / c->time_base.num;
2231                     if (fr == 25000) {
2232                         norm = PAL;
2233                         break;
2234                     } else if ((fr == 29970) || (fr == 23976)) {
2235                         norm = NTSC;
2236                         break;
2237                     }
2238                 }
2239                 if (norm != UNKNOWN)
2240                     break;
2241             }
2242         }
2243         if (norm != UNKNOWN)
2244             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2245     }
2246
2247     if (norm == UNKNOWN) {
2248         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2249         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2250         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2251         exit_program(1);
2252     }
2253
2254     if (!strcmp(arg, "vcd")) {
2255         opt_video_codec(o, "c:v", "mpeg1video");
2256         opt_audio_codec(o, "c:a", "mp2");
2257         parse_option(o, "f", "vcd", options);
2258
2259         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2260         parse_option(o, "r", frame_rates[norm], options);
2261         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2262
2263         opt_default(NULL, "b:v", "1150000");
2264         opt_default(NULL, "maxrate", "1150000");
2265         opt_default(NULL, "minrate", "1150000");
2266         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2267
2268         opt_default(NULL, "b:a", "224000");
2269         parse_option(o, "ar", "44100", options);
2270         parse_option(o, "ac", "2", options);
2271
2272         opt_default(NULL, "packetsize", "2324");
2273         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2274
2275         /* We have to offset the PTS, so that it is consistent with the SCR.
2276            SCR starts at 36000, but the first two packs contain only padding
2277            and the first pack from the other stream, respectively, may also have
2278            been written before.
2279            So the real data starts at SCR 36000+3*1200. */
2280         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2281     } else if (!strcmp(arg, "svcd")) {
2282
2283         opt_video_codec(o, "c:v", "mpeg2video");
2284         opt_audio_codec(o, "c:a", "mp2");
2285         parse_option(o, "f", "svcd", options);
2286
2287         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2288         parse_option(o, "r", frame_rates[norm], options);
2289         parse_option(o, "pix_fmt", "yuv420p", options);
2290         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2291
2292         opt_default(NULL, "b:v", "2040000");
2293         opt_default(NULL, "maxrate", "2516000");
2294         opt_default(NULL, "minrate", "0"); // 1145000;
2295         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2296         opt_default(NULL, "scan_offset", "1");
2297
2298         opt_default(NULL, "b:a", "224000");
2299         parse_option(o, "ar", "44100", options);
2300
2301         opt_default(NULL, "packetsize", "2324");
2302
2303     } else if (!strcmp(arg, "dvd")) {
2304
2305         opt_video_codec(o, "c:v", "mpeg2video");
2306         opt_audio_codec(o, "c:a", "ac3");
2307         parse_option(o, "f", "dvd", options);
2308
2309         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2310         parse_option(o, "r", frame_rates[norm], options);
2311         parse_option(o, "pix_fmt", "yuv420p", options);
2312         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2313
2314         opt_default(NULL, "b:v", "6000000");
2315         opt_default(NULL, "maxrate", "9000000");
2316         opt_default(NULL, "minrate", "0"); // 1500000;
2317         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2318
2319         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2320         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2321
2322         opt_default(NULL, "b:a", "448000");
2323         parse_option(o, "ar", "48000", options);
2324
2325     } else if (!strncmp(arg, "dv", 2)) {
2326
2327         parse_option(o, "f", "dv", options);
2328
2329         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2330         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2331                           norm == PAL ? "yuv420p" : "yuv411p", options);
2332         parse_option(o, "r", frame_rates[norm], options);
2333
2334         parse_option(o, "ar", "48000", options);
2335         parse_option(o, "ac", "2", options);
2336
2337     } else {
2338         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2339         return AVERROR(EINVAL);
2340     }
2341
2342     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2343     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2344
2345     return 0;
2346 }
2347
2348 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2349 {
2350     av_free (vstats_filename);
2351     vstats_filename = av_strdup (arg);
2352     return 0;
2353 }
2354
2355 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2356 {
2357     char filename[40];
2358     time_t today2 = time(NULL);
2359     struct tm *today = localtime(&today2);
2360
2361     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2362              today->tm_sec);
2363     return opt_vstats_file(NULL, opt, filename);
2364 }
2365
2366 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2367 {
2368     OptionsContext *o = optctx;
2369     return parse_option(o, "frames:v", arg, options);
2370 }
2371
2372 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2373 {
2374     OptionsContext *o = optctx;
2375     return parse_option(o, "frames:a", arg, options);
2376 }
2377
2378 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2379 {
2380     OptionsContext *o = optctx;
2381     return parse_option(o, "frames:d", arg, options);
2382 }
2383
2384 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2385 {
2386     int ret;
2387     AVDictionary *cbak = codec_opts;
2388     AVDictionary *fbak = format_opts;
2389     codec_opts = NULL;
2390     format_opts = NULL;
2391
2392     ret = opt_default(NULL, opt, arg);
2393
2394     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2395     av_dict_copy(&o->g->format_opts, format_opts, 0);
2396     av_dict_free(&codec_opts);
2397     av_dict_free(&format_opts);
2398     codec_opts = cbak;
2399     format_opts = fbak;
2400
2401     return ret;
2402 }
2403
2404 static int opt_preset(void *optctx, const char *opt, const char *arg)
2405 {
2406     OptionsContext *o = optctx;
2407     FILE *f=NULL;
2408     char filename[1000], line[1000], tmp_line[1000];
2409     const char *codec_name = NULL;
2410
2411     tmp_line[0] = *opt;
2412     tmp_line[1] = 0;
2413     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2414
2415     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2416         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2417             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2418         }else
2419             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2420         exit_program(1);
2421     }
2422
2423     while (fgets(line, sizeof(line), f)) {
2424         char *key = tmp_line, *value, *endptr;
2425
2426         if (strcspn(line, "#\n\r") == 0)
2427             continue;
2428         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2429         if (!av_strtok(key,   "=",    &value) ||
2430             !av_strtok(value, "\r\n", &endptr)) {
2431             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2432             exit_program(1);
2433         }
2434         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2435
2436         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2437         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2438         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2439         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2440         else if (opt_default_new(o, key, value) < 0) {
2441             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2442                    filename, line, key, value);
2443             exit_program(1);
2444         }
2445     }
2446
2447     fclose(f);
2448
2449     return 0;
2450 }
2451
2452 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2453 {
2454     OptionsContext *o = optctx;
2455     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2456     int ret = parse_option(o, s, arg, options);
2457     av_free(s);
2458     return ret;
2459 }
2460
2461 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2462 {
2463     OptionsContext *o = optctx;
2464
2465     if(!strcmp(opt, "ab")){
2466         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2467         return 0;
2468     } else if(!strcmp(opt, "b")){
2469         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2470         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2471         return 0;
2472     }
2473     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2474     return 0;
2475 }
2476
2477 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2478 {
2479     OptionsContext *o = optctx;
2480     char *s;
2481     int ret;
2482     if(!strcmp(opt, "qscale")){
2483         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2484         return parse_option(o, "q:v", arg, options);
2485     }
2486     s = av_asprintf("q%s", opt + 6);
2487     ret = parse_option(o, s, arg, options);
2488     av_free(s);
2489     return ret;
2490 }
2491
2492 static int opt_profile(void *optctx, const char *opt, const char *arg)
2493 {
2494     OptionsContext *o = optctx;
2495     if(!strcmp(opt, "profile")){
2496         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2497         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2498         return 0;
2499     }
2500     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2501     return 0;
2502 }
2503
2504 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2505 {
2506     OptionsContext *o = optctx;
2507     return parse_option(o, "filter:v", arg, options);
2508 }
2509
2510 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2511 {
2512     OptionsContext *o = optctx;
2513     return parse_option(o, "filter:a", arg, options);
2514 }
2515
2516 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2517 {
2518     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2519     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2520     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2521     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2522
2523     if (video_sync_method == VSYNC_AUTO)
2524         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2525     return 0;
2526 }
2527
2528 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2529 {
2530     OptionsContext *o = optctx;
2531     char *tcr = av_asprintf("timecode=%s", arg);
2532     int ret = parse_option(o, "metadata:g", tcr, options);
2533     if (ret >= 0)
2534         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2535     av_free(tcr);
2536     return 0;
2537 }
2538
2539 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2540 {
2541     OptionsContext *o = optctx;
2542     char layout_str[32];
2543     char *stream_str;
2544     char *ac_str;
2545     int ret, channels, ac_str_size;
2546     uint64_t layout;
2547
2548     layout = av_get_channel_layout(arg);
2549     if (!layout) {
2550         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2551         return AVERROR(EINVAL);
2552     }
2553     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2554     ret = opt_default_new(o, opt, layout_str);
2555     if (ret < 0)
2556         return ret;
2557
2558     /* set 'ac' option based on channel layout */
2559     channels = av_get_channel_layout_nb_channels(layout);
2560     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2561     stream_str = strchr(opt, ':');
2562     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2563     ac_str = av_mallocz(ac_str_size);
2564     if (!ac_str)
2565         return AVERROR(ENOMEM);
2566     av_strlcpy(ac_str, "ac", 3);
2567     if (stream_str)
2568         av_strlcat(ac_str, stream_str, ac_str_size);
2569     ret = parse_option(o, ac_str, layout_str, options);
2570     av_free(ac_str);
2571
2572     return ret;
2573 }
2574
2575 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2576 {
2577     OptionsContext *o = optctx;
2578     return parse_option(o, "q:a", arg, options);
2579 }
2580
2581 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2582 {
2583     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2584     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2585         return AVERROR(ENOMEM);
2586     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2587     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2588     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2589         return AVERROR(ENOMEM);
2590     return 0;
2591 }
2592
2593 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2594 {
2595     uint8_t *graph_desc = read_file(arg);
2596     if (!graph_desc)
2597         return AVERROR(EINVAL);
2598
2599     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2600     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2601         return AVERROR(ENOMEM);
2602     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2603     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2604     return 0;
2605 }
2606
2607 void show_help_default(const char *opt, const char *arg)
2608 {
2609     /* per-file options have at least one of those set */
2610     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2611     int show_advanced = 0, show_avoptions = 0;
2612
2613     if (opt && *opt) {
2614         if (!strcmp(opt, "long"))
2615             show_advanced = 1;
2616         else if (!strcmp(opt, "full"))
2617             show_advanced = show_avoptions = 1;
2618         else
2619             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2620     }
2621
2622     show_usage();
2623
2624     printf("Getting help:\n"
2625            "    -h      -- print basic options\n"
2626            "    -h long -- print more options\n"
2627            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2628            "    See man %s for detailed description of the options.\n"
2629            "\n", program_name);
2630
2631     show_help_options(options, "Print help / information / capabilities:",
2632                       OPT_EXIT, 0, 0);
2633
2634     show_help_options(options, "Global options (affect whole program "
2635                       "instead of just one file:",
2636                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2637     if (show_advanced)
2638         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2639                           per_file | OPT_EXIT, 0);
2640
2641     show_help_options(options, "Per-file main options:", 0,
2642                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2643                       OPT_EXIT, per_file);
2644     if (show_advanced)
2645         show_help_options(options, "Advanced per-file options:",
2646                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2647
2648     show_help_options(options, "Video options:",
2649                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2650     if (show_advanced)
2651         show_help_options(options, "Advanced Video options:",
2652                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2653
2654     show_help_options(options, "Audio options:",
2655                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2656     if (show_advanced)
2657         show_help_options(options, "Advanced Audio options:",
2658                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2659     show_help_options(options, "Subtitle options:",
2660                       OPT_SUBTITLE, 0, 0);
2661     printf("\n");
2662
2663     if (show_avoptions) {
2664         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2665         show_help_children(avcodec_get_class(), flags);
2666         show_help_children(avformat_get_class(), flags);
2667 #if CONFIG_SWSCALE
2668         show_help_children(sws_get_class(), flags);
2669 #endif
2670         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2671         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2672     }
2673 }
2674
2675 void show_usage(void)
2676 {
2677     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2678     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2679     av_log(NULL, AV_LOG_INFO, "\n");
2680 }
2681
2682 enum OptGroup {
2683     GROUP_OUTFILE,
2684     GROUP_INFILE,
2685 };
2686
2687 static const OptionGroupDef groups[] = {
2688     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2689     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2690 };
2691
2692 static int open_files(OptionGroupList *l, const char *inout,
2693                       int (*open_file)(OptionsContext*, const char*))
2694 {
2695     int i, ret;
2696
2697     for (i = 0; i < l->nb_groups; i++) {
2698         OptionGroup *g = &l->groups[i];
2699         OptionsContext o;
2700
2701         init_options(&o);
2702         o.g = g;
2703
2704         ret = parse_optgroup(&o, g);
2705         if (ret < 0) {
2706             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2707                    "%s.\n", inout, g->arg);
2708             return ret;
2709         }
2710
2711         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2712         ret = open_file(&o, g->arg);
2713         uninit_options(&o);
2714         if (ret < 0) {
2715             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2716                    inout, g->arg);
2717             return ret;
2718         }
2719         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2720     }
2721
2722     return 0;
2723 }
2724
2725 int ffmpeg_parse_options(int argc, char **argv)
2726 {
2727     OptionParseContext octx;
2728     uint8_t error[128];
2729     int ret;
2730
2731     memset(&octx, 0, sizeof(octx));
2732
2733     /* split the commandline into an internal representation */
2734     ret = split_commandline(&octx, argc, argv, options, groups,
2735                             FF_ARRAY_ELEMS(groups));
2736     if (ret < 0) {
2737         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2738         goto fail;
2739     }
2740
2741     /* apply global options */
2742     ret = parse_optgroup(NULL, &octx.global_opts);
2743     if (ret < 0) {
2744         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2745         goto fail;
2746     }
2747
2748     /* open input files */
2749     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2750     if (ret < 0) {
2751         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2752         goto fail;
2753     }
2754
2755     /* open output files */
2756     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2757     if (ret < 0) {
2758         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2759         goto fail;
2760     }
2761
2762 fail:
2763     uninit_parse_context(&octx);
2764     if (ret < 0) {
2765         av_strerror(ret, error, sizeof(error));
2766         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2767     }
2768     return ret;
2769 }
2770
2771 static int opt_progress(void *optctx, const char *opt, const char *arg)
2772 {
2773     AVIOContext *avio = NULL;
2774     int ret;
2775
2776     if (!strcmp(arg, "-"))
2777         arg = "pipe:";
2778     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2779     if (ret < 0) {
2780         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2781                arg, av_err2str(ret));
2782         return ret;
2783     }
2784     progress_avio = avio;
2785     return 0;
2786 }
2787
2788 #define OFFSET(x) offsetof(OptionsContext, x)
2789 const OptionDef options[] = {
2790     /* main options */
2791 #include "cmdutils_common_opts.h"
2792     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2793                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2794         "force format", "fmt" },
2795     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2796         "overwrite output files" },
2797     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2798         "never overwrite output files" },
2799     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2800                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2801         "codec name", "codec" },
2802     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2803                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2804         "codec name", "codec" },
2805     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2806                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2807         "preset name", "preset" },
2808     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2809                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2810         "set input stream mapping",
2811         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2812     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2813         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2814     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2815                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2816         "set metadata information of outfile from infile",
2817         "outfile[,metadata]:infile[,metadata]" },
2818     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2819                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2820         "set chapters mapping", "input_file_index" },
2821     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2822                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2823         "record or transcode \"duration\" seconds of audio/video",
2824         "duration" },
2825     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2826         "record or transcode stop time", "time_stop" },
2827     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2828         "set the limit file size in bytes", "limit_size" },
2829     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2830                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2831         "set the start time offset", "time_off" },
2832     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2833                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2834         "enable/disable accurate seeking with -ss" },
2835     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2836                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2837         "set the input ts offset", "time_off" },
2838     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2839                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2840         "set the input ts scale", "scale" },
2841     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2842         "set the recording timestamp ('now' to set the current time)", "time" },
2843     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2844         "add metadata", "string=string" },
2845     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2846                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2847         "set the number of data frames to output", "number" },
2848     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2849         "add timings for benchmarking" },
2850     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2851       "add timings for each task" },
2852     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2853       "write program-readable progress information", "url" },
2854     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2855       "enable or disable interaction on standard input" },
2856     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2857         "set max runtime in seconds", "limit" },
2858     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2859         "dump each input packet" },
2860     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2861         "when dumping packets, also dump the payload" },
2862     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2863                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2864         "read input at native frame rate", "" },
2865     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2866         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2867         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2868     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2869         "video sync method", "" },
2870     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2871         "audio sync method", "" },
2872     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2873         "audio drift threshold", "threshold" },
2874     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2875         "copy timestamps" },
2876     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
2877         "shift input timestamps to start at 0 when using copyts" },
2878     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2879         "copy input stream time base when stream copying", "mode" },
2880     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2881                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2882         "finish encoding within shortest input" },
2883     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
2884                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
2885         "audio pad", "" },
2886     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2887         "timestamp discontinuity delta threshold", "threshold" },
2888     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2889         "timestamp error delta threshold", "threshold" },
2890     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2891         "exit on error", "error" },
2892     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2893                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2894         "copy initial non-keyframes" },
2895     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2896         "copy or discard frames before start time" },
2897     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2898         "set the number of frames to output", "number" },
2899     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2900                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2901         "force codec tag/fourcc", "fourcc/tag" },
2902     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2903                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2904         "use fixed quality scale (VBR)", "q" },
2905     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2906                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2907         "use fixed quality scale (VBR)", "q" },
2908     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2909         "set profile", "profile" },
2910     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2911         "set stream filtergraph", "filter_graph" },
2912     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2913         "read stream filtergraph description from a file", "filename" },
2914     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2915         "reinit filtergraph on input parameter changes", "" },
2916     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2917         "create a complex filtergraph", "graph_description" },
2918     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2919         "create a complex filtergraph", "graph_description" },
2920     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2921         "read complex filtergraph description from a file", "filename" },
2922     { "stats",          OPT_BOOL,                                    { &print_stats },
2923         "print progress report during encoding", },
2924     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2925                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2926         "add an attachment to the output file", "filename" },
2927     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2928                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2929         "extract an attachment into a file", "filename" },
2930     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2931         "print timestamp debugging info" },
2932     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
2933         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2934     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
2935                         OPT_INPUT,                                   { .off = OFFSET(discard) },
2936         "discard", "" },
2937
2938     /* video options */
2939     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2940         "set the number of video frames to output", "number" },
2941     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2942                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2943         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2944     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2945                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2946         "set frame size (WxH or abbreviation)", "size" },
2947     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2948                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2949         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2950     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2951                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2952         "set pixel format", "format" },
2953     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2954         "set the number of bits per raw sample", "number" },
2955     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2956         "deprecated use -g 1" },
2957     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2958         "disable video" },
2959     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2960                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2961         "rate control override for specific intervals", "override" },
2962     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2963                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2964         "force video codec ('copy' to copy stream)", "codec" },
2965     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2966         "Removed" },
2967     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2968         "Removed" },
2969     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2970         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2971     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2972         "select the pass number (1 to 3)", "n" },
2973     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2974                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2975         "select two pass log file name prefix", "prefix" },
2976     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2977         "this option is deprecated, use the yadif filter instead" },
2978     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2979         "calculate PSNR of compressed frames" },
2980     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2981         "dump video coding statistics to file" },
2982     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2983         "dump video coding statistics to file", "file" },
2984     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2985         "set video filters", "filter_graph" },
2986     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2987                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2988         "specify intra matrix coeffs", "matrix" },
2989     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2990                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2991         "specify inter matrix coeffs", "matrix" },
2992     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2993                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
2994         "specify intra matrix coeffs", "matrix" },
2995     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2996                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2997         "top=1/bottom=0/auto=-1 field first", "" },
2998     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2999                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3000         "force video tag/fourcc", "fourcc/tag" },
3001     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3002         "show QP histogram" },
3003     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3004                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3005         "force the selected framerate, disable the best supported framerate selection" },
3006     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3007                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3008         "set the value of an outfile streamid", "streamIndex:value" },
3009     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3010                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3011         "force key frames at specified timestamps", "timestamps" },
3012     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3013         "audio bitrate (please use -b:a)", "bitrate" },
3014     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3015         "video bitrate (please use -b:v)", "bitrate" },
3016     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3017                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3018         "use HW accelerated decoding", "hwaccel name" },
3019     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3020                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3021         "select a device for HW acceleration" "devicename" },
3022 #if HAVE_VDPAU_X11
3023     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3024 #endif
3025
3026     /* audio options */
3027     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3028         "set the number of audio frames to output", "number" },
3029     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3030         "set audio quality (codec-specific)", "quality", },
3031     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3032                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3033         "set audio sampling rate (in Hz)", "rate" },
3034     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3035                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3036         "set number of audio channels", "channels" },
3037     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3038         "disable audio" },
3039     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3040                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3041         "force audio codec ('copy' to copy stream)", "codec" },
3042     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3043                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3044         "force audio tag/fourcc", "fourcc/tag" },
3045     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3046         "change audio volume (256=normal)" , "volume" },
3047     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3048                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3049         "set sample format", "format" },
3050     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3051                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3052         "set channel layout", "layout" },
3053     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3054         "set audio filters", "filter_graph" },
3055     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3056       "set the maximum number of channels to try to guess the channel layout" },
3057
3058     /* subtitle options */
3059     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3060         "disable subtitle" },
3061     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3062         "force subtitle codec ('copy' to copy stream)", "codec" },
3063     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3064         , "force subtitle tag/fourcc", "fourcc/tag" },
3065     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3066         "fix subtitles duration" },
3067     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3068         "set canvas size (WxH or abbreviation)", "size" },
3069
3070     /* grab options */
3071     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3072         "deprecated, use -channel", "channel" },
3073     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3074         "deprecated, use -standard", "standard" },
3075     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3076
3077     /* muxer options */
3078     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3079         "set the maximum demux-decode delay", "seconds" },
3080     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3081         "set the initial demux-decode delay", "seconds" },
3082     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3083         "override the options from ffserver", "" },
3084
3085     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3086         "A comma-separated list of bitstream filters", "bitstream_filters" },
3087     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3088         "deprecated", "audio bitstream_filters" },
3089     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3090         "deprecated", "video bitstream_filters" },
3091
3092     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3093         "set the audio options to the indicated preset", "preset" },
3094     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3095         "set the video options to the indicated preset", "preset" },
3096     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3097         "set the subtitle options to the indicated preset", "preset" },
3098     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3099         "set options from indicated preset file", "filename" },
3100     /* data codec support */
3101     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3102         "force data codec ('copy' to copy stream)", "codec" },
3103     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3104         "disable data" },
3105
3106     { NULL, },
3107 };