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