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