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