git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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