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