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