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