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

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