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