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