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         if (!video_enc->rc_initial_buffer_occupancy)
1149             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1150         video_enc->intra_dc_precision = intra_dc_precision - 8;
1151
1152         if (do_psnr)
1153             video_enc->flags|= CODEC_FLAG_PSNR;
1154
1155         /* two pass mode */
1156         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1157         if (do_pass) {
1158             if (do_pass & 1) {
1159                 video_enc->flags |= CODEC_FLAG_PASS1;
1160             }
1161             if (do_pass & 2) {
1162                 video_enc->flags |= CODEC_FLAG_PASS2;
1163             }
1164         }
1165
1166         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1167         if (ost->logfile_prefix &&
1168             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1169             exit(1);
1170
1171         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1172         if (ost->forced_keyframes)
1173             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1174
1175         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1176
1177         ost->top_field_first = -1;
1178         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1179
1180         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1181         ost->avfilter = av_strdup(filters);
1182     } else {
1183         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1184     }
1185
1186     return ost;
1187 }
1188
1189 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1190 {
1191     int n;
1192     AVStream *st;
1193     OutputStream *ost;
1194     AVCodecContext *audio_enc;
1195
1196     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1197     st  = ost->st;
1198
1199     audio_enc = st->codec;
1200     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1201
1202     if (!ost->stream_copy) {
1203         char *sample_fmt = NULL;
1204         const char *filters = "anull";
1205
1206         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1207
1208         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1209         if (sample_fmt &&
1210             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1211             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1212             exit(1);
1213         }
1214
1215         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1216
1217         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1218
1219         av_assert1(filters);
1220         ost->avfilter = av_strdup(filters);
1221
1222         /* check for channel mapping for this audio stream */
1223         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1224             AudioChannelMap *map = &o->audio_channel_maps[n];
1225             InputStream *ist = input_streams[ost->source_index];
1226             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1227                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1228                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1229                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1230                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1231                 else
1232                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1233                            ost->file_index, ost->st->index);
1234             }
1235         }
1236     }
1237
1238     return ost;
1239 }
1240
1241 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1242 {
1243     OutputStream *ost;
1244
1245     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1246     if (!ost->stream_copy) {
1247         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1248         exit(1);
1249     }
1250
1251     return ost;
1252 }
1253
1254 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1255 {
1256     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1257     ost->stream_copy = 1;
1258     return ost;
1259 }
1260
1261 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1262 {
1263     AVStream *st;
1264     OutputStream *ost;
1265     AVCodecContext *subtitle_enc;
1266
1267     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1268     st  = ost->st;
1269     subtitle_enc = st->codec;
1270
1271     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1272
1273     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1274
1275     if (!ost->stream_copy) {
1276         char *frame_size = NULL;
1277
1278         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1279         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1280             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1281             exit(1);
1282         }
1283     }
1284
1285     return ost;
1286 }
1287
1288 /* arg format is "output-stream-index:streamid-value". */
1289 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1290 {
1291     OptionsContext *o = optctx;
1292     int idx;
1293     char *p;
1294     char idx_str[16];
1295
1296     av_strlcpy(idx_str, arg, sizeof(idx_str));
1297     p = strchr(idx_str, ':');
1298     if (!p) {
1299         av_log(NULL, AV_LOG_FATAL,
1300                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1301                arg, opt);
1302         exit(1);
1303     }
1304     *p++ = '\0';
1305     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1306     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1307     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1308     return 0;
1309 }
1310
1311 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1312 {
1313     AVFormatContext *is = ifile->ctx;
1314     AVFormatContext *os = ofile->ctx;
1315     AVChapter **tmp;
1316     int i;
1317
1318     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1319     if (!tmp)
1320         return AVERROR(ENOMEM);
1321     os->chapters = tmp;
1322
1323     for (i = 0; i < is->nb_chapters; i++) {
1324         AVChapter *in_ch = is->chapters[i], *out_ch;
1325         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1326                                        AV_TIME_BASE_Q, in_ch->time_base);
1327         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1328                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1329
1330
1331         if (in_ch->end < ts_off)
1332             continue;
1333         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1334             break;
1335
1336         out_ch = av_mallocz(sizeof(AVChapter));
1337         if (!out_ch)
1338             return AVERROR(ENOMEM);
1339
1340         out_ch->id        = in_ch->id;
1341         out_ch->time_base = in_ch->time_base;
1342         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1343         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1344
1345         if (copy_metadata)
1346             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1347
1348         os->chapters[os->nb_chapters++] = out_ch;
1349     }
1350     return 0;
1351 }
1352
1353 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1354 {
1355     int i, err;
1356     AVFormatContext *ic = avformat_alloc_context();
1357
1358     ic->interrupt_callback = int_cb;
1359     err = avformat_open_input(&ic, filename, NULL, NULL);
1360     if (err < 0)
1361         return err;
1362     /* copy stream format */
1363     for(i=0;i<ic->nb_streams;i++) {
1364         AVStream *st;
1365         OutputStream *ost;
1366         AVCodec *codec;
1367         AVCodecContext *avctx;
1368
1369         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1370         ost   = new_output_stream(o, s, codec->type, -1);
1371         st    = ost->st;
1372         avctx = st->codec;
1373         ost->enc = codec;
1374
1375         // FIXME: a more elegant solution is needed
1376         memcpy(st, ic->streams[i], sizeof(AVStream));
1377         st->cur_dts = 0;
1378         st->info = av_malloc(sizeof(*st->info));
1379         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1380         st->codec= avctx;
1381         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1382
1383         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1384             choose_sample_fmt(st, codec);
1385         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1386             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1387     }
1388
1389     /* ffserver seeking with date=... needs a date reference */
1390     err = parse_option(o, "metadata", "creation_time=now", options);
1391
1392     avformat_close_input(&ic);
1393     return err;
1394 }
1395
1396 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1397                                AVFormatContext *oc)
1398 {
1399     OutputStream *ost;
1400
1401     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1402                                   ofilter->out_tmp->pad_idx)) {
1403     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1404     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1405     default:
1406         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1407                "currently.\n");
1408         exit(1);
1409     }
1410
1411     ost->source_index = -1;
1412     ost->filter       = ofilter;
1413
1414     ofilter->ost      = ost;
1415
1416     if (ost->stream_copy) {
1417         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1418                "which is fed from a complex filtergraph. Filtering and streamcopy "
1419                "cannot be used together.\n", ost->file_index, ost->index);
1420         exit(1);
1421     }
1422
1423     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1424         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1425         exit(1);
1426     }
1427     avfilter_inout_free(&ofilter->out_tmp);
1428 }
1429
1430 static int configure_complex_filters(void)
1431 {
1432     int i, ret = 0;
1433
1434     for (i = 0; i < nb_filtergraphs; i++)
1435         if (!filtergraphs[i]->graph &&
1436             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1437             return ret;
1438     return 0;
1439 }
1440
1441 static int open_output_file(OptionsContext *o, const char *filename)
1442 {
1443     AVFormatContext *oc;
1444     int i, j, err;
1445     AVOutputFormat *file_oformat;
1446     OutputStream *ost;
1447     InputStream  *ist;
1448
1449     if (configure_complex_filters() < 0) {
1450         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1451         exit(1);
1452     }
1453
1454     if (!strcmp(filename, "-"))
1455         filename = "pipe:";
1456
1457     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1458     if (!oc) {
1459         print_error(filename, err);
1460         exit(1);
1461     }
1462     file_oformat= oc->oformat;
1463     oc->interrupt_callback = int_cb;
1464
1465     /* create streams for all unlabeled output pads */
1466     for (i = 0; i < nb_filtergraphs; i++) {
1467         FilterGraph *fg = filtergraphs[i];
1468         for (j = 0; j < fg->nb_outputs; j++) {
1469             OutputFilter *ofilter = fg->outputs[j];
1470
1471             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1472                 continue;
1473
1474             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1475                                           ofilter->out_tmp->pad_idx)) {
1476             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1477             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1478             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1479             }
1480             init_output_filter(ofilter, o, oc);
1481         }
1482     }
1483
1484     if (!strcmp(file_oformat->name, "ffm") &&
1485         av_strstart(filename, "http:", NULL)) {
1486         int j;
1487         /* special case for files sent to ffserver: we get the stream
1488            parameters from ffserver */
1489         int err = read_ffserver_streams(o, oc, filename);
1490         if (err < 0) {
1491             print_error(filename, err);
1492             exit(1);
1493         }
1494         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1495             ost = output_streams[j];
1496             for (i = 0; i < nb_input_streams; i++) {
1497                 ist = input_streams[i];
1498                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1499                     ost->sync_ist= ist;
1500                     ost->source_index= i;
1501                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1502                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1503                     ist->discard = 0;
1504                     ist->st->discard = AVDISCARD_NONE;
1505                     break;
1506                 }
1507             }
1508             if(!ost->sync_ist){
1509                 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));
1510                 exit(1);
1511             }
1512         }
1513     } else if (!o->nb_stream_maps) {
1514         char *subtitle_codec_name = NULL;
1515         /* pick the "best" stream of each type */
1516
1517         /* video: highest resolution */
1518         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1519             int area = 0, idx = -1;
1520             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1521             for (i = 0; i < nb_input_streams; i++) {
1522                 int new_area;
1523                 ist = input_streams[i];
1524                 new_area = ist->st->codec->width * ist->st->codec->height;
1525                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1526                     new_area = 1;
1527                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1528                     new_area > area) {
1529                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1530                         continue;
1531                     area = new_area;
1532                     idx = i;
1533                 }
1534             }
1535             if (idx >= 0)
1536                 new_video_stream(o, oc, idx);
1537         }
1538
1539         /* audio: most channels */
1540         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1541             int channels = 0, idx = -1;
1542             for (i = 0; i < nb_input_streams; i++) {
1543                 ist = input_streams[i];
1544                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1545                     ist->st->codec->channels > channels) {
1546                     channels = ist->st->codec->channels;
1547                     idx = i;
1548                 }
1549             }
1550             if (idx >= 0)
1551                 new_audio_stream(o, oc, idx);
1552         }
1553
1554         /* subtitles: pick first */
1555         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1556         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1557             for (i = 0; i < nb_input_streams; i++)
1558                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1559                     new_subtitle_stream(o, oc, i);
1560                     break;
1561                 }
1562         }
1563         /* do something with data? */
1564     } else {
1565         for (i = 0; i < o->nb_stream_maps; i++) {
1566             StreamMap *map = &o->stream_maps[i];
1567             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1568
1569             if (map->disabled)
1570                 continue;
1571
1572             if (map->linklabel) {
1573                 FilterGraph *fg;
1574                 OutputFilter *ofilter = NULL;
1575                 int j, k;
1576
1577                 for (j = 0; j < nb_filtergraphs; j++) {
1578                     fg = filtergraphs[j];
1579                     for (k = 0; k < fg->nb_outputs; k++) {
1580                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1581                         if (out && !strcmp(out->name, map->linklabel)) {
1582                             ofilter = fg->outputs[k];
1583                             goto loop_end;
1584                         }
1585                     }
1586                 }
1587 loop_end:
1588                 if (!ofilter) {
1589                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1590                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1591                     exit(1);
1592                 }
1593                 init_output_filter(ofilter, o, oc);
1594             } else {
1595                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1596                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1597                     continue;
1598                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1599                     continue;
1600                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1601                     continue;
1602                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1603                     continue;
1604
1605                 switch (ist->st->codec->codec_type) {
1606                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1607                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1608                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1609                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1610                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1611                 default:
1612                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1613                            map->file_index, map->stream_index);
1614                     exit(1);
1615                 }
1616             }
1617         }
1618     }
1619
1620     /* handle attached files */
1621     for (i = 0; i < o->nb_attachments; i++) {
1622         AVIOContext *pb;
1623         uint8_t *attachment;
1624         const char *p;
1625         int64_t len;
1626
1627         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1628             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1629                    o->attachments[i]);
1630             exit(1);
1631         }
1632         if ((len = avio_size(pb)) <= 0) {
1633             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1634                    o->attachments[i]);
1635             exit(1);
1636         }
1637         if (!(attachment = av_malloc(len))) {
1638             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1639                    o->attachments[i]);
1640             exit(1);
1641         }
1642         avio_read(pb, attachment, len);
1643
1644         ost = new_attachment_stream(o, oc, -1);
1645         ost->stream_copy               = 0;
1646         ost->attachment_filename       = o->attachments[i];
1647         ost->finished                  = 1;
1648         ost->st->codec->extradata      = attachment;
1649         ost->st->codec->extradata_size = len;
1650
1651         p = strrchr(o->attachments[i], '/');
1652         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1653         avio_close(pb);
1654     }
1655
1656     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1657         AVDictionaryEntry *e;
1658         ost = output_streams[i];
1659
1660         if ((ost->stream_copy || ost->attachment_filename)
1661             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1662             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1663             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1664                 exit(1);
1665     }
1666
1667     GROW_ARRAY(output_files, nb_output_files);
1668     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1669         exit(1);
1670
1671     output_files[nb_output_files - 1]->ctx            = oc;
1672     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1673     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1674     if (o->recording_time != INT64_MAX)
1675         oc->duration = o->recording_time;
1676     output_files[nb_output_files - 1]->start_time     = o->start_time;
1677     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1678     output_files[nb_output_files - 1]->shortest       = o->shortest;
1679     av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1680
1681     /* check filename in case of an image number is expected */
1682     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1683         if (!av_filename_number_test(oc->filename)) {
1684             print_error(oc->filename, AVERROR(EINVAL));
1685             exit(1);
1686         }
1687     }
1688
1689     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1690         /* test if it already exists to avoid losing precious files */
1691         assert_file_overwrite(filename);
1692
1693         /* open the file */
1694         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1695                               &oc->interrupt_callback,
1696                               &output_files[nb_output_files - 1]->opts)) < 0) {
1697             print_error(filename, err);
1698             exit(1);
1699         }
1700     }
1701
1702     if (o->mux_preload) {
1703         uint8_t buf[64];
1704         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1705         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1706     }
1707     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1708
1709     /* copy metadata */
1710     for (i = 0; i < o->nb_metadata_map; i++) {
1711         char *p;
1712         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1713
1714         if (in_file_index >= nb_input_files) {
1715             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1716             exit(1);
1717         }
1718         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1719                       in_file_index >= 0 ?
1720                       input_files[in_file_index]->ctx : NULL, o);
1721     }
1722
1723     /* copy chapters */
1724     if (o->chapters_input_file >= nb_input_files) {
1725         if (o->chapters_input_file == INT_MAX) {
1726             /* copy chapters from the first input file that has them*/
1727             o->chapters_input_file = -1;
1728             for (i = 0; i < nb_input_files; i++)
1729                 if (input_files[i]->ctx->nb_chapters) {
1730                     o->chapters_input_file = i;
1731                     break;
1732                 }
1733         } else {
1734             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1735                    o->chapters_input_file);
1736             exit(1);
1737         }
1738     }
1739     if (o->chapters_input_file >= 0)
1740         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1741                       !o->metadata_chapters_manual);
1742
1743     /* copy global metadata by default */
1744     if (!o->metadata_global_manual && nb_input_files){
1745         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1746                      AV_DICT_DONT_OVERWRITE);
1747         if(o->recording_time != INT64_MAX)
1748             av_dict_set(&oc->metadata, "duration", NULL, 0);
1749         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1750     }
1751     if (!o->metadata_streams_manual)
1752         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1753             InputStream *ist;
1754             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1755                 continue;
1756             ist = input_streams[output_streams[i]->source_index];
1757             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1758         }
1759
1760     /* process manually set metadata */
1761     for (i = 0; i < o->nb_metadata; i++) {
1762         AVDictionary **m;
1763         char type, *val;
1764         const char *stream_spec;
1765         int index = 0, j, ret = 0;
1766
1767         val = strchr(o->metadata[i].u.str, '=');
1768         if (!val) {
1769             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1770                    o->metadata[i].u.str);
1771             exit(1);
1772         }
1773         *val++ = 0;
1774
1775         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1776         if (type == 's') {
1777             for (j = 0; j < oc->nb_streams; j++) {
1778                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1779                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1780                 } else if (ret < 0)
1781                     exit(1);
1782             }
1783         }
1784         else {
1785             switch (type) {
1786             case 'g':
1787                 m = &oc->metadata;
1788                 break;
1789             case 'c':
1790                 if (index < 0 || index >= oc->nb_chapters) {
1791                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1792                     exit(1);
1793                 }
1794                 m = &oc->chapters[index]->metadata;
1795                 break;
1796             default:
1797                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1798                 exit(1);
1799             }
1800             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1801         }
1802     }
1803
1804     return 0;
1805 }
1806
1807 static int opt_target(void *optctx, const char *opt, const char *arg)
1808 {
1809     OptionsContext *o = optctx;
1810     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1811     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1812
1813     if (!strncmp(arg, "pal-", 4)) {
1814         norm = PAL;
1815         arg += 4;
1816     } else if (!strncmp(arg, "ntsc-", 5)) {
1817         norm = NTSC;
1818         arg += 5;
1819     } else if (!strncmp(arg, "film-", 5)) {
1820         norm = FILM;
1821         arg += 5;
1822     } else {
1823         /* Try to determine PAL/NTSC by peeking in the input files */
1824         if (nb_input_files) {
1825             int i, j, fr;
1826             for (j = 0; j < nb_input_files; j++) {
1827                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1828                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1829                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1830                         continue;
1831                     fr = c->time_base.den * 1000 / c->time_base.num;
1832                     if (fr == 25000) {
1833                         norm = PAL;
1834                         break;
1835                     } else if ((fr == 29970) || (fr == 23976)) {
1836                         norm = NTSC;
1837                         break;
1838                     }
1839                 }
1840                 if (norm != UNKNOWN)
1841                     break;
1842             }
1843         }
1844         if (norm != UNKNOWN)
1845             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1846     }
1847
1848     if (norm == UNKNOWN) {
1849         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1850         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1851         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1852         exit(1);
1853     }
1854
1855     if (!strcmp(arg, "vcd")) {
1856         opt_video_codec(o, "c:v", "mpeg1video");
1857         opt_audio_codec(o, "c:a", "mp2");
1858         parse_option(o, "f", "vcd", options);
1859         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1860
1861         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1862         parse_option(o, "r", frame_rates[norm], options);
1863         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1864
1865         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1866         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1867         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1868         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1869
1870         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1871         parse_option(o, "ar", "44100", options);
1872         parse_option(o, "ac", "2", options);
1873
1874         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1875         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1876
1877         /* We have to offset the PTS, so that it is consistent with the SCR.
1878            SCR starts at 36000, but the first two packs contain only padding
1879            and the first pack from the other stream, respectively, may also have
1880            been written before.
1881            So the real data starts at SCR 36000+3*1200. */
1882         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1883     } else if (!strcmp(arg, "svcd")) {
1884
1885         opt_video_codec(o, "c:v", "mpeg2video");
1886         opt_audio_codec(o, "c:a", "mp2");
1887         parse_option(o, "f", "svcd", options);
1888
1889         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1890         parse_option(o, "r", frame_rates[norm], options);
1891         parse_option(o, "pix_fmt", "yuv420p", options);
1892         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1893
1894         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1895         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1896         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1897         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1898         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1899
1900         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1901         parse_option(o, "ar", "44100", options);
1902
1903         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1904
1905     } else if (!strcmp(arg, "dvd")) {
1906
1907         opt_video_codec(o, "c:v", "mpeg2video");
1908         opt_audio_codec(o, "c:a", "ac3");
1909         parse_option(o, "f", "dvd", options);
1910
1911         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1912         parse_option(o, "r", frame_rates[norm], options);
1913         parse_option(o, "pix_fmt", "yuv420p", options);
1914         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1915
1916         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1917         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1918         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1919         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1920
1921         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.
1922         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1923
1924         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1925         parse_option(o, "ar", "48000", options);
1926
1927     } else if (!strncmp(arg, "dv", 2)) {
1928
1929         parse_option(o, "f", "dv", options);
1930
1931         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1932         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1933                           norm == PAL ? "yuv420p" : "yuv411p", options);
1934         parse_option(o, "r", frame_rates[norm], options);
1935
1936         parse_option(o, "ar", "48000", options);
1937         parse_option(o, "ac", "2", options);
1938
1939     } else {
1940         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1941         return AVERROR(EINVAL);
1942     }
1943     return 0;
1944 }
1945
1946 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1947 {
1948     av_free (vstats_filename);
1949     vstats_filename = av_strdup (arg);
1950     return 0;
1951 }
1952
1953 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1954 {
1955     char filename[40];
1956     time_t today2 = time(NULL);
1957     struct tm *today = localtime(&today2);
1958
1959     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1960              today->tm_sec);
1961     return opt_vstats_file(NULL, opt, filename);
1962 }
1963
1964 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1965 {
1966     OptionsContext *o = optctx;
1967     return parse_option(o, "frames:v", arg, options);
1968 }
1969
1970 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1971 {
1972     OptionsContext *o = optctx;
1973     return parse_option(o, "frames:a", arg, options);
1974 }
1975
1976 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1977 {
1978     OptionsContext *o = optctx;
1979     return parse_option(o, "frames:d", arg, options);
1980 }
1981
1982 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1983 {
1984     int ret;
1985     AVDictionary *cbak = codec_opts;
1986     AVDictionary *fbak = format_opts;
1987     codec_opts = NULL;
1988     format_opts = NULL;
1989
1990     ret = opt_default(NULL, opt, arg);
1991
1992     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1993     av_dict_copy(&o->g->format_opts, format_opts, 0);
1994     av_dict_free(&codec_opts);
1995     av_dict_free(&format_opts);
1996     codec_opts = cbak;
1997     format_opts = fbak;
1998
1999     return ret;
2000 }
2001
2002 static int opt_preset(void *optctx, const char *opt, const char *arg)
2003 {
2004     OptionsContext *o = optctx;
2005     FILE *f=NULL;
2006     char filename[1000], line[1000], tmp_line[1000];
2007     const char *codec_name = NULL;
2008
2009     tmp_line[0] = *opt;
2010     tmp_line[1] = 0;
2011     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2012
2013     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2014         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2015             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2016         }else
2017             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2018         exit(1);
2019     }
2020
2021     while (fgets(line, sizeof(line), f)) {
2022         char *key = tmp_line, *value, *endptr;
2023
2024         if (strcspn(line, "#\n\r") == 0)
2025             continue;
2026         strcpy(tmp_line, line);
2027         if (!av_strtok(key,   "=",    &value) ||
2028             !av_strtok(value, "\r\n", &endptr)) {
2029             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2030             exit(1);
2031         }
2032         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2033
2034         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2035         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2036         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2037         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2038         else if (opt_default_new(o, key, value) < 0) {
2039             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2040                    filename, line, key, value);
2041             exit(1);
2042         }
2043     }
2044
2045     fclose(f);
2046
2047     return 0;
2048 }
2049
2050 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2051 {
2052     OptionsContext *o = optctx;
2053     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2054     int ret = parse_option(o, s, arg, options);
2055     av_free(s);
2056     return ret;
2057 }
2058
2059 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2060 {
2061     OptionsContext *o = optctx;
2062     if(!strcmp(opt, "b")){
2063         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2064         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2065         return 0;
2066     }
2067     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2068     return 0;
2069 }
2070
2071 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2072 {
2073     OptionsContext *o = optctx;
2074     char *s;
2075     int ret;
2076     if(!strcmp(opt, "qscale")){
2077         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2078         return parse_option(o, "q:v", arg, options);
2079     }
2080     s = av_asprintf("q%s", opt + 6);
2081     ret = parse_option(o, s, arg, options);
2082     av_free(s);
2083     return ret;
2084 }
2085
2086 static int opt_profile(void *optctx, const char *opt, const char *arg)
2087 {
2088     OptionsContext *o = optctx;
2089     if(!strcmp(opt, "profile")){
2090         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2091         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2092         return 0;
2093     }
2094     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2095     return 0;
2096 }
2097
2098 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2099 {
2100     OptionsContext *o = optctx;
2101     return parse_option(o, "filter:v", arg, options);
2102 }
2103
2104 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2105 {
2106     OptionsContext *o = optctx;
2107     return parse_option(o, "filter:a", arg, options);
2108 }
2109
2110 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2111 {
2112     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2113     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2114     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2115     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2116
2117     if (video_sync_method == VSYNC_AUTO)
2118         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2119     return 0;
2120 }
2121
2122 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2123 {
2124     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2125     do_deinterlace = 1;
2126     return 0;
2127 }
2128
2129 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2130 {
2131     OptionsContext *o = optctx;
2132     char *tcr = av_asprintf("timecode=%s", arg);
2133     int ret = parse_option(o, "metadata:g", tcr, options);
2134     if (ret >= 0)
2135         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2136     av_free(tcr);
2137     return 0;
2138 }
2139
2140 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2141 {
2142     OptionsContext *o = optctx;
2143     char layout_str[32];
2144     char *stream_str;
2145     char *ac_str;
2146     int ret, channels, ac_str_size;
2147     uint64_t layout;
2148
2149     layout = av_get_channel_layout(arg);
2150     if (!layout) {
2151         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2152         return AVERROR(EINVAL);
2153     }
2154     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2155     ret = opt_default(NULL, opt, layout_str);
2156     if (ret < 0)
2157         return ret;
2158
2159     /* set 'ac' option based on channel layout */
2160     channels = av_get_channel_layout_nb_channels(layout);
2161     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2162     stream_str = strchr(opt, ':');
2163     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2164     ac_str = av_mallocz(ac_str_size);
2165     if (!ac_str)
2166         return AVERROR(ENOMEM);
2167     av_strlcpy(ac_str, "ac", 3);
2168     if (stream_str)
2169         av_strlcat(ac_str, stream_str, ac_str_size);
2170     ret = parse_option(o, ac_str, layout_str, options);
2171     av_free(ac_str);
2172
2173     return ret;
2174 }
2175
2176 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2177 {
2178     OptionsContext *o = optctx;
2179     return parse_option(o, "q:a", arg, options);
2180 }
2181
2182 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2183 {
2184     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2185     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2186         return AVERROR(ENOMEM);
2187     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2188     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2189     return 0;
2190 }
2191
2192 void show_help_default(const char *opt, const char *arg)
2193 {
2194     /* per-file options have at least one of those set */
2195     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2196     int show_advanced = 0, show_avoptions = 0;
2197
2198     if (opt && *opt) {
2199         if (!strcmp(opt, "long"))
2200             show_advanced = 1;
2201         else if (!strcmp(opt, "full"))
2202             show_advanced = show_avoptions = 1;
2203         else
2204             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2205     }
2206
2207     show_usage();
2208
2209     printf("Getting help:\n"
2210            "    -h      -- print basic options\n"
2211            "    -h long -- print more options\n"
2212            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2213            "    See man %s for detailed description of the options.\n"
2214            "\n", program_name);
2215
2216     show_help_options(options, "Print help / information / capabilities:",
2217                       OPT_EXIT, 0, 0);
2218
2219     show_help_options(options, "Global options (affect whole program "
2220                       "instead of just one file:",
2221                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2222     if (show_advanced)
2223         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2224                           per_file | OPT_EXIT, 0);
2225
2226     show_help_options(options, "Per-file main options:", 0,
2227                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2228                       OPT_EXIT, per_file);
2229     if (show_advanced)
2230         show_help_options(options, "Advanced per-file options:",
2231                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2232
2233     show_help_options(options, "Video options:",
2234                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2235     if (show_advanced)
2236         show_help_options(options, "Advanced Video options:",
2237                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2238
2239     show_help_options(options, "Audio options:",
2240                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2241     if (show_advanced)
2242         show_help_options(options, "Advanced Audio options:",
2243                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2244     show_help_options(options, "Subtitle options:",
2245                       OPT_SUBTITLE, 0, 0);
2246     printf("\n");
2247
2248     if (show_avoptions) {
2249         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2250         show_help_children(avcodec_get_class(), flags);
2251         show_help_children(avformat_get_class(), flags);
2252         show_help_children(sws_get_class(), flags);
2253         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2254         show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2255     }
2256 }
2257
2258 void show_usage(void)
2259 {
2260     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2261     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2262     av_log(NULL, AV_LOG_INFO, "\n");
2263 }
2264
2265 enum OptGroup {
2266     GROUP_OUTFILE,
2267     GROUP_INFILE,
2268 };
2269
2270 static const OptionGroupDef groups[] = {
2271     [GROUP_OUTFILE] = { "output file",  NULL },
2272     [GROUP_INFILE]  = { "input file",   "i"  },
2273 };
2274
2275 static int open_files(OptionGroupList *l, const char *inout,
2276                       int (*open_file)(OptionsContext*, const char*))
2277 {
2278     int i, ret;
2279
2280     for (i = 0; i < l->nb_groups; i++) {
2281         OptionGroup *g = &l->groups[i];
2282         OptionsContext o;
2283
2284         init_options(&o, !strcmp(inout, "input"));
2285         o.g = g;
2286
2287         ret = parse_optgroup(&o, g);
2288         if (ret < 0) {
2289             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2290                    "%s.\n", inout, g->arg);
2291             return ret;
2292         }
2293
2294         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2295         ret = open_file(&o, g->arg);
2296         uninit_options(&o, !strcmp(inout, "input"));
2297         if (ret < 0) {
2298             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2299                    inout, g->arg);
2300             return ret;
2301         }
2302         av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
2303     }
2304
2305     return 0;
2306 }
2307
2308 int ffmpeg_parse_options(int argc, char **argv)
2309 {
2310     OptionParseContext octx;
2311     uint8_t error[128];
2312     int ret;
2313
2314     memset(&octx, 0, sizeof(octx));
2315
2316     /* split the commandline into an internal representation */
2317     ret = split_commandline(&octx, argc, argv, options, groups,
2318                             FF_ARRAY_ELEMS(groups));
2319     if (ret < 0) {
2320         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2321         goto fail;
2322     }
2323
2324     /* apply global options */
2325     ret = parse_optgroup(NULL, &octx.global_opts);
2326     if (ret < 0) {
2327         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2328         goto fail;
2329     }
2330
2331     /* open input files */
2332     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2333     if (ret < 0) {
2334         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2335         goto fail;
2336     }
2337
2338     /* open output files */
2339     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2340     if (ret < 0) {
2341         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2342         goto fail;
2343     }
2344
2345 fail:
2346     uninit_parse_context(&octx);
2347     if (ret < 0) {
2348         av_strerror(ret, error, sizeof(error));
2349         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2350     }
2351     return ret;
2352 }
2353
2354 static int opt_progress(void *optctx, const char *opt, const char *arg)
2355 {
2356     AVIOContext *avio = NULL;
2357     int ret;
2358
2359     if (!strcmp(arg, "-"))
2360         arg = "pipe:";
2361     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2362     if (ret < 0) {
2363         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2364                arg, av_err2str(ret));
2365         return ret;
2366     }
2367     progress_avio = avio;
2368     return 0;
2369 }
2370
2371 #define OFFSET(x) offsetof(OptionsContext, x)
2372 const OptionDef options[] = {
2373     /* main options */
2374 #include "cmdutils_common_opts.h"
2375     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
2376         "force format", "fmt" },
2377     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2378         "overwrite output files" },
2379     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2380         "do not overwrite output files" },
2381     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2382         "codec name", "codec" },
2383     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2384         "codec name", "codec" },
2385     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
2386         "preset name", "preset" },
2387     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map },
2388         "set input stream mapping",
2389         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2390     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map_channel },
2391         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2392     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
2393         "set metadata information of outfile from infile",
2394         "outfile[,metadata]:infile[,metadata]" },
2395     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2396         "set chapters mapping", "input_file_index" },
2397     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
2398         "record or transcode \"duration\" seconds of audio/video",
2399         "duration" },
2400     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
2401         "set the limit file size in bytes", "limit_size" },
2402     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
2403         "set the start time offset", "time_off" },
2404     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2405         "set the input ts offset", "time_off" },
2406     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2407         "set the input ts scale", "scale" },
2408     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2409         "set the recording timestamp ('now' to set the current time)", "time" },
2410     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
2411         "add metadata", "string=string" },
2412     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_data_frames },
2413         "set the number of data frames to record", "number" },
2414     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2415         "add timings for benchmarking" },
2416     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2417       "add timings for each task" },
2418     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2419       "write program-readable progress information", "url" },
2420     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2421       "enable or disable interaction on standard input" },
2422     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2423         "set max runtime in seconds", "limit" },
2424     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2425         "dump each input packet" },
2426     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2427         "when dumping packets, also dump the payload" },
2428     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
2429         "read input at native frame rate", "" },
2430     { "target",         HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_target },
2431         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2432         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2433     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2434         "video sync method", "" },
2435     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2436         "audio sync method", "" },
2437     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2438         "audio drift threshold", "threshold" },
2439     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2440         "copy timestamps" },
2441     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2442         "copy input stream time base when stream copying", "mode" },
2443     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
2444         "finish encoding within shortest input" },
2445     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2446         "timestamp discontinuity delta threshold", "threshold" },
2447     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2448         "timestamp error delta threshold", "threshold" },
2449     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2450         "exit on error", "error" },
2451     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
2452         "copy initial non-keyframes" },
2453     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC,   { .off = OFFSET(copy_prior_start) },
2454         "copy or discard frames before start time" },
2455     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
2456         "set the number of frames to record", "number" },
2457     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2458         "force codec tag/fourcc", "fourcc/tag" },
2459     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2460         "use fixed quality scale (VBR)", "q" },
2461     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_qscale },
2462         "use fixed quality scale (VBR)", "q" },
2463     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_profile },
2464         "set profile", "profile" },
2465     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
2466         "set stream filterchain", "filter_list" },
2467     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC,                { .off = OFFSET(reinit_filters) },
2468         "reinit filtergraph on input parameter changes", "" },
2469     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2470         "create a complex filtergraph", "graph_description" },
2471     { "stats",          OPT_BOOL,                                    { &print_stats },
2472         "print progress report during encoding", },
2473     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_attach },
2474         "add an attachment to the output file", "filename" },
2475     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2476         "extract an attachment into a file", "filename" },
2477     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2478         "print timestamp debugging info" },
2479
2480     /* video options */
2481     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_frames },
2482         "set the number of video frames to record", "number" },
2483     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
2484         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2485     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2486         "set frame size (WxH or abbreviation)", "size" },
2487     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
2488         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2489     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2490         "set pixel format", "format" },
2491     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2492         "set the number of bits per raw sample", "number" },
2493     { "croptop",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2494         "Removed, use the crop filter instead", "size" },
2495     { "cropbottom",   OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2496         "Removed, use the crop filter instead", "size" },
2497     { "cropleft",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2498         "Removed, use the crop filter instead", "size" },
2499     { "cropright",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2500         "Removed, use the crop filter instead", "size" },
2501     { "padtop",       OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2502         "Removed, use the pad filter instead", "size" },
2503     { "padbottom",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2504         "Removed, use the pad filter instead", "size" },
2505     { "padleft",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2506         "Removed, use the pad filter instead", "size" },
2507     { "padright",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2508         "Removed, use the pad filter instead", "size" },
2509     { "padcolor",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2510         "Removed, use the pad filter instead", "color" },
2511     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2512         "deprecated use -g 1" },
2513     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
2514         "disable video" },
2515     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2516         "discard threshold", "n" },
2517     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2518         "rate control override for specific intervals", "override" },
2519     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_codec },
2520         "force video codec ('copy' to copy stream)", "codec" },
2521     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2522         "Removed" },
2523     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2524         "Removed" },
2525     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_timecode },
2526         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2527     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
2528         "select the pass number (1 to 3)", "n" },
2529     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
2530         "select two pass log file name prefix", "prefix" },
2531     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2532         "this option is deprecated, use the yadif filter instead" },
2533     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2534         "calculate PSNR of compressed frames" },
2535     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2536         "dump video coding statistics to file" },
2537     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2538         "dump video coding statistics to file", "file" },
2539     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
2540         "video filters", "filter list" },
2541     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2542         "specify intra matrix coeffs", "matrix" },
2543     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2544         "specify inter matrix coeffs", "matrix" },
2545     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
2546         "top=1/bottom=0/auto=-1 field first", "" },
2547     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2548         "intra_dc_precision", "precision" },
2549     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_old2new },
2550         "force video tag/fourcc", "fourcc/tag" },
2551     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2552         "show QP histogram" },
2553     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
2554         "force the selected framerate, disable the best supported framerate selection" },
2555     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
2556         "set the value of an outfile streamid", "streamIndex:value" },
2557     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2558         { .off = OFFSET(forced_key_frames) },
2559         "force key frames at specified timestamps", "timestamps" },
2560     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_bitrate },
2561         "video bitrate (please use -b:v)", "bitrate" },
2562
2563     /* audio options */
2564     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
2565         "set the number of audio frames to record", "number" },
2566     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
2567         "set audio quality (codec-specific)", "quality", },
2568     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2569         "set audio sampling rate (in Hz)", "rate" },
2570     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2571         "set number of audio channels", "channels" },
2572     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2573         "disable audio" },
2574     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
2575         "force audio codec ('copy' to copy stream)", "codec" },
2576     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_old2new },
2577         "force audio tag/fourcc", "fourcc/tag" },
2578     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2579         "change audio volume (256=normal)" , "volume" },
2580     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2581         "set sample format", "format" },
2582     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
2583         "set channel layout", "layout" },
2584     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
2585         "audio filters", "filter list" },
2586
2587     /* subtitle options */
2588     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2589         "disable subtitle" },
2590     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2591         "force subtitle codec ('copy' to copy stream)", "codec" },
2592     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_old2new }
2593         , "force subtitle tag/fourcc", "fourcc/tag" },
2594     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2595         "fix subtitles duration" },
2596
2597     /* grab options */
2598     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2599         "deprecated, use -channel", "channel" },
2600     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2601         "deprecated, use -standard", "standard" },
2602     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2603
2604     /* muxer options */
2605     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2606         "set the maximum demux-decode delay", "seconds" },
2607     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2608         "set the initial demux-decode delay", "seconds" },
2609
2610     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2611         "A comma-separated list of bitstream filters", "bitstream_filters" },
2612     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2613         "deprecated", "audio bitstream_filters" },
2614     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2615         "deprecated", "video bitstream_filters" },
2616
2617     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2618         "set the audio options to the indicated preset", "preset" },
2619     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2620         "set the video options to the indicated preset", "preset" },
2621     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2622         "set the subtitle options to the indicated preset", "preset" },
2623     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE,                { .func_arg = opt_preset },
2624         "set options from indicated preset file", "filename" },
2625     /* data codec support */
2626     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2627         "force data codec ('copy' to copy stream)", "codec" },
2628     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2629         "disable data" },
2630
2631     { NULL, },
2632 };