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