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