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