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