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

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