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

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