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