git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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