git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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