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