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