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