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