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