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