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