git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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