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->enc_ctx->codec_tag = tag;
1208     }
1209
1210     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1211     if (qscale >= 0) {
1212         ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1213         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1214     }
1215
1216     MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1217     ost->disposition = av_strdup(ost->disposition);
1218
1219     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1220         ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1221
1222     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1223
1224     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1225     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1226         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1227
1228     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1229
1230     ost->source_index = source_index;
1231     if (source_index >= 0) {
1232         ost->sync_ist = input_streams[source_index];
1233         input_streams[source_index]->discard = 0;
1234         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1235     }
1236     ost->last_mux_dts = AV_NOPTS_VALUE;
1237
1238     return ost;
1239 }
1240
1241 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1242 {
1243     int i;
1244     const char *p = str;
1245     for (i = 0;; i++) {
1246         dest[i] = atoi(p);
1247         if (i == 63)
1248             break;
1249         p = strchr(p, ',');
1250         if (!p) {
1251             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1252             exit_program(1);
1253         }
1254         p++;
1255     }
1256 }
1257
1258 /* read file contents into a string */
1259 static uint8_t *read_file(const char *filename)
1260 {
1261     AVIOContext *pb      = NULL;
1262     AVIOContext *dyn_buf = NULL;
1263     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1264     uint8_t buf[1024], *str;
1265
1266     if (ret < 0) {
1267         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1268         return NULL;
1269     }
1270
1271     ret = avio_open_dyn_buf(&dyn_buf);
1272     if (ret < 0) {
1273         avio_closep(&pb);
1274         return NULL;
1275     }
1276     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1277         avio_write(dyn_buf, buf, ret);
1278     avio_w8(dyn_buf, 0);
1279     avio_closep(&pb);
1280
1281     ret = avio_close_dyn_buf(dyn_buf, &str);
1282     if (ret < 0)
1283         return NULL;
1284     return str;
1285 }
1286
1287 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1288                              OutputStream *ost)
1289 {
1290     AVStream *st = ost->st;
1291
1292     if (ost->filters_script && ost->filters) {
1293         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1294                "output stream #%d:%d.\n", nb_output_files, st->index);
1295         exit_program(1);
1296     }
1297
1298     if (ost->filters_script)
1299         return read_file(ost->filters_script);
1300     else if (ost->filters)
1301         return av_strdup(ost->filters);
1302
1303     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1304                      "null" : "anull");
1305 }
1306
1307 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1308                                      const OutputStream *ost, enum AVMediaType type)
1309 {
1310     if (ost->filters_script || ost->filters) {
1311         av_log(NULL, AV_LOG_ERROR,
1312                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1313                "Filtering and streamcopy cannot be used together.\n",
1314                ost->filters ? "Filtergraph" : "Filtergraph script",
1315                ost->filters ? ost->filters : ost->filters_script,
1316                av_get_media_type_string(type), ost->file_index, ost->index);
1317         exit_program(1);
1318     }
1319 }
1320
1321 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1322 {
1323     AVStream *st;
1324     OutputStream *ost;
1325     AVCodecContext *video_enc;
1326     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1327
1328     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1329     st  = ost->st;
1330     video_enc = ost->enc_ctx;
1331
1332     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1333     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1334         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1335         exit_program(1);
1336     }
1337     if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1338         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1339
1340     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1341     if (frame_aspect_ratio) {
1342         AVRational q;
1343         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1344             q.num <= 0 || q.den <= 0) {
1345             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1346             exit_program(1);
1347         }
1348         ost->frame_aspect_ratio = q;
1349     }
1350
1351     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1352     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1353
1354     if (!ost->stream_copy) {
1355         const char *p = NULL;
1356         char *frame_size = NULL;
1357         char *frame_pix_fmt = NULL;
1358         char *intra_matrix = NULL, *inter_matrix = NULL;
1359         char *chroma_intra_matrix = NULL;
1360         int do_pass = 0;
1361         int i;
1362
1363         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1364         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1365             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1366             exit_program(1);
1367         }
1368
1369         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1370         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1371         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1372             ost->keep_pix_fmt = 1;
1373             if (!*++frame_pix_fmt)
1374                 frame_pix_fmt = NULL;
1375         }
1376         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1377             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1378             exit_program(1);
1379         }
1380         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1381
1382         if (intra_only)
1383             video_enc->gop_size = 0;
1384         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1385         if (intra_matrix) {
1386             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1387                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1388                 exit_program(1);
1389             }
1390             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1391         }
1392         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1393         if (chroma_intra_matrix) {
1394             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1395             if (!p) {
1396                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1397                 exit_program(1);
1398             }
1399             av_codec_set_chroma_intra_matrix(video_enc, p);
1400             parse_matrix_coeffs(p, chroma_intra_matrix);
1401         }
1402         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1403         if (inter_matrix) {
1404             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1405                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1406                 exit_program(1);
1407             }
1408             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1409         }
1410
1411         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1412         for (i = 0; p; i++) {
1413             int start, end, q;
1414             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1415             if (e != 3) {
1416                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1417                 exit_program(1);
1418             }
1419             video_enc->rc_override =
1420                 av_realloc_array(video_enc->rc_override,
1421                                  i + 1, sizeof(RcOverride));
1422             if (!video_enc->rc_override) {
1423                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1424                 exit_program(1);
1425             }
1426             video_enc->rc_override[i].start_frame = start;
1427             video_enc->rc_override[i].end_frame   = end;
1428             if (q > 0) {
1429                 video_enc->rc_override[i].qscale         = q;
1430                 video_enc->rc_override[i].quality_factor = 1.0;
1431             }
1432             else {
1433                 video_enc->rc_override[i].qscale         = 0;
1434                 video_enc->rc_override[i].quality_factor = -q/100.0;
1435             }
1436             p = strchr(p, '/');
1437             if (p) p++;
1438         }
1439         video_enc->rc_override_count = i;
1440
1441         if (do_psnr)
1442             video_enc->flags|= CODEC_FLAG_PSNR;
1443
1444         /* two pass mode */
1445         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1446         if (do_pass) {
1447             if (do_pass & 1) {
1448                 video_enc->flags |= CODEC_FLAG_PASS1;
1449                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1450             }
1451             if (do_pass & 2) {
1452                 video_enc->flags |= CODEC_FLAG_PASS2;
1453                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1454             }
1455         }
1456
1457         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1458         if (ost->logfile_prefix &&
1459             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1460             exit_program(1);
1461
1462         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1463         if (ost->forced_keyframes)
1464             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1465
1466         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1467
1468         ost->top_field_first = -1;
1469         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1470
1471
1472         ost->avfilter = get_ost_filters(o, oc, ost);
1473         if (!ost->avfilter)
1474             exit_program(1);
1475     } else {
1476         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1477     }
1478
1479     if (ost->stream_copy)
1480         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1481
1482     return ost;
1483 }
1484
1485 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1486 {
1487     int n;
1488     AVStream *st;
1489     OutputStream *ost;
1490     AVCodecContext *audio_enc;
1491
1492     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1493     st  = ost->st;
1494
1495     audio_enc = ost->enc_ctx;
1496     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1497
1498     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1499     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1500
1501     if (!ost->stream_copy) {
1502         char *sample_fmt = NULL;
1503
1504         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1505
1506         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1507         if (sample_fmt &&
1508             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1509             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1510             exit_program(1);
1511         }
1512
1513         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1514
1515         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1516         ost->apad = av_strdup(ost->apad);
1517
1518         ost->avfilter = get_ost_filters(o, oc, ost);
1519         if (!ost->avfilter)
1520             exit_program(1);
1521
1522         /* check for channel mapping for this audio stream */
1523         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1524             AudioChannelMap *map = &o->audio_channel_maps[n];
1525             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1526                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1527                 InputStream *ist;
1528
1529                 if (map->channel_idx == -1) {
1530                     ist = NULL;
1531                 } else if (ost->source_index < 0) {
1532                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1533                            ost->file_index, ost->st->index);
1534                     continue;
1535                 } else {
1536                     ist = input_streams[ost->source_index];
1537                 }
1538
1539                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1540                     if (av_reallocp_array(&ost->audio_channels_map,
1541                                           ost->audio_channels_mapped + 1,
1542                                           sizeof(*ost->audio_channels_map)
1543                                           ) < 0 )
1544                         exit_program(1);
1545
1546                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1547                 }
1548             }
1549         }
1550     }
1551
1552     if (ost->stream_copy)
1553         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1554
1555     return ost;
1556 }
1557
1558 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1559 {
1560     OutputStream *ost;
1561
1562     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1563     if (!ost->stream_copy) {
1564         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1565         exit_program(1);
1566     }
1567
1568     return ost;
1569 }
1570
1571 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1572 {
1573     OutputStream *ost;
1574
1575     ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1576     if (!ost->stream_copy) {
1577         av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1578         exit_program(1);
1579     }
1580
1581     return ost;
1582 }
1583
1584 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1585 {
1586     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1587     ost->stream_copy = 1;
1588     ost->finished    = 1;
1589     return ost;
1590 }
1591
1592 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1593 {
1594     AVStream *st;
1595     OutputStream *ost;
1596     AVCodecContext *subtitle_enc;
1597
1598     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1599     st  = ost->st;
1600     subtitle_enc = ost->enc_ctx;
1601
1602     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1603
1604     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1605
1606     if (!ost->stream_copy) {
1607         char *frame_size = NULL;
1608
1609         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1610         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1611             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1612             exit_program(1);
1613         }
1614     }
1615
1616     return ost;
1617 }
1618
1619 /* arg format is "output-stream-index:streamid-value". */
1620 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1621 {
1622     OptionsContext *o = optctx;
1623     int idx;
1624     char *p;
1625     char idx_str[16];
1626
1627     av_strlcpy(idx_str, arg, sizeof(idx_str));
1628     p = strchr(idx_str, ':');
1629     if (!p) {
1630         av_log(NULL, AV_LOG_FATAL,
1631                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1632                arg, opt);
1633         exit_program(1);
1634     }
1635     *p++ = '\0';
1636     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1637     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1638     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1639     return 0;
1640 }
1641
1642 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1643 {
1644     AVFormatContext *is = ifile->ctx;
1645     AVFormatContext *os = ofile->ctx;
1646     AVChapter **tmp;
1647     int i;
1648
1649     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1650     if (!tmp)
1651         return AVERROR(ENOMEM);
1652     os->chapters = tmp;
1653
1654     for (i = 0; i < is->nb_chapters; i++) {
1655         AVChapter *in_ch = is->chapters[i], *out_ch;
1656         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1657         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1658                                        AV_TIME_BASE_Q, in_ch->time_base);
1659         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1660                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1661
1662
1663         if (in_ch->end < ts_off)
1664             continue;
1665         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1666             break;
1667
1668         out_ch = av_mallocz(sizeof(AVChapter));
1669         if (!out_ch)
1670             return AVERROR(ENOMEM);
1671
1672         out_ch->id        = in_ch->id;
1673         out_ch->time_base = in_ch->time_base;
1674         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1675         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1676
1677         if (copy_metadata)
1678             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1679
1680         os->chapters[os->nb_chapters++] = out_ch;
1681     }
1682     return 0;
1683 }
1684
1685 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1686 {
1687     int i, err;
1688     AVFormatContext *ic = avformat_alloc_context();
1689
1690     ic->interrupt_callback = int_cb;
1691     err = avformat_open_input(&ic, filename, NULL, NULL);
1692     if (err < 0)
1693         return err;
1694     /* copy stream format */
1695     for(i=0;i<ic->nb_streams;i++) {
1696         AVStream *st;
1697         OutputStream *ost;
1698         AVCodec *codec;
1699         const char *enc_config;
1700
1701         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1702         if (!codec) {
1703             av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1704             return AVERROR(EINVAL);
1705         }
1706         if (codec->type == AVMEDIA_TYPE_AUDIO)
1707             opt_audio_codec(o, "c:a", codec->name);
1708         else if (codec->type == AVMEDIA_TYPE_VIDEO)
1709             opt_video_codec(o, "c:v", codec->name);
1710         ost   = new_output_stream(o, s, codec->type, -1);
1711         st    = ost->st;
1712
1713         avcodec_get_context_defaults3(st->codec, codec);
1714         enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1715         if (enc_config) {
1716             AVDictionary *opts = NULL;
1717             av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1718             av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1719             av_dict_free(&opts);
1720         }
1721
1722         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1723             choose_sample_fmt(st, codec);
1724         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1725             choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1726         avcodec_copy_context(ost->enc_ctx, st->codec);
1727         if (enc_config)
1728             av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1729     }
1730
1731     avformat_close_input(&ic);
1732     return err;
1733 }
1734
1735 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1736                                AVFormatContext *oc)
1737 {
1738     OutputStream *ost;
1739
1740     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1741                                   ofilter->out_tmp->pad_idx)) {
1742     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1743     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1744     default:
1745         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1746                "currently.\n");
1747         exit_program(1);
1748     }
1749
1750     ost->source_index = -1;
1751     ost->filter       = ofilter;
1752
1753     ofilter->ost      = ost;
1754
1755     if (ost->stream_copy) {
1756         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1757                "which is fed from a complex filtergraph. Filtering and streamcopy "
1758                "cannot be used together.\n", ost->file_index, ost->index);
1759         exit_program(1);
1760     }
1761
1762     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1763         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1764         av_log(NULL, AV_LOG_ERROR,
1765                "%s '%s' was specified through the %s option "
1766                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1767                "%s and -filter_complex cannot be used together for the same stream.\n",
1768                ost->filters ? "Filtergraph" : "Filtergraph script",
1769                ost->filters ? ost->filters : ost->filters_script,
1770                opt, ost->file_index, ost->index, opt);
1771         exit_program(1);
1772     }
1773
1774     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1775         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1776         exit_program(1);
1777     }
1778     avfilter_inout_free(&ofilter->out_tmp);
1779 }
1780
1781 static int configure_complex_filters(void)
1782 {
1783     int i, ret = 0;
1784
1785     for (i = 0; i < nb_filtergraphs; i++)
1786         if (!filtergraphs[i]->graph &&
1787             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1788             return ret;
1789     return 0;
1790 }
1791
1792 static int open_output_file(OptionsContext *o, const char *filename)
1793 {
1794     AVFormatContext *oc;
1795     int i, j, err;
1796     AVOutputFormat *file_oformat;
1797     OutputFile *of;
1798     OutputStream *ost;
1799     InputStream  *ist;
1800     AVDictionary *unused_opts = NULL;
1801     AVDictionaryEntry *e = NULL;
1802
1803     if (configure_complex_filters() < 0) {
1804         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1805         exit_program(1);
1806     }
1807
1808     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1809         o->stop_time = INT64_MAX;
1810         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1811     }
1812
1813     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1814         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1815         if (o->stop_time <= start_time) {
1816             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1817             exit_program(1);
1818         } else {
1819             o->recording_time = o->stop_time - start_time;
1820         }
1821     }
1822
1823     GROW_ARRAY(output_files, nb_output_files);
1824     of = av_mallocz(sizeof(*of));
1825     if (!of)
1826         exit_program(1);
1827     output_files[nb_output_files - 1] = of;
1828
1829     of->ost_index      = nb_output_streams;
1830     of->recording_time = o->recording_time;
1831     of->start_time     = o->start_time;
1832     of->limit_filesize = o->limit_filesize;
1833     of->shortest       = o->shortest;
1834     av_dict_copy(&of->opts, o->g->format_opts, 0);
1835
1836     if (!strcmp(filename, "-"))
1837         filename = "pipe:";
1838
1839     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1840     if (!oc) {
1841         print_error(filename, err);
1842         exit_program(1);
1843     }
1844
1845     of->ctx = oc;
1846     if (o->recording_time != INT64_MAX)
1847         oc->duration = o->recording_time;
1848
1849     file_oformat= oc->oformat;
1850     oc->interrupt_callback = int_cb;
1851
1852     /* create streams for all unlabeled output pads */
1853     for (i = 0; i < nb_filtergraphs; i++) {
1854         FilterGraph *fg = filtergraphs[i];
1855         for (j = 0; j < fg->nb_outputs; j++) {
1856             OutputFilter *ofilter = fg->outputs[j];
1857
1858             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1859                 continue;
1860
1861             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1862                                           ofilter->out_tmp->pad_idx)) {
1863             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1864             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1865             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1866             }
1867             init_output_filter(ofilter, o, oc);
1868         }
1869     }
1870
1871     /* ffserver seeking with date=... needs a date reference */
1872     if (!strcmp(file_oformat->name, "ffm") &&
1873         av_strstart(filename, "http:", NULL)) {
1874         int err = parse_option(o, "metadata", "creation_time=now", options);
1875         if (err < 0) {
1876             print_error(filename, err);
1877             exit_program(1);
1878         }
1879     }
1880
1881     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1882         av_strstart(filename, "http:", NULL)) {
1883         int j;
1884         /* special case for files sent to ffserver: we get the stream
1885            parameters from ffserver */
1886         int err = read_ffserver_streams(o, oc, filename);
1887         if (err < 0) {
1888             print_error(filename, err);
1889             exit_program(1);
1890         }
1891         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1892             ost = output_streams[j];
1893             for (i = 0; i < nb_input_streams; i++) {
1894                 ist = input_streams[i];
1895                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1896                     ost->sync_ist= ist;
1897                     ost->source_index= i;
1898                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1899                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1900                     ist->discard = 0;
1901                     ist->st->discard = ist->user_set_discard;
1902                     break;
1903                 }
1904             }
1905             if(!ost->sync_ist){
1906                 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));
1907                 exit_program(1);
1908             }
1909         }
1910     } else if (!o->nb_stream_maps) {
1911         char *subtitle_codec_name = NULL;
1912         /* pick the "best" stream of each type */
1913
1914         /* video: highest resolution */
1915         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1916             int area = 0, idx = -1;
1917             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1918             for (i = 0; i < nb_input_streams; i++) {
1919                 int new_area;
1920                 ist = input_streams[i];
1921                 new_area = ist->st->codec->width * ist->st->codec->height;
1922                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1923                     new_area = 1;
1924                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1925                     new_area > area) {
1926                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1927                         continue;
1928                     area = new_area;
1929                     idx = i;
1930                 }
1931             }
1932             if (idx >= 0)
1933                 new_video_stream(o, oc, idx);
1934         }
1935
1936         /* audio: most channels */
1937         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1938             int channels = 0, idx = -1;
1939             for (i = 0; i < nb_input_streams; i++) {
1940                 ist = input_streams[i];
1941                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1942                     ist->st->codec->channels > channels) {
1943                     channels = ist->st->codec->channels;
1944                     idx = i;
1945                 }
1946             }
1947             if (idx >= 0)
1948                 new_audio_stream(o, oc, idx);
1949         }
1950
1951         /* subtitles: pick first */
1952         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1953         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1954             for (i = 0; i < nb_input_streams; i++)
1955                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1956                     AVCodecDescriptor const *input_descriptor =
1957                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1958                     AVCodecDescriptor const *output_descriptor = NULL;
1959                     AVCodec const *output_codec =
1960                         avcodec_find_encoder(oc->oformat->subtitle_codec);
1961                     int input_props = 0, output_props = 0;
1962                     if (output_codec)
1963                         output_descriptor = avcodec_descriptor_get(output_codec->id);
1964                     if (input_descriptor)
1965                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1966                     if (output_descriptor)
1967                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1968                     if (subtitle_codec_name ||
1969                         input_props & output_props ||
1970                         // Map dvb teletext which has neither property to any output subtitle encoder
1971                         input_descriptor && output_descriptor &&
1972                         (!input_descriptor->props ||
1973                          !output_descriptor->props)) {
1974                         new_subtitle_stream(o, oc, i);
1975                         break;
1976                     }
1977                 }
1978         }
1979         /* Data only if codec id match */
1980         if (!o->data_disable ) {
1981             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1982             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1983                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1984                     && input_streams[i]->st->codec->codec_id == codec_id )
1985                     new_data_stream(o, oc, i);
1986             }
1987         }
1988     } else {
1989         for (i = 0; i < o->nb_stream_maps; i++) {
1990             StreamMap *map = &o->stream_maps[i];
1991
1992             if (map->disabled)
1993                 continue;
1994
1995             if (map->linklabel) {
1996                 FilterGraph *fg;
1997                 OutputFilter *ofilter = NULL;
1998                 int j, k;
1999
2000                 for (j = 0; j < nb_filtergraphs; j++) {
2001                     fg = filtergraphs[j];
2002                     for (k = 0; k < fg->nb_outputs; k++) {
2003                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2004                         if (out && !strcmp(out->name, map->linklabel)) {
2005                             ofilter = fg->outputs[k];
2006                             goto loop_end;
2007                         }
2008                     }
2009                 }
2010 loop_end:
2011                 if (!ofilter) {
2012                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2013                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2014                     exit_program(1);
2015                 }
2016                 init_output_filter(ofilter, o, oc);
2017             } else {
2018                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2019
2020                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2021                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2022                     continue;
2023                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2024                     continue;
2025                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2026                     continue;
2027                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2028                     continue;
2029
2030                 ost = NULL;
2031                 switch (ist->st->codec->codec_type) {
2032                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2033                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2034                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2035                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2036                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2037                 case AVMEDIA_TYPE_UNKNOWN:
2038                     if (copy_unknown_streams) {
2039                         ost = new_unknown_stream   (o, oc, src_idx);
2040                         break;
2041                     }
2042                 default:
2043                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2044                            "Cannot map stream #%d:%d - unsupported type.\n",
2045                            map->file_index, map->stream_index);
2046                     if (!ignore_unknown_streams) {
2047                         av_log(NULL, AV_LOG_FATAL,
2048                                "If you want unsupported types ignored instead "
2049                                "of failing, please use the -ignore_unknown option\n"
2050                                "If you want them copied, please use -copy_unknown\n");
2051                         exit_program(1);
2052                     }
2053                 }
2054                 if (ost)
2055                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2056                                                   + map->sync_stream_index];
2057             }
2058         }
2059     }
2060
2061     /* handle attached files */
2062     for (i = 0; i < o->nb_attachments; i++) {
2063         AVIOContext *pb;
2064         uint8_t *attachment;
2065         const char *p;
2066         int64_t len;
2067
2068         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2069             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2070                    o->attachments[i]);
2071             exit_program(1);
2072         }
2073         if ((len = avio_size(pb)) <= 0) {
2074             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2075                    o->attachments[i]);
2076             exit_program(1);
2077         }
2078         if (!(attachment = av_malloc(len))) {
2079             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2080                    o->attachments[i]);
2081             exit_program(1);
2082         }
2083         avio_read(pb, attachment, len);
2084
2085         ost = new_attachment_stream(o, oc, -1);
2086         ost->stream_copy               = 0;
2087         ost->attachment_filename       = o->attachments[i];
2088         ost->finished                  = 1;
2089         ost->st->codec->extradata      = attachment;
2090         ost->st->codec->extradata_size = len;
2091
2092         p = strrchr(o->attachments[i], '/');
2093         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2094         avio_closep(&pb);
2095     }
2096
2097     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2098         AVDictionaryEntry *e;
2099         ost = output_streams[i];
2100
2101         if ((ost->stream_copy || ost->attachment_filename)
2102             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2103             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2104             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2105                 exit_program(1);
2106     }
2107
2108     /* check if all codec options have been used */
2109     unused_opts = strip_specifiers(o->g->codec_opts);
2110     for (i = of->ost_index; i < nb_output_streams; i++) {
2111         e = NULL;
2112         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2113                                 AV_DICT_IGNORE_SUFFIX)))
2114             av_dict_set(&unused_opts, e->key, NULL, 0);
2115     }
2116
2117     e = NULL;
2118     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2119         const AVClass *class = avcodec_get_class();
2120         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2121                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2122         const AVClass *fclass = avformat_get_class();
2123         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2124                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2125         if (!option || foption)
2126             continue;
2127
2128
2129         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2130             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2131                    "output file #%d (%s) is not an encoding option.\n", e->key,
2132                    option->help ? option->help : "", nb_output_files - 1,
2133                    filename);
2134             exit_program(1);
2135         }
2136
2137         // gop_timecode is injected by generic code but not always used
2138         if (!strcmp(e->key, "gop_timecode"))
2139             continue;
2140
2141         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2142                "output file #%d (%s) has not been used for any stream. The most "
2143                "likely reason is either wrong type (e.g. a video option with "
2144                "no video streams) or that it is a private option of some encoder "
2145                "which was not actually used for any stream.\n", e->key,
2146                option->help ? option->help : "", nb_output_files - 1, filename);
2147     }
2148     av_dict_free(&unused_opts);
2149
2150     /* check filename in case of an image number is expected */
2151     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2152         if (!av_filename_number_test(oc->filename)) {
2153             print_error(oc->filename, AVERROR(EINVAL));
2154             exit_program(1);
2155         }
2156     }
2157
2158     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2159         av_log(NULL, AV_LOG_ERROR,
2160                "No input streams but output needs an input stream\n");
2161         exit_program(1);
2162     }
2163
2164     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2165         /* test if it already exists to avoid losing precious files */
2166         assert_file_overwrite(filename);
2167
2168         /* open the file */
2169         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2170                               &oc->interrupt_callback,
2171                               &of->opts)) < 0) {
2172             print_error(filename, err);
2173             exit_program(1);
2174         }
2175     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2176         assert_file_overwrite(filename);
2177
2178     if (o->mux_preload) {
2179         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2180     }
2181     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2182
2183     /* copy metadata */
2184     for (i = 0; i < o->nb_metadata_map; i++) {
2185         char *p;
2186         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2187
2188         if (in_file_index >= nb_input_files) {
2189             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2190             exit_program(1);
2191         }
2192         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2193                       in_file_index >= 0 ?
2194                       input_files[in_file_index]->ctx : NULL, o);
2195     }
2196
2197     /* copy chapters */
2198     if (o->chapters_input_file >= nb_input_files) {
2199         if (o->chapters_input_file == INT_MAX) {
2200             /* copy chapters from the first input file that has them*/
2201             o->chapters_input_file = -1;
2202             for (i = 0; i < nb_input_files; i++)
2203                 if (input_files[i]->ctx->nb_chapters) {
2204                     o->chapters_input_file = i;
2205                     break;
2206                 }
2207         } else {
2208             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2209                    o->chapters_input_file);
2210             exit_program(1);
2211         }
2212     }
2213     if (o->chapters_input_file >= 0)
2214         copy_chapters(input_files[o->chapters_input_file], of,
2215                       !o->metadata_chapters_manual);
2216
2217     /* copy global metadata by default */
2218     if (!o->metadata_global_manual && nb_input_files){
2219         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2220                      AV_DICT_DONT_OVERWRITE);
2221         if(o->recording_time != INT64_MAX)
2222             av_dict_set(&oc->metadata, "duration", NULL, 0);
2223         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2224     }
2225     if (!o->metadata_streams_manual)
2226         for (i = of->ost_index; i < nb_output_streams; i++) {
2227             InputStream *ist;
2228             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2229                 continue;
2230             ist = input_streams[output_streams[i]->source_index];
2231             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2232             if (!output_streams[i]->stream_copy) {
2233                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2234                 if (ist->autorotate)
2235                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2236             }
2237         }
2238
2239     /* process manually set metadata */
2240     for (i = 0; i < o->nb_metadata; i++) {
2241         AVDictionary **m;
2242         char type, *val;
2243         const char *stream_spec;
2244         int index = 0, j, ret = 0;
2245         char now_time[256];
2246
2247         val = strchr(o->metadata[i].u.str, '=');
2248         if (!val) {
2249             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2250                    o->metadata[i].u.str);
2251             exit_program(1);
2252         }
2253         *val++ = 0;
2254
2255         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2256             !strcmp(val, "now")) {
2257             time_t now = time(0);
2258             struct tm *ptm, tmbuf;
2259             ptm = localtime_r(&now, &tmbuf);
2260             if (ptm) {
2261                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2262                     val = now_time;
2263             }
2264         }
2265
2266         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2267         if (type == 's') {
2268             for (j = 0; j < oc->nb_streams; j++) {
2269                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2270                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2271                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2272                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2273                         ost->rotate_overridden = 1;
2274                     }
2275                 } else if (ret < 0)
2276                     exit_program(1);
2277             }
2278         }
2279         else {
2280             switch (type) {
2281             case 'g':
2282                 m = &oc->metadata;
2283                 break;
2284             case 'c':
2285                 if (index < 0 || index >= oc->nb_chapters) {
2286                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2287                     exit_program(1);
2288                 }
2289                 m = &oc->chapters[index]->metadata;
2290                 break;
2291             default:
2292                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2293                 exit_program(1);
2294             }
2295             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2296         }
2297     }
2298
2299     return 0;
2300 }
2301
2302 static int opt_target(void *optctx, const char *opt, const char *arg)
2303 {
2304     OptionsContext *o = optctx;
2305     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2306     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2307
2308     if (!strncmp(arg, "pal-", 4)) {
2309         norm = PAL;
2310         arg += 4;
2311     } else if (!strncmp(arg, "ntsc-", 5)) {
2312         norm = NTSC;
2313         arg += 5;
2314     } else if (!strncmp(arg, "film-", 5)) {
2315         norm = FILM;
2316         arg += 5;
2317     } else {
2318         /* Try to determine PAL/NTSC by peeking in the input files */
2319         if (nb_input_files) {
2320             int i, j, fr;
2321             for (j = 0; j < nb_input_files; j++) {
2322                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2323                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2324                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2325                         !c->time_base.num)
2326                         continue;
2327                     fr = c->time_base.den * 1000 / c->time_base.num;
2328                     if (fr == 25000) {
2329                         norm = PAL;
2330                         break;
2331                     } else if ((fr == 29970) || (fr == 23976)) {
2332                         norm = NTSC;
2333                         break;
2334                     }
2335                 }
2336                 if (norm != UNKNOWN)
2337                     break;
2338             }
2339         }
2340         if (norm != UNKNOWN)
2341             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2342     }
2343
2344     if (norm == UNKNOWN) {
2345         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2346         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2347         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2348         exit_program(1);
2349     }
2350
2351     if (!strcmp(arg, "vcd")) {
2352         opt_video_codec(o, "c:v", "mpeg1video");
2353         opt_audio_codec(o, "c:a", "mp2");
2354         parse_option(o, "f", "vcd", options);
2355
2356         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2357         parse_option(o, "r", frame_rates[norm], options);
2358         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2359
2360         opt_default(NULL, "b:v", "1150000");
2361         opt_default(NULL, "maxrate:v", "1150000");
2362         opt_default(NULL, "minrate:v", "1150000");
2363         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2364
2365         opt_default(NULL, "b:a", "224000");
2366         parse_option(o, "ar", "44100", options);
2367         parse_option(o, "ac", "2", options);
2368
2369         opt_default(NULL, "packetsize", "2324");
2370         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2371
2372         /* We have to offset the PTS, so that it is consistent with the SCR.
2373            SCR starts at 36000, but the first two packs contain only padding
2374            and the first pack from the other stream, respectively, may also have
2375            been written before.
2376            So the real data starts at SCR 36000+3*1200. */
2377         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2378     } else if (!strcmp(arg, "svcd")) {
2379
2380         opt_video_codec(o, "c:v", "mpeg2video");
2381         opt_audio_codec(o, "c:a", "mp2");
2382         parse_option(o, "f", "svcd", options);
2383
2384         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2385         parse_option(o, "r", frame_rates[norm], options);
2386         parse_option(o, "pix_fmt", "yuv420p", options);
2387         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2388
2389         opt_default(NULL, "b:v", "2040000");
2390         opt_default(NULL, "maxrate:v", "2516000");
2391         opt_default(NULL, "minrate:v", "0"); // 1145000;
2392         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2393         opt_default(NULL, "scan_offset", "1");
2394
2395         opt_default(NULL, "b:a", "224000");
2396         parse_option(o, "ar", "44100", options);
2397
2398         opt_default(NULL, "packetsize", "2324");
2399
2400     } else if (!strcmp(arg, "dvd")) {
2401
2402         opt_video_codec(o, "c:v", "mpeg2video");
2403         opt_audio_codec(o, "c:a", "ac3");
2404         parse_option(o, "f", "dvd", options);
2405
2406         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2407         parse_option(o, "r", frame_rates[norm], options);
2408         parse_option(o, "pix_fmt", "yuv420p", options);
2409         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2410
2411         opt_default(NULL, "b:v", "6000000");
2412         opt_default(NULL, "maxrate:v", "9000000");
2413         opt_default(NULL, "minrate:v", "0"); // 1500000;
2414         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2415
2416         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2417         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2418
2419         opt_default(NULL, "b:a", "448000");
2420         parse_option(o, "ar", "48000", options);
2421
2422     } else if (!strncmp(arg, "dv", 2)) {
2423
2424         parse_option(o, "f", "dv", options);
2425
2426         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2427         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2428                           norm == PAL ? "yuv420p" : "yuv411p", options);
2429         parse_option(o, "r", frame_rates[norm], options);
2430
2431         parse_option(o, "ar", "48000", options);
2432         parse_option(o, "ac", "2", options);
2433
2434     } else {
2435         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2436         return AVERROR(EINVAL);
2437     }
2438
2439     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2440     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2441
2442     return 0;
2443 }
2444
2445 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2446 {
2447     av_free (vstats_filename);
2448     vstats_filename = av_strdup (arg);
2449     return 0;
2450 }
2451
2452 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2453 {
2454     char filename[40];
2455     time_t today2 = time(NULL);
2456     struct tm *today = localtime(&today2);
2457
2458     if (!today) { // maybe tomorrow
2459         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2460         exit_program(1);
2461     }
2462
2463     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2464              today->tm_sec);
2465     return opt_vstats_file(NULL, opt, filename);
2466 }
2467
2468 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2469 {
2470     OptionsContext *o = optctx;
2471     return parse_option(o, "frames:v", arg, options);
2472 }
2473
2474 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2475 {
2476     OptionsContext *o = optctx;
2477     return parse_option(o, "frames:a", arg, options);
2478 }
2479
2480 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2481 {
2482     OptionsContext *o = optctx;
2483     return parse_option(o, "frames:d", arg, options);
2484 }
2485
2486 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2487 {
2488     int ret;
2489     AVDictionary *cbak = codec_opts;
2490     AVDictionary *fbak = format_opts;
2491     codec_opts = NULL;
2492     format_opts = NULL;
2493
2494     ret = opt_default(NULL, opt, arg);
2495
2496     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2497     av_dict_copy(&o->g->format_opts, format_opts, 0);
2498     av_dict_free(&codec_opts);
2499     av_dict_free(&format_opts);
2500     codec_opts = cbak;
2501     format_opts = fbak;
2502
2503     return ret;
2504 }
2505
2506 static int opt_preset(void *optctx, const char *opt, const char *arg)
2507 {
2508     OptionsContext *o = optctx;
2509     FILE *f=NULL;
2510     char filename[1000], line[1000], tmp_line[1000];
2511     const char *codec_name = NULL;
2512
2513     tmp_line[0] = *opt;
2514     tmp_line[1] = 0;
2515     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2516
2517     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2518         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2519             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2520         }else
2521             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2522         exit_program(1);
2523     }
2524
2525     while (fgets(line, sizeof(line), f)) {
2526         char *key = tmp_line, *value, *endptr;
2527
2528         if (strcspn(line, "#\n\r") == 0)
2529             continue;
2530         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2531         if (!av_strtok(key,   "=",    &value) ||
2532             !av_strtok(value, "\r\n", &endptr)) {
2533             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2534             exit_program(1);
2535         }
2536         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2537
2538         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2539         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2540         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2541         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2542         else if (opt_default_new(o, key, value) < 0) {
2543             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2544                    filename, line, key, value);
2545             exit_program(1);
2546         }
2547     }
2548
2549     fclose(f);
2550
2551     return 0;
2552 }
2553
2554 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2555 {
2556     OptionsContext *o = optctx;
2557     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2558     int ret = parse_option(o, s, arg, options);
2559     av_free(s);
2560     return ret;
2561 }
2562
2563 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2564 {
2565     OptionsContext *o = optctx;
2566
2567     if(!strcmp(opt, "ab")){
2568         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2569         return 0;
2570     } else if(!strcmp(opt, "b")){
2571         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2572         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2573         return 0;
2574     }
2575     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2576     return 0;
2577 }
2578
2579 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2580 {
2581     OptionsContext *o = optctx;
2582     char *s;
2583     int ret;
2584     if(!strcmp(opt, "qscale")){
2585         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2586         return parse_option(o, "q:v", arg, options);
2587     }
2588     s = av_asprintf("q%s", opt + 6);
2589     ret = parse_option(o, s, arg, options);
2590     av_free(s);
2591     return ret;
2592 }
2593
2594 static int opt_profile(void *optctx, const char *opt, const char *arg)
2595 {
2596     OptionsContext *o = optctx;
2597     if(!strcmp(opt, "profile")){
2598         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2599         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2600         return 0;
2601     }
2602     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2603     return 0;
2604 }
2605
2606 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2607 {
2608     OptionsContext *o = optctx;
2609     return parse_option(o, "filter:v", arg, options);
2610 }
2611
2612 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2613 {
2614     OptionsContext *o = optctx;
2615     return parse_option(o, "filter:a", arg, options);
2616 }
2617
2618 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2619 {
2620     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2621     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2622     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2623     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2624
2625     if (video_sync_method == VSYNC_AUTO)
2626         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2627     return 0;
2628 }
2629
2630 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2631 {
2632     OptionsContext *o = optctx;
2633     char *tcr = av_asprintf("timecode=%s", arg);
2634     int ret = parse_option(o, "metadata:g", tcr, options);
2635     if (ret >= 0)
2636         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2637     av_free(tcr);
2638     return 0;
2639 }
2640
2641 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2642 {
2643     OptionsContext *o = optctx;
2644     char layout_str[32];
2645     char *stream_str;
2646     char *ac_str;
2647     int ret, channels, ac_str_size;
2648     uint64_t layout;
2649
2650     layout = av_get_channel_layout(arg);
2651     if (!layout) {
2652         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2653         return AVERROR(EINVAL);
2654     }
2655     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2656     ret = opt_default_new(o, opt, layout_str);
2657     if (ret < 0)
2658         return ret;
2659
2660     /* set 'ac' option based on channel layout */
2661     channels = av_get_channel_layout_nb_channels(layout);
2662     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2663     stream_str = strchr(opt, ':');
2664     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2665     ac_str = av_mallocz(ac_str_size);
2666     if (!ac_str)
2667         return AVERROR(ENOMEM);
2668     av_strlcpy(ac_str, "ac", 3);
2669     if (stream_str)
2670         av_strlcat(ac_str, stream_str, ac_str_size);
2671     ret = parse_option(o, ac_str, layout_str, options);
2672     av_free(ac_str);
2673
2674     return ret;
2675 }
2676
2677 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2678 {
2679     OptionsContext *o = optctx;
2680     return parse_option(o, "q:a", arg, options);
2681 }
2682
2683 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2684 {
2685     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2686     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2687         return AVERROR(ENOMEM);
2688     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2689     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2690     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2691         return AVERROR(ENOMEM);
2692
2693     input_stream_potentially_available = 1;
2694
2695     return 0;
2696 }
2697
2698 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2699 {
2700     uint8_t *graph_desc = read_file(arg);
2701     if (!graph_desc)
2702         return AVERROR(EINVAL);
2703
2704     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2705     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2706         return AVERROR(ENOMEM);
2707     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2708     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2709
2710     input_stream_potentially_available = 1;
2711
2712     return 0;
2713 }
2714
2715 void show_help_default(const char *opt, const char *arg)
2716 {
2717     /* per-file options have at least one of those set */
2718     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2719     int show_advanced = 0, show_avoptions = 0;
2720
2721     if (opt && *opt) {
2722         if (!strcmp(opt, "long"))
2723             show_advanced = 1;
2724         else if (!strcmp(opt, "full"))
2725             show_advanced = show_avoptions = 1;
2726         else
2727             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2728     }
2729
2730     show_usage();
2731
2732     printf("Getting help:\n"
2733            "    -h      -- print basic options\n"
2734            "    -h long -- print more options\n"
2735            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2736            "    See man %s for detailed description of the options.\n"
2737            "\n", program_name);
2738
2739     show_help_options(options, "Print help / information / capabilities:",
2740                       OPT_EXIT, 0, 0);
2741
2742     show_help_options(options, "Global options (affect whole program "
2743                       "instead of just one file:",
2744                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2745     if (show_advanced)
2746         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2747                           per_file | OPT_EXIT, 0);
2748
2749     show_help_options(options, "Per-file main options:", 0,
2750                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2751                       OPT_EXIT, per_file);
2752     if (show_advanced)
2753         show_help_options(options, "Advanced per-file options:",
2754                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2755
2756     show_help_options(options, "Video options:",
2757                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2758     if (show_advanced)
2759         show_help_options(options, "Advanced Video options:",
2760                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2761
2762     show_help_options(options, "Audio options:",
2763                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2764     if (show_advanced)
2765         show_help_options(options, "Advanced Audio options:",
2766                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2767     show_help_options(options, "Subtitle options:",
2768                       OPT_SUBTITLE, 0, 0);
2769     printf("\n");
2770
2771     if (show_avoptions) {
2772         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2773         show_help_children(avcodec_get_class(), flags);
2774         show_help_children(avformat_get_class(), flags);
2775 #if CONFIG_SWSCALE
2776         show_help_children(sws_get_class(), flags);
2777 #endif
2778         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2779         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2780     }
2781 }
2782
2783 void show_usage(void)
2784 {
2785     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2786     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2787     av_log(NULL, AV_LOG_INFO, "\n");
2788 }
2789
2790 enum OptGroup {
2791     GROUP_OUTFILE,
2792     GROUP_INFILE,
2793 };
2794
2795 static const OptionGroupDef groups[] = {
2796     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2797     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2798 };
2799
2800 static int open_files(OptionGroupList *l, const char *inout,
2801                       int (*open_file)(OptionsContext*, const char*))
2802 {
2803     int i, ret;
2804
2805     for (i = 0; i < l->nb_groups; i++) {
2806         OptionGroup *g = &l->groups[i];
2807         OptionsContext o;
2808
2809         init_options(&o);
2810         o.g = g;
2811
2812         ret = parse_optgroup(&o, g);
2813         if (ret < 0) {
2814             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2815                    "%s.\n", inout, g->arg);
2816             return ret;
2817         }
2818
2819         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2820         ret = open_file(&o, g->arg);
2821         uninit_options(&o);
2822         if (ret < 0) {
2823             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2824                    inout, g->arg);
2825             return ret;
2826         }
2827         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2828     }
2829
2830     return 0;
2831 }
2832
2833 int ffmpeg_parse_options(int argc, char **argv)
2834 {
2835     OptionParseContext octx;
2836     uint8_t error[128];
2837     int ret;
2838
2839     memset(&octx, 0, sizeof(octx));
2840
2841     /* split the commandline into an internal representation */
2842     ret = split_commandline(&octx, argc, argv, options, groups,
2843                             FF_ARRAY_ELEMS(groups));
2844     if (ret < 0) {
2845         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2846         goto fail;
2847     }
2848
2849     /* apply global options */
2850     ret = parse_optgroup(NULL, &octx.global_opts);
2851     if (ret < 0) {
2852         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2853         goto fail;
2854     }
2855
2856     /* open input files */
2857     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2858     if (ret < 0) {
2859         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2860         goto fail;
2861     }
2862
2863     /* open output files */
2864     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2865     if (ret < 0) {
2866         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2867         goto fail;
2868     }
2869
2870 fail:
2871     uninit_parse_context(&octx);
2872     if (ret < 0) {
2873         av_strerror(ret, error, sizeof(error));
2874         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2875     }
2876     return ret;
2877 }
2878
2879 static int opt_progress(void *optctx, const char *opt, const char *arg)
2880 {
2881     AVIOContext *avio = NULL;
2882     int ret;
2883
2884     if (!strcmp(arg, "-"))
2885         arg = "pipe:";
2886     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2887     if (ret < 0) {
2888         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2889                arg, av_err2str(ret));
2890         return ret;
2891     }
2892     progress_avio = avio;
2893     return 0;
2894 }
2895
2896 #define OFFSET(x) offsetof(OptionsContext, x)
2897 const OptionDef options[] = {
2898     /* main options */
2899 #include "cmdutils_common_opts.h"
2900     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2901                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2902         "force format", "fmt" },
2903     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2904         "overwrite output files" },
2905     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2906         "never overwrite output files" },
2907     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
2908         "Ignore unknown stream types" },
2909     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
2910         "Copy unknown stream types" },
2911     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2912                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2913         "codec name", "codec" },
2914     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2915                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2916         "codec name", "codec" },
2917     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2918                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2919         "preset name", "preset" },
2920     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2921                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2922         "set input stream mapping",
2923         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2924     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2925         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2926     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2927                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2928         "set metadata information of outfile from infile",
2929         "outfile[,metadata]:infile[,metadata]" },
2930     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2931                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2932         "set chapters mapping", "input_file_index" },
2933     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2934                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2935         "record or transcode \"duration\" seconds of audio/video",
2936         "duration" },
2937     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2938         "record or transcode stop time", "time_stop" },
2939     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2940         "set the limit file size in bytes", "limit_size" },
2941     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2942                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2943         "set the start time offset", "time_off" },
2944     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
2945                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
2946         "enable/disable seeking by timestamp with -ss" },
2947     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2948                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2949         "enable/disable accurate seeking with -ss" },
2950     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2951                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2952         "set the input ts offset", "time_off" },
2953     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2954                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2955         "set the input ts scale", "scale" },
2956     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
2957         "set the recording timestamp ('now' to set the current time)", "time" },
2958     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2959         "add metadata", "string=string" },
2960     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2961                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2962         "set the number of data frames to output", "number" },
2963     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2964         "add timings for benchmarking" },
2965     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2966       "add timings for each task" },
2967     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2968       "write program-readable progress information", "url" },
2969     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2970       "enable or disable interaction on standard input" },
2971     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2972         "set max runtime in seconds", "limit" },
2973     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2974         "dump each input packet" },
2975     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2976         "when dumping packets, also dump the payload" },
2977     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2978                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2979         "read input at native frame rate", "" },
2980     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2981         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2982         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2983     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2984         "video sync method", "" },
2985     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
2986         "frame drop threshold", "" },
2987     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2988         "audio sync method", "" },
2989     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2990         "audio drift threshold", "threshold" },
2991     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2992         "copy timestamps" },
2993     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
2994         "shift input timestamps to start at 0 when using copyts" },
2995     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2996         "copy input stream time base when stream copying", "mode" },
2997     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2998                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2999         "finish encoding within shortest input" },
3000     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3001                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3002         "audio pad", "" },
3003     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3004         "timestamp discontinuity delta threshold", "threshold" },
3005     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3006         "timestamp error delta threshold", "threshold" },
3007     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3008         "exit on error", "error" },
3009     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3010                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3011         "copy initial non-keyframes" },
3012     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3013         "copy or discard frames before start time" },
3014     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3015         "set the number of frames to output", "number" },
3016     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3017                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3018         "force codec tag/fourcc", "fourcc/tag" },
3019     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3020                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3021         "use fixed quality scale (VBR)", "q" },
3022     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3023                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3024         "use fixed quality scale (VBR)", "q" },
3025     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3026         "set profile", "profile" },
3027     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3028         "set stream filtergraph", "filter_graph" },
3029     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3030         "read stream filtergraph description from a file", "filename" },
3031     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3032         "reinit filtergraph on input parameter changes", "" },
3033     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3034         "create a complex filtergraph", "graph_description" },
3035     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3036         "create a complex filtergraph", "graph_description" },
3037     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3038         "read complex filtergraph description from a file", "filename" },
3039     { "stats",          OPT_BOOL,                                    { &print_stats },
3040         "print progress report during encoding", },
3041     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3042                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3043         "add an attachment to the output file", "filename" },
3044     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3045                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3046         "extract an attachment into a file", "filename" },
3047     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3048         "print timestamp debugging info" },
3049     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3050         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3051     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3052                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3053         "discard", "" },
3054     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3055                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3056         "disposition", "" },
3057     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3058                                                                      { .off = OFFSET(thread_queue_size) },
3059         "set the maximum number of queued packets from the demuxer" },
3060
3061     /* video options */
3062     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3063         "set the number of video frames to output", "number" },
3064     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3065                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3066         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3067     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3068                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3069         "set frame size (WxH or abbreviation)", "size" },
3070     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3071                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3072         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3073     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3074                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3075         "set pixel format", "format" },
3076     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3077         "set the number of bits per raw sample", "number" },
3078     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3079         "deprecated use -g 1" },
3080     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3081         "disable video" },
3082     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3083                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3084         "rate control override for specific intervals", "override" },
3085     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3086                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3087         "force video codec ('copy' to copy stream)", "codec" },
3088     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3089         "Removed" },
3090     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3091         "Removed" },
3092     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3093         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3094     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3095         "select the pass number (1 to 3)", "n" },
3096     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3097                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3098         "select two pass log file name prefix", "prefix" },
3099     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3100         "this option is deprecated, use the yadif filter instead" },
3101     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3102         "calculate PSNR of compressed frames" },
3103     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
3104         "dump video coding statistics to file" },
3105     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
3106         "dump video coding statistics to file", "file" },
3107     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3108         "set video filters", "filter_graph" },
3109     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3110                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3111         "specify intra matrix coeffs", "matrix" },
3112     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3113                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3114         "specify inter matrix coeffs", "matrix" },
3115     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3116                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3117         "specify intra matrix coeffs", "matrix" },
3118     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3119                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3120         "top=1/bottom=0/auto=-1 field first", "" },
3121     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3122                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3123         "force video tag/fourcc", "fourcc/tag" },
3124     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3125         "show QP histogram" },
3126     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3127                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3128         "force the selected framerate, disable the best supported framerate selection" },
3129     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3130                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3131         "set the value of an outfile streamid", "streamIndex:value" },
3132     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3133                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3134         "force key frames at specified timestamps", "timestamps" },
3135     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3136         "audio bitrate (please use -b:a)", "bitrate" },
3137     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3138         "video bitrate (please use -b:v)", "bitrate" },
3139     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3140                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3141         "use HW accelerated decoding", "hwaccel name" },
3142     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3143                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3144         "select a device for HW acceleration" "devicename" },
3145 #if HAVE_VDPAU_X11
3146     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3147 #endif
3148     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3149                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3150         "automatically insert correct rotate filters" },
3151
3152     /* audio options */
3153     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3154         "set the number of audio frames to output", "number" },
3155     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3156         "set audio quality (codec-specific)", "quality", },
3157     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3158                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3159         "set audio sampling rate (in Hz)", "rate" },
3160     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3161                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3162         "set number of audio channels", "channels" },
3163     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3164         "disable audio" },
3165     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3166                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3167         "force audio codec ('copy' to copy stream)", "codec" },
3168     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3169                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3170         "force audio tag/fourcc", "fourcc/tag" },
3171     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3172         "change audio volume (256=normal)" , "volume" },
3173     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3174                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3175         "set sample format", "format" },
3176     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3177                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3178         "set channel layout", "layout" },
3179     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3180         "set audio filters", "filter_graph" },
3181     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3182       "set the maximum number of channels to try to guess the channel layout" },
3183
3184     /* subtitle options */
3185     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3186         "disable subtitle" },
3187     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3188         "force subtitle codec ('copy' to copy stream)", "codec" },
3189     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3190         , "force subtitle tag/fourcc", "fourcc/tag" },
3191     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3192         "fix subtitles duration" },
3193     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3194         "set canvas size (WxH or abbreviation)", "size" },
3195
3196     /* grab options */
3197     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3198         "deprecated, use -channel", "channel" },
3199     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3200         "deprecated, use -standard", "standard" },
3201     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3202
3203     /* muxer options */
3204     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3205         "set the maximum demux-decode delay", "seconds" },
3206     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3207         "set the initial demux-decode delay", "seconds" },
3208     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3209         "override the options from ffserver", "" },
3210     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3211         "specify a file in which to print sdp information", "file" },
3212
3213     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3214         "A comma-separated list of bitstream filters", "bitstream_filters" },
3215     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3216         "deprecated", "audio bitstream_filters" },
3217     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3218         "deprecated", "video bitstream_filters" },
3219
3220     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3221         "set the audio options to the indicated preset", "preset" },
3222     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3223         "set the video options to the indicated preset", "preset" },
3224     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3225         "set the subtitle options to the indicated preset", "preset" },
3226     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3227         "set options from indicated preset file", "filename" },
3228     /* data codec support */
3229     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3230         "force data codec ('copy' to copy stream)", "codec" },
3231     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3232         "disable data" },
3233
3234     { NULL, },
3235 };