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