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 best_score = 0, idx = -1;
1996             for (i = 0; i < nb_input_streams; i++) {
1997                 int score;
1998                 ist = input_streams[i];
1999                 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2000                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2001                     score > best_score) {
2002                     best_score = score;
2003                     idx = i;
2004                 }
2005             }
2006             if (idx >= 0)
2007                 new_audio_stream(o, oc, idx);
2008         }
2009
2010         /* subtitles: pick first */
2011         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2012         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2013             for (i = 0; i < nb_input_streams; i++)
2014                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2015                     AVCodecDescriptor const *input_descriptor =
2016                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2017                     AVCodecDescriptor const *output_descriptor = NULL;
2018                     AVCodec const *output_codec =
2019                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2020                     int input_props = 0, output_props = 0;
2021                     if (output_codec)
2022                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2023                     if (input_descriptor)
2024                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2025                     if (output_descriptor)
2026                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2027                     if (subtitle_codec_name ||
2028                         input_props & output_props ||
2029                         // Map dvb teletext which has neither property to any output subtitle encoder
2030                         input_descriptor && output_descriptor &&
2031                         (!input_descriptor->props ||
2032                          !output_descriptor->props)) {
2033                         new_subtitle_stream(o, oc, i);
2034                         break;
2035                     }
2036                 }
2037         }
2038         /* Data only if codec id match */
2039         if (!o->data_disable ) {
2040             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2041             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2042                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2043                     && input_streams[i]->st->codec->codec_id == codec_id )
2044                     new_data_stream(o, oc, i);
2045             }
2046         }
2047     } else {
2048         for (i = 0; i < o->nb_stream_maps; i++) {
2049             StreamMap *map = &o->stream_maps[i];
2050
2051             if (map->disabled)
2052                 continue;
2053
2054             if (map->linklabel) {
2055                 FilterGraph *fg;
2056                 OutputFilter *ofilter = NULL;
2057                 int j, k;
2058
2059                 for (j = 0; j < nb_filtergraphs; j++) {
2060                     fg = filtergraphs[j];
2061                     for (k = 0; k < fg->nb_outputs; k++) {
2062                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2063                         if (out && !strcmp(out->name, map->linklabel)) {
2064                             ofilter = fg->outputs[k];
2065                             goto loop_end;
2066                         }
2067                     }
2068                 }
2069 loop_end:
2070                 if (!ofilter) {
2071                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2072                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2073                     exit_program(1);
2074                 }
2075                 init_output_filter(ofilter, o, oc);
2076             } else {
2077                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2078
2079                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2080                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2081                     continue;
2082                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2083                     continue;
2084                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2085                     continue;
2086                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2087                     continue;
2088
2089                 ost = NULL;
2090                 switch (ist->st->codec->codec_type) {
2091                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2092                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2093                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2094                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2095                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2096                 case AVMEDIA_TYPE_UNKNOWN:
2097                     if (copy_unknown_streams) {
2098                         ost = new_unknown_stream   (o, oc, src_idx);
2099                         break;
2100                     }
2101                 default:
2102                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2103                            "Cannot map stream #%d:%d - unsupported type.\n",
2104                            map->file_index, map->stream_index);
2105                     if (!ignore_unknown_streams) {
2106                         av_log(NULL, AV_LOG_FATAL,
2107                                "If you want unsupported types ignored instead "
2108                                "of failing, please use the -ignore_unknown option\n"
2109                                "If you want them copied, please use -copy_unknown\n");
2110                         exit_program(1);
2111                     }
2112                 }
2113                 if (ost)
2114                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2115                                                   + map->sync_stream_index];
2116             }
2117         }
2118     }
2119
2120     /* handle attached files */
2121     for (i = 0; i < o->nb_attachments; i++) {
2122         AVIOContext *pb;
2123         uint8_t *attachment;
2124         const char *p;
2125         int64_t len;
2126
2127         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2128             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2129                    o->attachments[i]);
2130             exit_program(1);
2131         }
2132         if ((len = avio_size(pb)) <= 0) {
2133             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2134                    o->attachments[i]);
2135             exit_program(1);
2136         }
2137         if (!(attachment = av_malloc(len))) {
2138             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2139                    o->attachments[i]);
2140             exit_program(1);
2141         }
2142         avio_read(pb, attachment, len);
2143
2144         ost = new_attachment_stream(o, oc, -1);
2145         ost->stream_copy               = 1;
2146         ost->attachment_filename       = o->attachments[i];
2147         ost->finished                  = 1;
2148         ost->st->codec->extradata      = attachment;
2149         ost->st->codec->extradata_size = len;
2150
2151         p = strrchr(o->attachments[i], '/');
2152         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2153         avio_closep(&pb);
2154     }
2155
2156     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2157         AVDictionaryEntry *e;
2158         ost = output_streams[i];
2159
2160         if ((ost->stream_copy || ost->attachment_filename)
2161             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2162             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2163             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2164                 exit_program(1);
2165     }
2166
2167     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2168         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2169         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2170         exit_program(1);
2171     }
2172
2173     /* check if all codec options have been used */
2174     unused_opts = strip_specifiers(o->g->codec_opts);
2175     for (i = of->ost_index; i < nb_output_streams; i++) {
2176         e = NULL;
2177         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2178                                 AV_DICT_IGNORE_SUFFIX)))
2179             av_dict_set(&unused_opts, e->key, NULL, 0);
2180     }
2181
2182     e = NULL;
2183     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2184         const AVClass *class = avcodec_get_class();
2185         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2186                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2187         const AVClass *fclass = avformat_get_class();
2188         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2189                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2190         if (!option || foption)
2191             continue;
2192
2193
2194         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2195             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2196                    "output file #%d (%s) is not an encoding option.\n", e->key,
2197                    option->help ? option->help : "", nb_output_files - 1,
2198                    filename);
2199             exit_program(1);
2200         }
2201
2202         // gop_timecode is injected by generic code but not always used
2203         if (!strcmp(e->key, "gop_timecode"))
2204             continue;
2205
2206         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2207                "output file #%d (%s) has not been used for any stream. The most "
2208                "likely reason is either wrong type (e.g. a video option with "
2209                "no video streams) or that it is a private option of some encoder "
2210                "which was not actually used for any stream.\n", e->key,
2211                option->help ? option->help : "", nb_output_files - 1, filename);
2212     }
2213     av_dict_free(&unused_opts);
2214
2215     /* set the encoding/decoding_needed flags */
2216     for (i = of->ost_index; i < nb_output_streams; i++) {
2217         OutputStream *ost = output_streams[i];
2218
2219         ost->encoding_needed = !ost->stream_copy;
2220         if (ost->encoding_needed && ost->source_index >= 0) {
2221             InputStream *ist = input_streams[ost->source_index];
2222             ist->decoding_needed |= DECODING_FOR_OST;
2223         }
2224     }
2225
2226     /* check filename in case of an image number is expected */
2227     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2228         if (!av_filename_number_test(oc->filename)) {
2229             print_error(oc->filename, AVERROR(EINVAL));
2230             exit_program(1);
2231         }
2232     }
2233
2234     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2235         av_log(NULL, AV_LOG_ERROR,
2236                "No input streams but output needs an input stream\n");
2237         exit_program(1);
2238     }
2239
2240     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2241         /* test if it already exists to avoid losing precious files */
2242         assert_file_overwrite(filename);
2243
2244         /* open the file */
2245         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2246                               &oc->interrupt_callback,
2247                               &of->opts)) < 0) {
2248             print_error(filename, err);
2249             exit_program(1);
2250         }
2251     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2252         assert_file_overwrite(filename);
2253
2254     if (o->mux_preload) {
2255         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2256     }
2257     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2258
2259     /* copy metadata */
2260     for (i = 0; i < o->nb_metadata_map; i++) {
2261         char *p;
2262         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2263
2264         if (in_file_index >= nb_input_files) {
2265             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2266             exit_program(1);
2267         }
2268         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2269                       in_file_index >= 0 ?
2270                       input_files[in_file_index]->ctx : NULL, o);
2271     }
2272
2273     /* copy chapters */
2274     if (o->chapters_input_file >= nb_input_files) {
2275         if (o->chapters_input_file == INT_MAX) {
2276             /* copy chapters from the first input file that has them*/
2277             o->chapters_input_file = -1;
2278             for (i = 0; i < nb_input_files; i++)
2279                 if (input_files[i]->ctx->nb_chapters) {
2280                     o->chapters_input_file = i;
2281                     break;
2282                 }
2283         } else {
2284             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2285                    o->chapters_input_file);
2286             exit_program(1);
2287         }
2288     }
2289     if (o->chapters_input_file >= 0)
2290         copy_chapters(input_files[o->chapters_input_file], of,
2291                       !o->metadata_chapters_manual);
2292
2293     /* copy global metadata by default */
2294     if (!o->metadata_global_manual && nb_input_files){
2295         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2296                      AV_DICT_DONT_OVERWRITE);
2297         if(o->recording_time != INT64_MAX)
2298             av_dict_set(&oc->metadata, "duration", NULL, 0);
2299         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2300     }
2301     if (!o->metadata_streams_manual)
2302         for (i = of->ost_index; i < nb_output_streams; i++) {
2303             InputStream *ist;
2304             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2305                 continue;
2306             ist = input_streams[output_streams[i]->source_index];
2307             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2308             if (!output_streams[i]->stream_copy) {
2309                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2310                 if (ist->autorotate)
2311                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2312             }
2313         }
2314
2315     /* process manually set metadata */
2316     for (i = 0; i < o->nb_metadata; i++) {
2317         AVDictionary **m;
2318         char type, *val;
2319         const char *stream_spec;
2320         int index = 0, j, ret = 0;
2321         char now_time[256];
2322
2323         val = strchr(o->metadata[i].u.str, '=');
2324         if (!val) {
2325             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2326                    o->metadata[i].u.str);
2327             exit_program(1);
2328         }
2329         *val++ = 0;
2330
2331         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2332             !strcmp(val, "now")) {
2333             time_t now = time(0);
2334             struct tm *ptm, tmbuf;
2335             ptm = localtime_r(&now, &tmbuf);
2336             if (ptm) {
2337                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2338                     val = now_time;
2339             }
2340         }
2341
2342         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2343         if (type == 's') {
2344             for (j = 0; j < oc->nb_streams; j++) {
2345                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2346                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2347                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2348                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2349                         ost->rotate_overridden = 1;
2350                     }
2351                 } else if (ret < 0)
2352                     exit_program(1);
2353             }
2354         }
2355         else {
2356             switch (type) {
2357             case 'g':
2358                 m = &oc->metadata;
2359                 break;
2360             case 'c':
2361                 if (index < 0 || index >= oc->nb_chapters) {
2362                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2363                     exit_program(1);
2364                 }
2365                 m = &oc->chapters[index]->metadata;
2366                 break;
2367             default:
2368                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2369                 exit_program(1);
2370             }
2371             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2372         }
2373     }
2374
2375     return 0;
2376 }
2377
2378 static int opt_target(void *optctx, const char *opt, const char *arg)
2379 {
2380     OptionsContext *o = optctx;
2381     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2382     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2383
2384     if (!strncmp(arg, "pal-", 4)) {
2385         norm = PAL;
2386         arg += 4;
2387     } else if (!strncmp(arg, "ntsc-", 5)) {
2388         norm = NTSC;
2389         arg += 5;
2390     } else if (!strncmp(arg, "film-", 5)) {
2391         norm = FILM;
2392         arg += 5;
2393     } else {
2394         /* Try to determine PAL/NTSC by peeking in the input files */
2395         if (nb_input_files) {
2396             int i, j, fr;
2397             for (j = 0; j < nb_input_files; j++) {
2398                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2399                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2400                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2401                         !c->time_base.num)
2402                         continue;
2403                     fr = c->time_base.den * 1000 / c->time_base.num;
2404                     if (fr == 25000) {
2405                         norm = PAL;
2406                         break;
2407                     } else if ((fr == 29970) || (fr == 23976)) {
2408                         norm = NTSC;
2409                         break;
2410                     }
2411                 }
2412                 if (norm != UNKNOWN)
2413                     break;
2414             }
2415         }
2416         if (norm != UNKNOWN)
2417             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2418     }
2419
2420     if (norm == UNKNOWN) {
2421         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2422         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2423         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2424         exit_program(1);
2425     }
2426
2427     if (!strcmp(arg, "vcd")) {
2428         opt_video_codec(o, "c:v", "mpeg1video");
2429         opt_audio_codec(o, "c:a", "mp2");
2430         parse_option(o, "f", "vcd", options);
2431
2432         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2433         parse_option(o, "r", frame_rates[norm], options);
2434         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2435
2436         opt_default(NULL, "b:v", "1150000");
2437         opt_default(NULL, "maxrate:v", "1150000");
2438         opt_default(NULL, "minrate:v", "1150000");
2439         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2440
2441         opt_default(NULL, "b:a", "224000");
2442         parse_option(o, "ar", "44100", options);
2443         parse_option(o, "ac", "2", options);
2444
2445         opt_default(NULL, "packetsize", "2324");
2446         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2447
2448         /* We have to offset the PTS, so that it is consistent with the SCR.
2449            SCR starts at 36000, but the first two packs contain only padding
2450            and the first pack from the other stream, respectively, may also have
2451            been written before.
2452            So the real data starts at SCR 36000+3*1200. */
2453         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2454     } else if (!strcmp(arg, "svcd")) {
2455
2456         opt_video_codec(o, "c:v", "mpeg2video");
2457         opt_audio_codec(o, "c:a", "mp2");
2458         parse_option(o, "f", "svcd", options);
2459
2460         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2461         parse_option(o, "r", frame_rates[norm], options);
2462         parse_option(o, "pix_fmt", "yuv420p", options);
2463         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2464
2465         opt_default(NULL, "b:v", "2040000");
2466         opt_default(NULL, "maxrate:v", "2516000");
2467         opt_default(NULL, "minrate:v", "0"); // 1145000;
2468         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2469         opt_default(NULL, "scan_offset", "1");
2470
2471         opt_default(NULL, "b:a", "224000");
2472         parse_option(o, "ar", "44100", options);
2473
2474         opt_default(NULL, "packetsize", "2324");
2475
2476     } else if (!strcmp(arg, "dvd")) {
2477
2478         opt_video_codec(o, "c:v", "mpeg2video");
2479         opt_audio_codec(o, "c:a", "ac3");
2480         parse_option(o, "f", "dvd", options);
2481
2482         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2483         parse_option(o, "r", frame_rates[norm], options);
2484         parse_option(o, "pix_fmt", "yuv420p", options);
2485         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2486
2487         opt_default(NULL, "b:v", "6000000");
2488         opt_default(NULL, "maxrate:v", "9000000");
2489         opt_default(NULL, "minrate:v", "0"); // 1500000;
2490         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2491
2492         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2493         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2494
2495         opt_default(NULL, "b:a", "448000");
2496         parse_option(o, "ar", "48000", options);
2497
2498     } else if (!strncmp(arg, "dv", 2)) {
2499
2500         parse_option(o, "f", "dv", options);
2501
2502         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2503         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2504                           norm == PAL ? "yuv420p" : "yuv411p", options);
2505         parse_option(o, "r", frame_rates[norm], options);
2506
2507         parse_option(o, "ar", "48000", options);
2508         parse_option(o, "ac", "2", options);
2509
2510     } else {
2511         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2512         return AVERROR(EINVAL);
2513     }
2514
2515     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2516     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2517
2518     return 0;
2519 }
2520
2521 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2522 {
2523     av_free (vstats_filename);
2524     vstats_filename = av_strdup (arg);
2525     return 0;
2526 }
2527
2528 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2529 {
2530     char filename[40];
2531     time_t today2 = time(NULL);
2532     struct tm *today = localtime(&today2);
2533
2534     if (!today) { // maybe tomorrow
2535         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2536         exit_program(1);
2537     }
2538
2539     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2540              today->tm_sec);
2541     return opt_vstats_file(NULL, opt, filename);
2542 }
2543
2544 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2545 {
2546     OptionsContext *o = optctx;
2547     return parse_option(o, "frames:v", arg, options);
2548 }
2549
2550 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2551 {
2552     OptionsContext *o = optctx;
2553     return parse_option(o, "frames:a", arg, options);
2554 }
2555
2556 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2557 {
2558     OptionsContext *o = optctx;
2559     return parse_option(o, "frames:d", arg, options);
2560 }
2561
2562 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2563 {
2564     int ret;
2565     AVDictionary *cbak = codec_opts;
2566     AVDictionary *fbak = format_opts;
2567     codec_opts = NULL;
2568     format_opts = NULL;
2569
2570     ret = opt_default(NULL, opt, arg);
2571
2572     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2573     av_dict_copy(&o->g->format_opts, format_opts, 0);
2574     av_dict_free(&codec_opts);
2575     av_dict_free(&format_opts);
2576     codec_opts = cbak;
2577     format_opts = fbak;
2578
2579     return ret;
2580 }
2581
2582 static int opt_preset(void *optctx, const char *opt, const char *arg)
2583 {
2584     OptionsContext *o = optctx;
2585     FILE *f=NULL;
2586     char filename[1000], line[1000], tmp_line[1000];
2587     const char *codec_name = NULL;
2588
2589     tmp_line[0] = *opt;
2590     tmp_line[1] = 0;
2591     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2592
2593     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2594         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2595             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2596         }else
2597             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2598         exit_program(1);
2599     }
2600
2601     while (fgets(line, sizeof(line), f)) {
2602         char *key = tmp_line, *value, *endptr;
2603
2604         if (strcspn(line, "#\n\r") == 0)
2605             continue;
2606         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2607         if (!av_strtok(key,   "=",    &value) ||
2608             !av_strtok(value, "\r\n", &endptr)) {
2609             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2610             exit_program(1);
2611         }
2612         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2613
2614         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2615         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2616         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2617         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2618         else if (opt_default_new(o, key, value) < 0) {
2619             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2620                    filename, line, key, value);
2621             exit_program(1);
2622         }
2623     }
2624
2625     fclose(f);
2626
2627     return 0;
2628 }
2629
2630 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2631 {
2632     OptionsContext *o = optctx;
2633     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2634     int ret = parse_option(o, s, arg, options);
2635     av_free(s);
2636     return ret;
2637 }
2638
2639 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2640 {
2641     OptionsContext *o = optctx;
2642
2643     if(!strcmp(opt, "ab")){
2644         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2645         return 0;
2646     } else if(!strcmp(opt, "b")){
2647         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2648         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2649         return 0;
2650     }
2651     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2652     return 0;
2653 }
2654
2655 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2656 {
2657     OptionsContext *o = optctx;
2658     char *s;
2659     int ret;
2660     if(!strcmp(opt, "qscale")){
2661         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2662         return parse_option(o, "q:v", arg, options);
2663     }
2664     s = av_asprintf("q%s", opt + 6);
2665     ret = parse_option(o, s, arg, options);
2666     av_free(s);
2667     return ret;
2668 }
2669
2670 static int opt_profile(void *optctx, const char *opt, const char *arg)
2671 {
2672     OptionsContext *o = optctx;
2673     if(!strcmp(opt, "profile")){
2674         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2675         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2676         return 0;
2677     }
2678     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2679     return 0;
2680 }
2681
2682 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2683 {
2684     OptionsContext *o = optctx;
2685     return parse_option(o, "filter:v", arg, options);
2686 }
2687
2688 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2689 {
2690     OptionsContext *o = optctx;
2691     return parse_option(o, "filter:a", arg, options);
2692 }
2693
2694 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2695 {
2696     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2697     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2698     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2699     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2700
2701     if (video_sync_method == VSYNC_AUTO)
2702         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2703     return 0;
2704 }
2705
2706 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2707 {
2708     OptionsContext *o = optctx;
2709     char *tcr = av_asprintf("timecode=%s", arg);
2710     int ret = parse_option(o, "metadata:g", tcr, options);
2711     if (ret >= 0)
2712         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2713     av_free(tcr);
2714     return 0;
2715 }
2716
2717 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2718 {
2719     OptionsContext *o = optctx;
2720     char layout_str[32];
2721     char *stream_str;
2722     char *ac_str;
2723     int ret, channels, ac_str_size;
2724     uint64_t layout;
2725
2726     layout = av_get_channel_layout(arg);
2727     if (!layout) {
2728         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2729         return AVERROR(EINVAL);
2730     }
2731     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2732     ret = opt_default_new(o, opt, layout_str);
2733     if (ret < 0)
2734         return ret;
2735
2736     /* set 'ac' option based on channel layout */
2737     channels = av_get_channel_layout_nb_channels(layout);
2738     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2739     stream_str = strchr(opt, ':');
2740     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2741     ac_str = av_mallocz(ac_str_size);
2742     if (!ac_str)
2743         return AVERROR(ENOMEM);
2744     av_strlcpy(ac_str, "ac", 3);
2745     if (stream_str)
2746         av_strlcat(ac_str, stream_str, ac_str_size);
2747     ret = parse_option(o, ac_str, layout_str, options);
2748     av_free(ac_str);
2749
2750     return ret;
2751 }
2752
2753 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2754 {
2755     OptionsContext *o = optctx;
2756     return parse_option(o, "q:a", arg, options);
2757 }
2758
2759 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2760 {
2761     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2762     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2763         return AVERROR(ENOMEM);
2764     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2765     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2766     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2767         return AVERROR(ENOMEM);
2768
2769     input_stream_potentially_available = 1;
2770
2771     return 0;
2772 }
2773
2774 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2775 {
2776     uint8_t *graph_desc = read_file(arg);
2777     if (!graph_desc)
2778         return AVERROR(EINVAL);
2779
2780     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2781     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2782         return AVERROR(ENOMEM);
2783     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2784     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2785
2786     input_stream_potentially_available = 1;
2787
2788     return 0;
2789 }
2790
2791 void show_help_default(const char *opt, const char *arg)
2792 {
2793     /* per-file options have at least one of those set */
2794     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2795     int show_advanced = 0, show_avoptions = 0;
2796
2797     if (opt && *opt) {
2798         if (!strcmp(opt, "long"))
2799             show_advanced = 1;
2800         else if (!strcmp(opt, "full"))
2801             show_advanced = show_avoptions = 1;
2802         else
2803             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2804     }
2805
2806     show_usage();
2807
2808     printf("Getting help:\n"
2809            "    -h      -- print basic options\n"
2810            "    -h long -- print more options\n"
2811            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2812            "    See man %s for detailed description of the options.\n"
2813            "\n", program_name);
2814
2815     show_help_options(options, "Print help / information / capabilities:",
2816                       OPT_EXIT, 0, 0);
2817
2818     show_help_options(options, "Global options (affect whole program "
2819                       "instead of just one file:",
2820                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2821     if (show_advanced)
2822         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2823                           per_file | OPT_EXIT, 0);
2824
2825     show_help_options(options, "Per-file main options:", 0,
2826                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2827                       OPT_EXIT, per_file);
2828     if (show_advanced)
2829         show_help_options(options, "Advanced per-file options:",
2830                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2831
2832     show_help_options(options, "Video options:",
2833                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2834     if (show_advanced)
2835         show_help_options(options, "Advanced Video options:",
2836                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2837
2838     show_help_options(options, "Audio options:",
2839                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2840     if (show_advanced)
2841         show_help_options(options, "Advanced Audio options:",
2842                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2843     show_help_options(options, "Subtitle options:",
2844                       OPT_SUBTITLE, 0, 0);
2845     printf("\n");
2846
2847     if (show_avoptions) {
2848         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2849         show_help_children(avcodec_get_class(), flags);
2850         show_help_children(avformat_get_class(), flags);
2851 #if CONFIG_SWSCALE
2852         show_help_children(sws_get_class(), flags);
2853 #endif
2854         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2855         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2856     }
2857 }
2858
2859 void show_usage(void)
2860 {
2861     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2862     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2863     av_log(NULL, AV_LOG_INFO, "\n");
2864 }
2865
2866 enum OptGroup {
2867     GROUP_OUTFILE,
2868     GROUP_INFILE,
2869 };
2870
2871 static const OptionGroupDef groups[] = {
2872     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2873     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2874 };
2875
2876 static int open_files(OptionGroupList *l, const char *inout,
2877                       int (*open_file)(OptionsContext*, const char*))
2878 {
2879     int i, ret;
2880
2881     for (i = 0; i < l->nb_groups; i++) {
2882         OptionGroup *g = &l->groups[i];
2883         OptionsContext o;
2884
2885         init_options(&o);
2886         o.g = g;
2887
2888         ret = parse_optgroup(&o, g);
2889         if (ret < 0) {
2890             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2891                    "%s.\n", inout, g->arg);
2892             return ret;
2893         }
2894
2895         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2896         ret = open_file(&o, g->arg);
2897         uninit_options(&o);
2898         if (ret < 0) {
2899             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2900                    inout, g->arg);
2901             return ret;
2902         }
2903         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2904     }
2905
2906     return 0;
2907 }
2908
2909 int ffmpeg_parse_options(int argc, char **argv)
2910 {
2911     OptionParseContext octx;
2912     uint8_t error[128];
2913     int ret;
2914
2915     memset(&octx, 0, sizeof(octx));
2916
2917     /* split the commandline into an internal representation */
2918     ret = split_commandline(&octx, argc, argv, options, groups,
2919                             FF_ARRAY_ELEMS(groups));
2920     if (ret < 0) {
2921         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2922         goto fail;
2923     }
2924
2925     /* apply global options */
2926     ret = parse_optgroup(NULL, &octx.global_opts);
2927     if (ret < 0) {
2928         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2929         goto fail;
2930     }
2931
2932     /* open input files */
2933     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2934     if (ret < 0) {
2935         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2936         goto fail;
2937     }
2938
2939     /* create the complex filtergraphs */
2940     ret = init_complex_filters();
2941     if (ret < 0) {
2942         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2943         goto fail;
2944     }
2945
2946     /* open output files */
2947     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2948     if (ret < 0) {
2949         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2950         goto fail;
2951     }
2952
2953     /* configure the complex filtergraphs */
2954     ret = configure_complex_filters();
2955     if (ret < 0) {
2956         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2957         goto fail;
2958     }
2959
2960 fail:
2961     uninit_parse_context(&octx);
2962     if (ret < 0) {
2963         av_strerror(ret, error, sizeof(error));
2964         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2965     }
2966     return ret;
2967 }
2968
2969 static int opt_progress(void *optctx, const char *opt, const char *arg)
2970 {
2971     AVIOContext *avio = NULL;
2972     int ret;
2973
2974     if (!strcmp(arg, "-"))
2975         arg = "pipe:";
2976     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2977     if (ret < 0) {
2978         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2979                arg, av_err2str(ret));
2980         return ret;
2981     }
2982     progress_avio = avio;
2983     return 0;
2984 }
2985
2986 #define OFFSET(x) offsetof(OptionsContext, x)
2987 const OptionDef options[] = {
2988     /* main options */
2989 #include "cmdutils_common_opts.h"
2990     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2991                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2992         "force format", "fmt" },
2993     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2994         "overwrite output files" },
2995     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2996         "never overwrite output files" },
2997     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
2998         "Ignore unknown stream types" },
2999     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3000         "Copy unknown stream types" },
3001     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3002                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3003         "codec name", "codec" },
3004     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3005                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3006         "codec name", "codec" },
3007     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3008                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3009         "preset name", "preset" },
3010     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3011                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3012         "set input stream mapping",
3013         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3014     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3015         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3016     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3017                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3018         "set metadata information of outfile from infile",
3019         "outfile[,metadata]:infile[,metadata]" },
3020     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3021                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3022         "set chapters mapping", "input_file_index" },
3023     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3024                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3025         "record or transcode \"duration\" seconds of audio/video",
3026         "duration" },
3027     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3028         "record or transcode stop time", "time_stop" },
3029     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3030         "set the limit file size in bytes", "limit_size" },
3031     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3032                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3033         "set the start time offset", "time_off" },
3034     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3035                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3036         "set the start time offset relative to EOF", "time_off" },
3037     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3038                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3039         "enable/disable seeking by timestamp with -ss" },
3040     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3041                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3042         "enable/disable accurate seeking with -ss" },
3043     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3044                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3045         "set the input ts offset", "time_off" },
3046     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3047                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3048         "set the input ts scale", "scale" },
3049     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3050         "set the recording timestamp ('now' to set the current time)", "time" },
3051     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3052         "add metadata", "string=string" },
3053     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3054                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3055         "set the number of data frames to output", "number" },
3056     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3057         "add timings for benchmarking" },
3058     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3059       "add timings for each task" },
3060     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3061       "write program-readable progress information", "url" },
3062     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3063       "enable or disable interaction on standard input" },
3064     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3065         "set max runtime in seconds", "limit" },
3066     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3067         "dump each input packet" },
3068     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3069         "when dumping packets, also dump the payload" },
3070     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3071                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3072         "read input at native frame rate", "" },
3073     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3074         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3075         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3076     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
3077         "video sync method", "" },
3078     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3079         "frame drop threshold", "" },
3080     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3081         "audio sync method", "" },
3082     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3083         "audio drift threshold", "threshold" },
3084     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3085         "copy timestamps" },
3086     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3087         "shift input timestamps to start at 0 when using copyts" },
3088     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3089         "copy input stream time base when stream copying", "mode" },
3090     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3091                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3092         "finish encoding within shortest input" },
3093     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3094                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3095         "audio pad", "" },
3096     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3097         "timestamp discontinuity delta threshold", "threshold" },
3098     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3099         "timestamp error delta threshold", "threshold" },
3100     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3101         "exit on error", "error" },
3102     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3103                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3104         "copy initial non-keyframes" },
3105     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3106         "copy or discard frames before start time" },
3107     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3108         "set the number of frames to output", "number" },
3109     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3110                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3111         "force codec tag/fourcc", "fourcc/tag" },
3112     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3113                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3114         "use fixed quality scale (VBR)", "q" },
3115     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3116                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3117         "use fixed quality scale (VBR)", "q" },
3118     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3119         "set profile", "profile" },
3120     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3121         "set stream filtergraph", "filter_graph" },
3122     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3123         "read stream filtergraph description from a file", "filename" },
3124     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3125         "reinit filtergraph on input parameter changes", "" },
3126     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3127         "create a complex filtergraph", "graph_description" },
3128     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3129         "create a complex filtergraph", "graph_description" },
3130     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3131         "read complex filtergraph description from a file", "filename" },
3132     { "stats",          OPT_BOOL,                                    { &print_stats },
3133         "print progress report during encoding", },
3134     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3135                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3136         "add an attachment to the output file", "filename" },
3137     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3138                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3139         "extract an attachment into a file", "filename" },
3140     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3141         "print timestamp debugging info" },
3142     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3143         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3144     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3145                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3146         "discard", "" },
3147     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3148                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3149         "disposition", "" },
3150     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3151                                                                      { .off = OFFSET(thread_queue_size) },
3152         "set the maximum number of queued packets from the demuxer" },
3153
3154     /* video options */
3155     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3156         "set the number of video frames to output", "number" },
3157     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3158                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3159         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3160     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3161                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3162         "set frame size (WxH or abbreviation)", "size" },
3163     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3164                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3165         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3166     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3167                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3168         "set pixel format", "format" },
3169     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3170         "set the number of bits per raw sample", "number" },
3171     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3172         "deprecated use -g 1" },
3173     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3174         "disable video" },
3175     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3176                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3177         "rate control override for specific intervals", "override" },
3178     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3179                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3180         "force video codec ('copy' to copy stream)", "codec" },
3181     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3182         "Removed" },
3183     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3184         "Removed" },
3185     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3186         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3187     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3188         "select the pass number (1 to 3)", "n" },
3189     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3190                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3191         "select two pass log file name prefix", "prefix" },
3192     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3193         "this option is deprecated, use the yadif filter instead" },
3194     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3195         "calculate PSNR of compressed frames" },
3196     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
3197         "dump video coding statistics to file" },
3198     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
3199         "dump video coding statistics to file", "file" },
3200     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3201         "set video filters", "filter_graph" },
3202     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3203                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3204         "specify intra matrix coeffs", "matrix" },
3205     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3206                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3207         "specify inter matrix coeffs", "matrix" },
3208     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3209                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3210         "specify intra matrix coeffs", "matrix" },
3211     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3212                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3213         "top=1/bottom=0/auto=-1 field first", "" },
3214     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3215                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3216         "force video tag/fourcc", "fourcc/tag" },
3217     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3218         "show QP histogram" },
3219     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3220                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3221         "force the selected framerate, disable the best supported framerate selection" },
3222     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3223                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3224         "set the value of an outfile streamid", "streamIndex:value" },
3225     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3226                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3227         "force key frames at specified timestamps", "timestamps" },
3228     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3229         "audio bitrate (please use -b:a)", "bitrate" },
3230     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3231         "video bitrate (please use -b:v)", "bitrate" },
3232     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3233                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3234         "use HW accelerated decoding", "hwaccel name" },
3235     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3236                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3237         "select a device for HW acceleration" "devicename" },
3238 #if HAVE_VDPAU_X11
3239     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3240 #endif
3241 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3242     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3243 #endif
3244     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3245                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3246         "automatically insert correct rotate filters" },
3247
3248     /* audio options */
3249     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3250         "set the number of audio frames to output", "number" },
3251     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3252         "set audio quality (codec-specific)", "quality", },
3253     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3254                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3255         "set audio sampling rate (in Hz)", "rate" },
3256     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3257                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3258         "set number of audio channels", "channels" },
3259     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3260         "disable audio" },
3261     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3262                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3263         "force audio codec ('copy' to copy stream)", "codec" },
3264     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3265                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3266         "force audio tag/fourcc", "fourcc/tag" },
3267     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3268         "change audio volume (256=normal)" , "volume" },
3269     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3270                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3271         "set sample format", "format" },
3272     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3273                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3274         "set channel layout", "layout" },
3275     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3276         "set audio filters", "filter_graph" },
3277     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3278       "set the maximum number of channels to try to guess the channel layout" },
3279
3280     /* subtitle options */
3281     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3282         "disable subtitle" },
3283     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3284         "force subtitle codec ('copy' to copy stream)", "codec" },
3285     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3286         , "force subtitle tag/fourcc", "fourcc/tag" },
3287     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3288         "fix subtitles duration" },
3289     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3290         "set canvas size (WxH or abbreviation)", "size" },
3291
3292     /* grab options */
3293     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3294         "deprecated, use -channel", "channel" },
3295     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3296         "deprecated, use -standard", "standard" },
3297     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3298
3299     /* muxer options */
3300     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3301         "set the maximum demux-decode delay", "seconds" },
3302     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3303         "set the initial demux-decode delay", "seconds" },
3304     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3305         "override the options from ffserver", "" },
3306     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3307         "specify a file in which to print sdp information", "file" },
3308
3309     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3310         "A comma-separated list of bitstream filters", "bitstream_filters" },
3311     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3312         "deprecated", "audio bitstream_filters" },
3313     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3314         "deprecated", "video bitstream_filters" },
3315
3316     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3317         "set the audio options to the indicated preset", "preset" },
3318     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3319         "set the video options to the indicated preset", "preset" },
3320     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3321         "set the subtitle options to the indicated preset", "preset" },
3322     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3323         "set options from indicated preset file", "filename" },
3324     /* data codec support */
3325     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3326         "force data codec ('copy' to copy stream)", "codec" },
3327     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3328         "disable data" },
3329
3330     { NULL, },
3331 };