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