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

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