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