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