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