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