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