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     char *filter = NULL, *filter_script = NULL;
1155
1156     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1157     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1158
1159     if (filter_script && filter) {
1160         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1161                "output stream #%d:%d.\n", nb_output_files, st->index);
1162         exit_program(1);
1163     }
1164
1165     if (filter_script)
1166         return read_file(filter_script);
1167     else if (filter)
1168         return av_strdup(filter);
1169
1170     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1171                      "null" : "anull");
1172 }
1173
1174 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1175 {
1176     AVStream *st;
1177     OutputStream *ost;
1178     AVCodecContext *video_enc;
1179     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1180
1181     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1182     st  = ost->st;
1183     video_enc = st->codec;
1184
1185     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1186     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1187         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1188         exit_program(1);
1189     }
1190
1191     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1192     if (frame_aspect_ratio) {
1193         AVRational q;
1194         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1195             q.num <= 0 || q.den <= 0) {
1196             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1197             exit_program(1);
1198         }
1199         ost->frame_aspect_ratio = q;
1200     }
1201
1202     if (!ost->stream_copy) {
1203         const char *p = NULL;
1204         char *frame_size = NULL;
1205         char *frame_pix_fmt = NULL;
1206         char *intra_matrix = NULL, *inter_matrix = NULL;
1207         int do_pass = 0;
1208         int i;
1209
1210         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1211         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1212             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1213             exit_program(1);
1214         }
1215
1216         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1217         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1218         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1219             ost->keep_pix_fmt = 1;
1220             if (!*++frame_pix_fmt)
1221                 frame_pix_fmt = NULL;
1222         }
1223         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1224             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1225             exit_program(1);
1226         }
1227         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1228
1229         if (intra_only)
1230             video_enc->gop_size = 0;
1231         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1232         if (intra_matrix) {
1233             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1234                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1235                 exit_program(1);
1236             }
1237             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1238         }
1239         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1240         if (inter_matrix) {
1241             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1242                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1243                 exit_program(1);
1244             }
1245             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1246         }
1247
1248         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1249         for (i = 0; p; i++) {
1250             int start, end, q;
1251             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1252             if (e != 3) {
1253                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1254                 exit_program(1);
1255             }
1256             /* FIXME realloc failure */
1257             video_enc->rc_override =
1258                 av_realloc(video_enc->rc_override,
1259                            sizeof(RcOverride) * (i + 1));
1260             video_enc->rc_override[i].start_frame = start;
1261             video_enc->rc_override[i].end_frame   = end;
1262             if (q > 0) {
1263                 video_enc->rc_override[i].qscale         = q;
1264                 video_enc->rc_override[i].quality_factor = 1.0;
1265             }
1266             else {
1267                 video_enc->rc_override[i].qscale         = 0;
1268                 video_enc->rc_override[i].quality_factor = -q/100.0;
1269             }
1270             p = strchr(p, '/');
1271             if (p) p++;
1272         }
1273         video_enc->rc_override_count = i;
1274         video_enc->intra_dc_precision = intra_dc_precision - 8;
1275
1276         if (do_psnr)
1277             video_enc->flags|= CODEC_FLAG_PSNR;
1278
1279         /* two pass mode */
1280         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1281         if (do_pass) {
1282             if (do_pass & 1) {
1283                 video_enc->flags |= CODEC_FLAG_PASS1;
1284                 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1285             }
1286             if (do_pass & 2) {
1287                 video_enc->flags |= CODEC_FLAG_PASS2;
1288                 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1289             }
1290         }
1291
1292         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1293         if (ost->logfile_prefix &&
1294             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1295             exit_program(1);
1296
1297         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1298         if (ost->forced_keyframes)
1299             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1300
1301         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1302
1303         ost->top_field_first = -1;
1304         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1305
1306
1307         ost->avfilter = get_ost_filters(o, oc, ost);
1308         if (!ost->avfilter)
1309             exit_program(1);
1310     } else {
1311         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1312     }
1313
1314     return ost;
1315 }
1316
1317 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1318 {
1319     int n;
1320     AVStream *st;
1321     OutputStream *ost;
1322     AVCodecContext *audio_enc;
1323
1324     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1325     st  = ost->st;
1326
1327     audio_enc = st->codec;
1328     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1329
1330     if (!ost->stream_copy) {
1331         char *sample_fmt = NULL;
1332
1333         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1334
1335         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1336         if (sample_fmt &&
1337             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1338             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1339             exit_program(1);
1340         }
1341
1342         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1343
1344         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1345         ost->apad = av_strdup(ost->apad);
1346
1347         ost->avfilter = get_ost_filters(o, oc, ost);
1348         if (!ost->avfilter)
1349             exit_program(1);
1350
1351         /* check for channel mapping for this audio stream */
1352         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1353             AudioChannelMap *map = &o->audio_channel_maps[n];
1354             InputStream *ist = input_streams[ost->source_index];
1355             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1356                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1357                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1358                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1359                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1360                 else
1361                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1362                            ost->file_index, ost->st->index);
1363             }
1364         }
1365     }
1366
1367     return ost;
1368 }
1369
1370 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1371 {
1372     OutputStream *ost;
1373
1374     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1375     if (!ost->stream_copy) {
1376         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1377         exit_program(1);
1378     }
1379
1380     return ost;
1381 }
1382
1383 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1384 {
1385     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1386     ost->stream_copy = 1;
1387     ost->finished    = 1;
1388     return ost;
1389 }
1390
1391 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1392 {
1393     AVStream *st;
1394     OutputStream *ost;
1395     AVCodecContext *subtitle_enc;
1396
1397     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1398     st  = ost->st;
1399     subtitle_enc = st->codec;
1400
1401     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1402
1403     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1404
1405     if (!ost->stream_copy) {
1406         char *frame_size = NULL;
1407
1408         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1409         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1410             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1411             exit_program(1);
1412         }
1413     }
1414
1415     return ost;
1416 }
1417
1418 /* arg format is "output-stream-index:streamid-value". */
1419 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1420 {
1421     OptionsContext *o = optctx;
1422     int idx;
1423     char *p;
1424     char idx_str[16];
1425
1426     av_strlcpy(idx_str, arg, sizeof(idx_str));
1427     p = strchr(idx_str, ':');
1428     if (!p) {
1429         av_log(NULL, AV_LOG_FATAL,
1430                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1431                arg, opt);
1432         exit_program(1);
1433     }
1434     *p++ = '\0';
1435     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1436     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1437     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1438     return 0;
1439 }
1440
1441 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1442 {
1443     AVFormatContext *is = ifile->ctx;
1444     AVFormatContext *os = ofile->ctx;
1445     AVChapter **tmp;
1446     int i;
1447
1448     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1449     if (!tmp)
1450         return AVERROR(ENOMEM);
1451     os->chapters = tmp;
1452
1453     for (i = 0; i < is->nb_chapters; i++) {
1454         AVChapter *in_ch = is->chapters[i], *out_ch;
1455         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1456         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1457                                        AV_TIME_BASE_Q, in_ch->time_base);
1458         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1459                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1460
1461
1462         if (in_ch->end < ts_off)
1463             continue;
1464         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1465             break;
1466
1467         out_ch = av_mallocz(sizeof(AVChapter));
1468         if (!out_ch)
1469             return AVERROR(ENOMEM);
1470
1471         out_ch->id        = in_ch->id;
1472         out_ch->time_base = in_ch->time_base;
1473         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1474         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1475
1476         if (copy_metadata)
1477             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1478
1479         os->chapters[os->nb_chapters++] = out_ch;
1480     }
1481     return 0;
1482 }
1483
1484 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1485 {
1486     int i, err;
1487     AVFormatContext *ic = avformat_alloc_context();
1488
1489     ic->interrupt_callback = int_cb;
1490     err = avformat_open_input(&ic, filename, NULL, NULL);
1491     if (err < 0)
1492         return err;
1493     /* copy stream format */
1494     for(i=0;i<ic->nb_streams;i++) {
1495         AVStream *st;
1496         OutputStream *ost;
1497         AVCodec *codec;
1498         AVCodecContext *avctx;
1499
1500         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1501         ost   = new_output_stream(o, s, codec->type, -1);
1502         st    = ost->st;
1503         avctx = st->codec;
1504         ost->enc = codec;
1505
1506         // FIXME: a more elegant solution is needed
1507         memcpy(st, ic->streams[i], sizeof(AVStream));
1508         st->cur_dts = 0;
1509         st->info = av_malloc(sizeof(*st->info));
1510         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1511         st->codec= avctx;
1512         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1513
1514         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1515             choose_sample_fmt(st, codec);
1516         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1517             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1518     }
1519
1520     avformat_close_input(&ic);
1521     return err;
1522 }
1523
1524 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1525                                AVFormatContext *oc)
1526 {
1527     OutputStream *ost;
1528
1529     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1530                                   ofilter->out_tmp->pad_idx)) {
1531     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1532     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1533     default:
1534         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1535                "currently.\n");
1536         exit_program(1);
1537     }
1538
1539     ost->source_index = -1;
1540     ost->filter       = ofilter;
1541
1542     ofilter->ost      = ost;
1543
1544     if (ost->stream_copy) {
1545         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1546                "which is fed from a complex filtergraph. Filtering and streamcopy "
1547                "cannot be used together.\n", ost->file_index, ost->index);
1548         exit_program(1);
1549     }
1550
1551     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1552         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1553         exit_program(1);
1554     }
1555     avfilter_inout_free(&ofilter->out_tmp);
1556 }
1557
1558 static int configure_complex_filters(void)
1559 {
1560     int i, ret = 0;
1561
1562     for (i = 0; i < nb_filtergraphs; i++)
1563         if (!filtergraphs[i]->graph &&
1564             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1565             return ret;
1566     return 0;
1567 }
1568
1569 static int open_output_file(OptionsContext *o, const char *filename)
1570 {
1571     AVFormatContext *oc;
1572     int i, j, err;
1573     AVOutputFormat *file_oformat;
1574     OutputFile *of;
1575     OutputStream *ost;
1576     InputStream  *ist;
1577     AVDictionary *unused_opts = NULL;
1578     AVDictionaryEntry *e = NULL;
1579
1580     if (configure_complex_filters() < 0) {
1581         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1582         exit_program(1);
1583     }
1584
1585     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1586         o->stop_time = INT64_MAX;
1587         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1588     }
1589
1590     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1591         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1592         if (o->stop_time <= start_time) {
1593             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1594             o->stop_time = INT64_MAX;
1595         } else {
1596             o->recording_time = o->stop_time - start_time;
1597         }
1598     }
1599
1600     GROW_ARRAY(output_files, nb_output_files);
1601     of = av_mallocz(sizeof(*of));
1602     if (!of)
1603         exit_program(1);
1604     output_files[nb_output_files - 1] = of;
1605
1606     of->ost_index      = nb_output_streams;
1607     of->recording_time = o->recording_time;
1608     of->start_time     = o->start_time;
1609     of->limit_filesize = o->limit_filesize;
1610     of->shortest       = o->shortest;
1611     av_dict_copy(&of->opts, o->g->format_opts, 0);
1612
1613     if (!strcmp(filename, "-"))
1614         filename = "pipe:";
1615
1616     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1617     if (!oc) {
1618         print_error(filename, err);
1619         exit_program(1);
1620     }
1621
1622     of->ctx = oc;
1623     if (o->recording_time != INT64_MAX)
1624         oc->duration = o->recording_time;
1625
1626     file_oformat= oc->oformat;
1627     oc->interrupt_callback = int_cb;
1628
1629     /* create streams for all unlabeled output pads */
1630     for (i = 0; i < nb_filtergraphs; i++) {
1631         FilterGraph *fg = filtergraphs[i];
1632         for (j = 0; j < fg->nb_outputs; j++) {
1633             OutputFilter *ofilter = fg->outputs[j];
1634
1635             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1636                 continue;
1637
1638             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1639                                           ofilter->out_tmp->pad_idx)) {
1640             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1641             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1642             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1643             }
1644             init_output_filter(ofilter, o, oc);
1645         }
1646     }
1647
1648     /* ffserver seeking with date=... needs a date reference */
1649     if (!strcmp(file_oformat->name, "ffm") &&
1650         av_strstart(filename, "http:", NULL)) {
1651         int err = parse_option(o, "metadata", "creation_time=now", options);
1652         if (err < 0) {
1653             print_error(filename, err);
1654             exit_program(1);
1655         }
1656     }
1657
1658     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1659         av_strstart(filename, "http:", NULL)) {
1660         int j;
1661         /* special case for files sent to ffserver: we get the stream
1662            parameters from ffserver */
1663         int err = read_ffserver_streams(o, oc, filename);
1664         if (err < 0) {
1665             print_error(filename, err);
1666             exit_program(1);
1667         }
1668         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1669             ost = output_streams[j];
1670             for (i = 0; i < nb_input_streams; i++) {
1671                 ist = input_streams[i];
1672                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1673                     ost->sync_ist= ist;
1674                     ost->source_index= i;
1675                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1676                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1677                     ist->discard = 0;
1678                     ist->st->discard = AVDISCARD_NONE;
1679                     break;
1680                 }
1681             }
1682             if(!ost->sync_ist){
1683                 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));
1684                 exit_program(1);
1685             }
1686         }
1687     } else if (!o->nb_stream_maps) {
1688         char *subtitle_codec_name = NULL;
1689         /* pick the "best" stream of each type */
1690
1691         /* video: highest resolution */
1692         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1693             int area = 0, idx = -1;
1694             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1695             for (i = 0; i < nb_input_streams; i++) {
1696                 int new_area;
1697                 ist = input_streams[i];
1698                 new_area = ist->st->codec->width * ist->st->codec->height;
1699                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1700                     new_area = 1;
1701                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1702                     new_area > area) {
1703                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1704                         continue;
1705                     area = new_area;
1706                     idx = i;
1707                 }
1708             }
1709             if (idx >= 0)
1710                 new_video_stream(o, oc, idx);
1711         }
1712
1713         /* audio: most channels */
1714         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1715             int channels = 0, idx = -1;
1716             for (i = 0; i < nb_input_streams; i++) {
1717                 ist = input_streams[i];
1718                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1719                     ist->st->codec->channels > channels) {
1720                     channels = ist->st->codec->channels;
1721                     idx = i;
1722                 }
1723             }
1724             if (idx >= 0)
1725                 new_audio_stream(o, oc, idx);
1726         }
1727
1728         /* subtitles: pick first */
1729         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1730         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1731             for (i = 0; i < nb_input_streams; i++)
1732                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1733                     new_subtitle_stream(o, oc, i);
1734                     break;
1735                 }
1736         }
1737         /* do something with data? */
1738     } else {
1739         for (i = 0; i < o->nb_stream_maps; i++) {
1740             StreamMap *map = &o->stream_maps[i];
1741
1742             if (map->disabled)
1743                 continue;
1744
1745             if (map->linklabel) {
1746                 FilterGraph *fg;
1747                 OutputFilter *ofilter = NULL;
1748                 int j, k;
1749
1750                 for (j = 0; j < nb_filtergraphs; j++) {
1751                     fg = filtergraphs[j];
1752                     for (k = 0; k < fg->nb_outputs; k++) {
1753                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1754                         if (out && !strcmp(out->name, map->linklabel)) {
1755                             ofilter = fg->outputs[k];
1756                             goto loop_end;
1757                         }
1758                     }
1759                 }
1760 loop_end:
1761                 if (!ofilter) {
1762                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1763                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1764                     exit_program(1);
1765                 }
1766                 init_output_filter(ofilter, o, oc);
1767             } else {
1768                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1769
1770                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1771                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1772                     continue;
1773                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1774                     continue;
1775                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1776                     continue;
1777                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1778                     continue;
1779
1780                 switch (ist->st->codec->codec_type) {
1781                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1782                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1783                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1784                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1785                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1786                 default:
1787                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1788                            map->file_index, map->stream_index);
1789                     exit_program(1);
1790                 }
1791             }
1792         }
1793     }
1794
1795     /* handle attached files */
1796     for (i = 0; i < o->nb_attachments; i++) {
1797         AVIOContext *pb;
1798         uint8_t *attachment;
1799         const char *p;
1800         int64_t len;
1801
1802         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1803             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1804                    o->attachments[i]);
1805             exit_program(1);
1806         }
1807         if ((len = avio_size(pb)) <= 0) {
1808             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1809                    o->attachments[i]);
1810             exit_program(1);
1811         }
1812         if (!(attachment = av_malloc(len))) {
1813             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1814                    o->attachments[i]);
1815             exit_program(1);
1816         }
1817         avio_read(pb, attachment, len);
1818
1819         ost = new_attachment_stream(o, oc, -1);
1820         ost->stream_copy               = 0;
1821         ost->attachment_filename       = o->attachments[i];
1822         ost->finished                  = 1;
1823         ost->st->codec->extradata      = attachment;
1824         ost->st->codec->extradata_size = len;
1825
1826         p = strrchr(o->attachments[i], '/');
1827         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1828         avio_close(pb);
1829     }
1830
1831     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1832         AVDictionaryEntry *e;
1833         ost = output_streams[i];
1834
1835         if ((ost->stream_copy || ost->attachment_filename)
1836             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1837             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1838             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1839                 exit_program(1);
1840     }
1841
1842     /* check if all codec options have been used */
1843     unused_opts = strip_specifiers(o->g->codec_opts);
1844     for (i = of->ost_index; i < nb_output_streams; i++) {
1845         e = NULL;
1846         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1847                                 AV_DICT_IGNORE_SUFFIX)))
1848             av_dict_set(&unused_opts, e->key, NULL, 0);
1849     }
1850
1851     e = NULL;
1852     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1853         const AVClass *class = avcodec_get_class();
1854         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1855                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1856         if (!option)
1857             continue;
1858         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1859             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1860                    "output file #%d (%s) is not an encoding option.\n", e->key,
1861                    option->help ? option->help : "", nb_output_files - 1,
1862                    filename);
1863             exit_program(1);
1864         }
1865
1866         // gop_timecode is injected by generic code but not always used
1867         if (!strcmp(e->key, "gop_timecode"))
1868             continue;
1869
1870         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1871                "output file #%d (%s) has not been used for any stream. The most "
1872                "likely reason is either wrong type (e.g. a video option with "
1873                "no video streams) or that it is a private option of some encoder "
1874                "which was not actually used for any stream.\n", e->key,
1875                option->help ? option->help : "", nb_output_files - 1, filename);
1876     }
1877     av_dict_free(&unused_opts);
1878
1879     /* check filename in case of an image number is expected */
1880     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1881         if (!av_filename_number_test(oc->filename)) {
1882             print_error(oc->filename, AVERROR(EINVAL));
1883             exit_program(1);
1884         }
1885     }
1886
1887     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1888         /* test if it already exists to avoid losing precious files */
1889         assert_file_overwrite(filename);
1890
1891         /* open the file */
1892         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1893                               &oc->interrupt_callback,
1894                               &of->opts)) < 0) {
1895             print_error(filename, err);
1896             exit_program(1);
1897         }
1898     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1899         assert_file_overwrite(filename);
1900
1901     if (o->mux_preload) {
1902         uint8_t buf[64];
1903         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1904         av_dict_set(&of->opts, "preload", buf, 0);
1905     }
1906     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1907
1908     /* copy metadata */
1909     for (i = 0; i < o->nb_metadata_map; i++) {
1910         char *p;
1911         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1912
1913         if (in_file_index >= nb_input_files) {
1914             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1915             exit_program(1);
1916         }
1917         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1918                       in_file_index >= 0 ?
1919                       input_files[in_file_index]->ctx : NULL, o);
1920     }
1921
1922     /* copy chapters */
1923     if (o->chapters_input_file >= nb_input_files) {
1924         if (o->chapters_input_file == INT_MAX) {
1925             /* copy chapters from the first input file that has them*/
1926             o->chapters_input_file = -1;
1927             for (i = 0; i < nb_input_files; i++)
1928                 if (input_files[i]->ctx->nb_chapters) {
1929                     o->chapters_input_file = i;
1930                     break;
1931                 }
1932         } else {
1933             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1934                    o->chapters_input_file);
1935             exit_program(1);
1936         }
1937     }
1938     if (o->chapters_input_file >= 0)
1939         copy_chapters(input_files[o->chapters_input_file], of,
1940                       !o->metadata_chapters_manual);
1941
1942     /* copy global metadata by default */
1943     if (!o->metadata_global_manual && nb_input_files){
1944         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1945                      AV_DICT_DONT_OVERWRITE);
1946         if(o->recording_time != INT64_MAX)
1947             av_dict_set(&oc->metadata, "duration", NULL, 0);
1948         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1949     }
1950     if (!o->metadata_streams_manual)
1951         for (i = of->ost_index; i < nb_output_streams; i++) {
1952             InputStream *ist;
1953             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1954                 continue;
1955             ist = input_streams[output_streams[i]->source_index];
1956             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1957         }
1958
1959     /* process manually set metadata */
1960     for (i = 0; i < o->nb_metadata; i++) {
1961         AVDictionary **m;
1962         char type, *val;
1963         const char *stream_spec;
1964         int index = 0, j, ret = 0;
1965
1966         val = strchr(o->metadata[i].u.str, '=');
1967         if (!val) {
1968             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1969                    o->metadata[i].u.str);
1970             exit_program(1);
1971         }
1972         *val++ = 0;
1973
1974         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1975         if (type == 's') {
1976             for (j = 0; j < oc->nb_streams; j++) {
1977                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1978                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1979                 } else if (ret < 0)
1980                     exit_program(1);
1981             }
1982         }
1983         else {
1984             switch (type) {
1985             case 'g':
1986                 m = &oc->metadata;
1987                 break;
1988             case 'c':
1989                 if (index < 0 || index >= oc->nb_chapters) {
1990                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1991                     exit_program(1);
1992                 }
1993                 m = &oc->chapters[index]->metadata;
1994                 break;
1995             default:
1996                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1997                 exit_program(1);
1998             }
1999             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2000         }
2001     }
2002
2003     return 0;
2004 }
2005
2006 static int opt_target(void *optctx, const char *opt, const char *arg)
2007 {
2008     OptionsContext *o = optctx;
2009     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2010     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2011
2012     if (!strncmp(arg, "pal-", 4)) {
2013         norm = PAL;
2014         arg += 4;
2015     } else if (!strncmp(arg, "ntsc-", 5)) {
2016         norm = NTSC;
2017         arg += 5;
2018     } else if (!strncmp(arg, "film-", 5)) {
2019         norm = FILM;
2020         arg += 5;
2021     } else {
2022         /* Try to determine PAL/NTSC by peeking in the input files */
2023         if (nb_input_files) {
2024             int i, j, fr;
2025             for (j = 0; j < nb_input_files; j++) {
2026                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2027                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2028                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2029                         continue;
2030                     fr = c->time_base.den * 1000 / c->time_base.num;
2031                     if (fr == 25000) {
2032                         norm = PAL;
2033                         break;
2034                     } else if ((fr == 29970) || (fr == 23976)) {
2035                         norm = NTSC;
2036                         break;
2037                     }
2038                 }
2039                 if (norm != UNKNOWN)
2040                     break;
2041             }
2042         }
2043         if (norm != UNKNOWN)
2044             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2045     }
2046
2047     if (norm == UNKNOWN) {
2048         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2049         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2050         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2051         exit_program(1);
2052     }
2053
2054     if (!strcmp(arg, "vcd")) {
2055         opt_video_codec(o, "c:v", "mpeg1video");
2056         opt_audio_codec(o, "c:a", "mp2");
2057         parse_option(o, "f", "vcd", options);
2058         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2059
2060         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2061         parse_option(o, "r", frame_rates[norm], options);
2062         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2063
2064         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2065         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2066         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2067         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2068
2069         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2070         parse_option(o, "ar", "44100", options);
2071         parse_option(o, "ac", "2", options);
2072
2073         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2074         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2075
2076         /* We have to offset the PTS, so that it is consistent with the SCR.
2077            SCR starts at 36000, but the first two packs contain only padding
2078            and the first pack from the other stream, respectively, may also have
2079            been written before.
2080            So the real data starts at SCR 36000+3*1200. */
2081         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2082     } else if (!strcmp(arg, "svcd")) {
2083
2084         opt_video_codec(o, "c:v", "mpeg2video");
2085         opt_audio_codec(o, "c:a", "mp2");
2086         parse_option(o, "f", "svcd", options);
2087
2088         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2089         parse_option(o, "r", frame_rates[norm], options);
2090         parse_option(o, "pix_fmt", "yuv420p", options);
2091         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2092
2093         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2094         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2095         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2096         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2097         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2098
2099         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2100         parse_option(o, "ar", "44100", options);
2101
2102         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2103
2104     } else if (!strcmp(arg, "dvd")) {
2105
2106         opt_video_codec(o, "c:v", "mpeg2video");
2107         opt_audio_codec(o, "c:a", "ac3");
2108         parse_option(o, "f", "dvd", options);
2109
2110         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2111         parse_option(o, "r", frame_rates[norm], options);
2112         parse_option(o, "pix_fmt", "yuv420p", options);
2113         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2114
2115         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2116         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2117         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2118         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2119
2120         av_dict_set(&o->g->format_opts, "packetsize", "2048", 0);  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2121         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2122
2123         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2124         parse_option(o, "ar", "48000", options);
2125
2126     } else if (!strncmp(arg, "dv", 2)) {
2127
2128         parse_option(o, "f", "dv", options);
2129
2130         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2131         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2132                           norm == PAL ? "yuv420p" : "yuv411p", options);
2133         parse_option(o, "r", frame_rates[norm], options);
2134
2135         parse_option(o, "ar", "48000", options);
2136         parse_option(o, "ac", "2", options);
2137
2138     } else {
2139         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2140         return AVERROR(EINVAL);
2141     }
2142     return 0;
2143 }
2144
2145 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2146 {
2147     av_free (vstats_filename);
2148     vstats_filename = av_strdup (arg);
2149     return 0;
2150 }
2151
2152 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2153 {
2154     char filename[40];
2155     time_t today2 = time(NULL);
2156     struct tm *today = localtime(&today2);
2157
2158     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2159              today->tm_sec);
2160     return opt_vstats_file(NULL, opt, filename);
2161 }
2162
2163 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2164 {
2165     OptionsContext *o = optctx;
2166     return parse_option(o, "frames:v", arg, options);
2167 }
2168
2169 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2170 {
2171     OptionsContext *o = optctx;
2172     return parse_option(o, "frames:a", arg, options);
2173 }
2174
2175 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2176 {
2177     OptionsContext *o = optctx;
2178     return parse_option(o, "frames:d", arg, options);
2179 }
2180
2181 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2182 {
2183     int ret;
2184     AVDictionary *cbak = codec_opts;
2185     AVDictionary *fbak = format_opts;
2186     codec_opts = NULL;
2187     format_opts = NULL;
2188
2189     ret = opt_default(NULL, opt, arg);
2190
2191     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2192     av_dict_copy(&o->g->format_opts, format_opts, 0);
2193     av_dict_free(&codec_opts);
2194     av_dict_free(&format_opts);
2195     codec_opts = cbak;
2196     format_opts = fbak;
2197
2198     return ret;
2199 }
2200
2201 static int opt_preset(void *optctx, const char *opt, const char *arg)
2202 {
2203     OptionsContext *o = optctx;
2204     FILE *f=NULL;
2205     char filename[1000], line[1000], tmp_line[1000];
2206     const char *codec_name = NULL;
2207
2208     tmp_line[0] = *opt;
2209     tmp_line[1] = 0;
2210     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2211
2212     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2213         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2214             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2215         }else
2216             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2217         exit_program(1);
2218     }
2219
2220     while (fgets(line, sizeof(line), f)) {
2221         char *key = tmp_line, *value, *endptr;
2222
2223         if (strcspn(line, "#\n\r") == 0)
2224             continue;
2225         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2226         if (!av_strtok(key,   "=",    &value) ||
2227             !av_strtok(value, "\r\n", &endptr)) {
2228             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2229             exit_program(1);
2230         }
2231         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2232
2233         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2234         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2235         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2236         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2237         else if (opt_default_new(o, key, value) < 0) {
2238             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2239                    filename, line, key, value);
2240             exit_program(1);
2241         }
2242     }
2243
2244     fclose(f);
2245
2246     return 0;
2247 }
2248
2249 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2250 {
2251     OptionsContext *o = optctx;
2252     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2253     int ret = parse_option(o, s, arg, options);
2254     av_free(s);
2255     return ret;
2256 }
2257
2258 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2259 {
2260     OptionsContext *o = optctx;
2261     if(!strcmp(opt, "b")){
2262         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2263         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2264         return 0;
2265     }
2266     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2267     return 0;
2268 }
2269
2270 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2271 {
2272     OptionsContext *o = optctx;
2273     char *s;
2274     int ret;
2275     if(!strcmp(opt, "qscale")){
2276         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2277         return parse_option(o, "q:v", arg, options);
2278     }
2279     s = av_asprintf("q%s", opt + 6);
2280     ret = parse_option(o, s, arg, options);
2281     av_free(s);
2282     return ret;
2283 }
2284
2285 static int opt_profile(void *optctx, const char *opt, const char *arg)
2286 {
2287     OptionsContext *o = optctx;
2288     if(!strcmp(opt, "profile")){
2289         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2290         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2291         return 0;
2292     }
2293     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2294     return 0;
2295 }
2296
2297 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2298 {
2299     OptionsContext *o = optctx;
2300     return parse_option(o, "filter:v", arg, options);
2301 }
2302
2303 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2304 {
2305     OptionsContext *o = optctx;
2306     return parse_option(o, "filter:a", arg, options);
2307 }
2308
2309 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2310 {
2311     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2312     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2313     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2314     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2315
2316     if (video_sync_method == VSYNC_AUTO)
2317         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2318     return 0;
2319 }
2320
2321 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2322 {
2323     OptionsContext *o = optctx;
2324     char *tcr = av_asprintf("timecode=%s", arg);
2325     int ret = parse_option(o, "metadata:g", tcr, options);
2326     if (ret >= 0)
2327         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2328     av_free(tcr);
2329     return 0;
2330 }
2331
2332 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2333 {
2334     OptionsContext *o = optctx;
2335     char layout_str[32];
2336     char *stream_str;
2337     char *ac_str;
2338     int ret, channels, ac_str_size;
2339     uint64_t layout;
2340
2341     layout = av_get_channel_layout(arg);
2342     if (!layout) {
2343         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2344         return AVERROR(EINVAL);
2345     }
2346     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2347     ret = opt_default_new(o, opt, layout_str);
2348     if (ret < 0)
2349         return ret;
2350
2351     /* set 'ac' option based on channel layout */
2352     channels = av_get_channel_layout_nb_channels(layout);
2353     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2354     stream_str = strchr(opt, ':');
2355     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2356     ac_str = av_mallocz(ac_str_size);
2357     if (!ac_str)
2358         return AVERROR(ENOMEM);
2359     av_strlcpy(ac_str, "ac", 3);
2360     if (stream_str)
2361         av_strlcat(ac_str, stream_str, ac_str_size);
2362     ret = parse_option(o, ac_str, layout_str, options);
2363     av_free(ac_str);
2364
2365     return ret;
2366 }
2367
2368 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2369 {
2370     OptionsContext *o = optctx;
2371     return parse_option(o, "q:a", arg, options);
2372 }
2373
2374 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2375 {
2376     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2377     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2378         return AVERROR(ENOMEM);
2379     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2380     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2381     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2382         return AVERROR(ENOMEM);
2383     return 0;
2384 }
2385
2386 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2387 {
2388     uint8_t *graph_desc = read_file(arg);
2389     if (!graph_desc)
2390         return AVERROR(EINVAL);
2391
2392     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2393     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2394         return AVERROR(ENOMEM);
2395     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2396     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2397     return 0;
2398 }
2399
2400 void show_help_default(const char *opt, const char *arg)
2401 {
2402     /* per-file options have at least one of those set */
2403     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2404     int show_advanced = 0, show_avoptions = 0;
2405
2406     if (opt && *opt) {
2407         if (!strcmp(opt, "long"))
2408             show_advanced = 1;
2409         else if (!strcmp(opt, "full"))
2410             show_advanced = show_avoptions = 1;
2411         else
2412             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2413     }
2414
2415     show_usage();
2416
2417     printf("Getting help:\n"
2418            "    -h      -- print basic options\n"
2419            "    -h long -- print more options\n"
2420            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2421            "    See man %s for detailed description of the options.\n"
2422            "\n", program_name);
2423
2424     show_help_options(options, "Print help / information / capabilities:",
2425                       OPT_EXIT, 0, 0);
2426
2427     show_help_options(options, "Global options (affect whole program "
2428                       "instead of just one file:",
2429                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2430     if (show_advanced)
2431         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2432                           per_file | OPT_EXIT, 0);
2433
2434     show_help_options(options, "Per-file main options:", 0,
2435                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2436                       OPT_EXIT, per_file);
2437     if (show_advanced)
2438         show_help_options(options, "Advanced per-file options:",
2439                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2440
2441     show_help_options(options, "Video options:",
2442                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2443     if (show_advanced)
2444         show_help_options(options, "Advanced Video options:",
2445                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2446
2447     show_help_options(options, "Audio options:",
2448                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2449     if (show_advanced)
2450         show_help_options(options, "Advanced Audio options:",
2451                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2452     show_help_options(options, "Subtitle options:",
2453                       OPT_SUBTITLE, 0, 0);
2454     printf("\n");
2455
2456     if (show_avoptions) {
2457         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2458         show_help_children(avcodec_get_class(), flags);
2459         show_help_children(avformat_get_class(), flags);
2460 #if CONFIG_SWSCALE
2461         show_help_children(sws_get_class(), flags);
2462 #endif
2463         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2464         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2465     }
2466 }
2467
2468 void show_usage(void)
2469 {
2470     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2471     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2472     av_log(NULL, AV_LOG_INFO, "\n");
2473 }
2474
2475 enum OptGroup {
2476     GROUP_OUTFILE,
2477     GROUP_INFILE,
2478 };
2479
2480 static const OptionGroupDef groups[] = {
2481     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2482     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2483 };
2484
2485 static int open_files(OptionGroupList *l, const char *inout,
2486                       int (*open_file)(OptionsContext*, const char*))
2487 {
2488     int i, ret;
2489
2490     for (i = 0; i < l->nb_groups; i++) {
2491         OptionGroup *g = &l->groups[i];
2492         OptionsContext o;
2493
2494         init_options(&o);
2495         o.g = g;
2496
2497         ret = parse_optgroup(&o, g);
2498         if (ret < 0) {
2499             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2500                    "%s.\n", inout, g->arg);
2501             return ret;
2502         }
2503
2504         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2505         ret = open_file(&o, g->arg);
2506         uninit_options(&o);
2507         if (ret < 0) {
2508             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2509                    inout, g->arg);
2510             return ret;
2511         }
2512         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2513     }
2514
2515     return 0;
2516 }
2517
2518 int ffmpeg_parse_options(int argc, char **argv)
2519 {
2520     OptionParseContext octx;
2521     uint8_t error[128];
2522     int ret;
2523
2524     memset(&octx, 0, sizeof(octx));
2525
2526     /* split the commandline into an internal representation */
2527     ret = split_commandline(&octx, argc, argv, options, groups,
2528                             FF_ARRAY_ELEMS(groups));
2529     if (ret < 0) {
2530         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2531         goto fail;
2532     }
2533
2534     /* apply global options */
2535     ret = parse_optgroup(NULL, &octx.global_opts);
2536     if (ret < 0) {
2537         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2538         goto fail;
2539     }
2540
2541     /* open input files */
2542     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2543     if (ret < 0) {
2544         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2545         goto fail;
2546     }
2547
2548     /* open output files */
2549     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2550     if (ret < 0) {
2551         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2552         goto fail;
2553     }
2554
2555 fail:
2556     uninit_parse_context(&octx);
2557     if (ret < 0) {
2558         av_strerror(ret, error, sizeof(error));
2559         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2560     }
2561     return ret;
2562 }
2563
2564 static int opt_progress(void *optctx, const char *opt, const char *arg)
2565 {
2566     AVIOContext *avio = NULL;
2567     int ret;
2568
2569     if (!strcmp(arg, "-"))
2570         arg = "pipe:";
2571     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2572     if (ret < 0) {
2573         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2574                arg, av_err2str(ret));
2575         return ret;
2576     }
2577     progress_avio = avio;
2578     return 0;
2579 }
2580
2581 #define OFFSET(x) offsetof(OptionsContext, x)
2582 const OptionDef options[] = {
2583     /* main options */
2584 #include "cmdutils_common_opts.h"
2585     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2586                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2587         "force format", "fmt" },
2588     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2589         "overwrite output files" },
2590     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2591         "never overwrite output files" },
2592     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2593                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2594         "codec name", "codec" },
2595     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2596                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2597         "codec name", "codec" },
2598     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2599                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2600         "preset name", "preset" },
2601     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2602                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2603         "set input stream mapping",
2604         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2605     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2606         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2607     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2608                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2609         "set metadata information of outfile from infile",
2610         "outfile[,metadata]:infile[,metadata]" },
2611     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2612                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2613         "set chapters mapping", "input_file_index" },
2614     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2615                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2616         "record or transcode \"duration\" seconds of audio/video",
2617         "duration" },
2618     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2619         "record or transcode stop time", "time_stop" },
2620     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2621         "set the limit file size in bytes", "limit_size" },
2622     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2623                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2624         "set the start time offset", "time_off" },
2625     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2626                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2627         "enable/disable accurate seeking with -ss" },
2628     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2629                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2630         "set the input ts offset", "time_off" },
2631     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2632                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2633         "set the input ts scale", "scale" },
2634     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2635         "set the recording timestamp ('now' to set the current time)", "time" },
2636     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2637         "add metadata", "string=string" },
2638     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2639                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2640         "set the number of data frames to record", "number" },
2641     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2642         "add timings for benchmarking" },
2643     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2644       "add timings for each task" },
2645     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2646       "write program-readable progress information", "url" },
2647     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2648       "enable or disable interaction on standard input" },
2649     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2650         "set max runtime in seconds", "limit" },
2651     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2652         "dump each input packet" },
2653     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2654         "when dumping packets, also dump the payload" },
2655     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2656                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2657         "read input at native frame rate", "" },
2658     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2659         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2660         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2661     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2662         "video sync method", "" },
2663     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2664         "audio sync method", "" },
2665     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2666         "audio drift threshold", "threshold" },
2667     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2668         "copy timestamps" },
2669     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2670         "copy input stream time base when stream copying", "mode" },
2671     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2672                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2673         "finish encoding within shortest input" },
2674     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
2675                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
2676         "audio pad", "" },
2677     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2678         "timestamp discontinuity delta threshold", "threshold" },
2679     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2680         "timestamp error delta threshold", "threshold" },
2681     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2682         "exit on error", "error" },
2683     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2684                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2685         "copy initial non-keyframes" },
2686     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2687         "copy or discard frames before start time" },
2688     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2689         "set the number of frames to record", "number" },
2690     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2691                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2692         "force codec tag/fourcc", "fourcc/tag" },
2693     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2694                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2695         "use fixed quality scale (VBR)", "q" },
2696     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2697                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2698         "use fixed quality scale (VBR)", "q" },
2699     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2700         "set profile", "profile" },
2701     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2702         "set stream filtergraph", "filter_graph" },
2703     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2704         "read stream filtergraph description from a file", "filename" },
2705     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2706         "reinit filtergraph on input parameter changes", "" },
2707     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2708         "create a complex filtergraph", "graph_description" },
2709     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2710         "create a complex filtergraph", "graph_description" },
2711     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2712         "read complex filtergraph description from a file", "filename" },
2713     { "stats",          OPT_BOOL,                                    { &print_stats },
2714         "print progress report during encoding", },
2715     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2716                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2717         "add an attachment to the output file", "filename" },
2718     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2719                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2720         "extract an attachment into a file", "filename" },
2721     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2722         "print timestamp debugging info" },
2723     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
2724         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2725
2726     /* video options */
2727     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2728         "set the number of video frames to record", "number" },
2729     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2730                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2731         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2732     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2733                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2734         "set frame size (WxH or abbreviation)", "size" },
2735     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2736                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2737         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2738     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2739                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2740         "set pixel format", "format" },
2741     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2742         "set the number of bits per raw sample", "number" },
2743     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2744         "deprecated use -g 1" },
2745     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2746         "disable video" },
2747     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2748         "discard threshold", "n" },
2749     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2750                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2751         "rate control override for specific intervals", "override" },
2752     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2753                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2754         "force video codec ('copy' to copy stream)", "codec" },
2755     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2756         "Removed" },
2757     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2758         "Removed" },
2759     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2760         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2761     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2762         "select the pass number (1 to 3)", "n" },
2763     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2764                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2765         "select two pass log file name prefix", "prefix" },
2766     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2767         "this option is deprecated, use the yadif filter instead" },
2768     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2769         "calculate PSNR of compressed frames" },
2770     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2771         "dump video coding statistics to file" },
2772     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2773         "dump video coding statistics to file", "file" },
2774     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2775         "set video filters", "filter_graph" },
2776     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2777                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2778         "specify intra matrix coeffs", "matrix" },
2779     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2780                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2781         "specify inter matrix coeffs", "matrix" },
2782     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2783                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2784         "top=1/bottom=0/auto=-1 field first", "" },
2785     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2786         "intra_dc_precision", "precision" },
2787     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2788                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2789         "force video tag/fourcc", "fourcc/tag" },
2790     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2791         "show QP histogram" },
2792     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2793                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2794         "force the selected framerate, disable the best supported framerate selection" },
2795     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2796                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2797         "set the value of an outfile streamid", "streamIndex:value" },
2798     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2799                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2800         "force key frames at specified timestamps", "timestamps" },
2801     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2802         "video bitrate (please use -b:v)", "bitrate" },
2803
2804     /* audio options */
2805     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2806         "set the number of audio frames to record", "number" },
2807     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2808         "set audio quality (codec-specific)", "quality", },
2809     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2810                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2811         "set audio sampling rate (in Hz)", "rate" },
2812     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2813                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2814         "set number of audio channels", "channels" },
2815     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2816         "disable audio" },
2817     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2818                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2819         "force audio codec ('copy' to copy stream)", "codec" },
2820     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2821                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2822         "force audio tag/fourcc", "fourcc/tag" },
2823     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2824         "change audio volume (256=normal)" , "volume" },
2825     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2826                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2827         "set sample format", "format" },
2828     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2829                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2830         "set channel layout", "layout" },
2831     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2832         "set audio filters", "filter_graph" },
2833     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2834       "set the maximum number of channels to try to guess the channel layout" },
2835
2836     /* subtitle options */
2837     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2838         "disable subtitle" },
2839     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2840         "force subtitle codec ('copy' to copy stream)", "codec" },
2841     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2842         , "force subtitle tag/fourcc", "fourcc/tag" },
2843     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2844         "fix subtitles duration" },
2845     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2846         "set canvas size (WxH or abbreviation)", "size" },
2847
2848     /* grab options */
2849     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2850         "deprecated, use -channel", "channel" },
2851     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2852         "deprecated, use -standard", "standard" },
2853     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2854
2855     /* muxer options */
2856     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2857         "set the maximum demux-decode delay", "seconds" },
2858     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2859         "set the initial demux-decode delay", "seconds" },
2860     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2861         "override the options from ffserver", "" },
2862
2863     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2864         "A comma-separated list of bitstream filters", "bitstream_filters" },
2865     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2866         "deprecated", "audio bitstream_filters" },
2867     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2868         "deprecated", "video bitstream_filters" },
2869
2870     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2871         "set the audio options to the indicated preset", "preset" },
2872     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2873         "set the video options to the indicated preset", "preset" },
2874     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2875         "set the subtitle options to the indicated preset", "preset" },
2876     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2877         "set options from indicated preset file", "filename" },
2878     /* data codec support */
2879     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2880         "force data codec ('copy' to copy stream)", "codec" },
2881     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2882         "disable data" },
2883
2884     { NULL, },
2885 };