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