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