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     ofilter->format   = -1;
1975
1976     if (ost->stream_copy) {
1977         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1978                "which is fed from a complex filtergraph. Filtering and streamcopy "
1979                "cannot be used together.\n", ost->file_index, ost->index);
1980         exit_program(1);
1981     }
1982
1983     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1984         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1985         av_log(NULL, AV_LOG_ERROR,
1986                "%s '%s' was specified through the %s option "
1987                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1988                "%s and -filter_complex cannot be used together for the same stream.\n",
1989                ost->filters ? "Filtergraph" : "Filtergraph script",
1990                ost->filters ? ost->filters : ost->filters_script,
1991                opt, ost->file_index, ost->index, opt);
1992         exit_program(1);
1993     }
1994
1995     avfilter_inout_free(&ofilter->out_tmp);
1996 }
1997
1998 static int init_complex_filters(void)
1999 {
2000     int i, ret = 0;
2001
2002     for (i = 0; i < nb_filtergraphs; i++) {
2003         ret = init_complex_filtergraph(filtergraphs[i]);
2004         if (ret < 0)
2005             return ret;
2006     }
2007     return 0;
2008 }
2009
2010 static int configure_complex_filters(void)
2011 {
2012     int i, j, ret = 0;
2013
2014     for (i = 0; i < nb_filtergraphs; i++) {
2015         FilterGraph *fg = filtergraphs[i];
2016
2017         if (filtergraph_is_simple(fg))
2018             continue;
2019
2020         for (j = 0; j < fg->nb_inputs; j++) {
2021             ret = ifilter_parameters_from_decoder(fg->inputs[j],
2022                                                   fg->inputs[j]->ist->dec_ctx);
2023             if (ret < 0) {
2024                 av_log(NULL, AV_LOG_ERROR,
2025                        "Error initializing filtergraph %d input %d\n", i, j);
2026                 return ret;
2027             }
2028         }
2029
2030         ret = configure_filtergraph(filtergraphs[i]);
2031         if (ret < 0)
2032             return ret;
2033     }
2034     return 0;
2035 }
2036
2037 static int open_output_file(OptionsContext *o, const char *filename)
2038 {
2039     AVFormatContext *oc;
2040     int i, j, err;
2041     AVOutputFormat *file_oformat;
2042     OutputFile *of;
2043     OutputStream *ost;
2044     InputStream  *ist;
2045     AVDictionary *unused_opts = NULL;
2046     AVDictionaryEntry *e = NULL;
2047
2048
2049     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2050         o->stop_time = INT64_MAX;
2051         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2052     }
2053
2054     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2055         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2056         if (o->stop_time <= start_time) {
2057             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2058             exit_program(1);
2059         } else {
2060             o->recording_time = o->stop_time - start_time;
2061         }
2062     }
2063
2064     GROW_ARRAY(output_files, nb_output_files);
2065     of = av_mallocz(sizeof(*of));
2066     if (!of)
2067         exit_program(1);
2068     output_files[nb_output_files - 1] = of;
2069
2070     of->ost_index      = nb_output_streams;
2071     of->recording_time = o->recording_time;
2072     of->start_time     = o->start_time;
2073     of->limit_filesize = o->limit_filesize;
2074     of->shortest       = o->shortest;
2075     av_dict_copy(&of->opts, o->g->format_opts, 0);
2076
2077     if (!strcmp(filename, "-"))
2078         filename = "pipe:";
2079
2080     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2081     if (!oc) {
2082         print_error(filename, err);
2083         exit_program(1);
2084     }
2085
2086     of->ctx = oc;
2087     if (o->recording_time != INT64_MAX)
2088         oc->duration = o->recording_time;
2089
2090     file_oformat= oc->oformat;
2091     oc->interrupt_callback = int_cb;
2092
2093     /* create streams for all unlabeled output pads */
2094     for (i = 0; i < nb_filtergraphs; i++) {
2095         FilterGraph *fg = filtergraphs[i];
2096         for (j = 0; j < fg->nb_outputs; j++) {
2097             OutputFilter *ofilter = fg->outputs[j];
2098
2099             if (!ofilter->out_tmp || ofilter->out_tmp->name)
2100                 continue;
2101
2102             switch (ofilter->type) {
2103             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2104             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2105             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2106             }
2107             init_output_filter(ofilter, o, oc);
2108         }
2109     }
2110
2111     /* ffserver seeking with date=... needs a date reference */
2112     if (!strcmp(file_oformat->name, "ffm") &&
2113         av_strstart(filename, "http:", NULL)) {
2114         int err = parse_option(o, "metadata", "creation_time=now", options);
2115         if (err < 0) {
2116             print_error(filename, err);
2117             exit_program(1);
2118         }
2119     }
2120
2121     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2122         av_strstart(filename, "http:", NULL)) {
2123         int j;
2124         /* special case for files sent to ffserver: we get the stream
2125            parameters from ffserver */
2126         int err = read_ffserver_streams(o, oc, filename);
2127         if (err < 0) {
2128             print_error(filename, err);
2129             exit_program(1);
2130         }
2131         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2132             ost = output_streams[j];
2133             for (i = 0; i < nb_input_streams; i++) {
2134                 ist = input_streams[i];
2135                 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2136                     ost->sync_ist= ist;
2137                     ost->source_index= i;
2138                     if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2139                     if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2140                     ist->discard = 0;
2141                     ist->st->discard = ist->user_set_discard;
2142                     break;
2143                 }
2144             }
2145             if(!ost->sync_ist){
2146                 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));
2147                 exit_program(1);
2148             }
2149         }
2150     } else if (!o->nb_stream_maps) {
2151         char *subtitle_codec_name = NULL;
2152         /* pick the "best" stream of each type */
2153
2154         /* video: highest resolution */
2155         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2156             int area = 0, idx = -1;
2157             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2158             for (i = 0; i < nb_input_streams; i++) {
2159                 int new_area;
2160                 ist = input_streams[i];
2161                 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2162                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2163                     new_area = 1;
2164                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2165                     new_area > area) {
2166                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2167                         continue;
2168                     area = new_area;
2169                     idx = i;
2170                 }
2171             }
2172             if (idx >= 0)
2173                 new_video_stream(o, oc, idx);
2174         }
2175
2176         /* audio: most channels */
2177         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2178             int best_score = 0, idx = -1;
2179             for (i = 0; i < nb_input_streams; i++) {
2180                 int score;
2181                 ist = input_streams[i];
2182                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2183                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2184                     score > best_score) {
2185                     best_score = score;
2186                     idx = i;
2187                 }
2188             }
2189             if (idx >= 0)
2190                 new_audio_stream(o, oc, idx);
2191         }
2192
2193         /* subtitles: pick first */
2194         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2195         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2196             for (i = 0; i < nb_input_streams; i++)
2197                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2198                     AVCodecDescriptor const *input_descriptor =
2199                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2200                     AVCodecDescriptor const *output_descriptor = NULL;
2201                     AVCodec const *output_codec =
2202                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2203                     int input_props = 0, output_props = 0;
2204                     if (output_codec)
2205                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2206                     if (input_descriptor)
2207                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2208                     if (output_descriptor)
2209                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2210                     if (subtitle_codec_name ||
2211                         input_props & output_props ||
2212                         // Map dvb teletext which has neither property to any output subtitle encoder
2213                         input_descriptor && output_descriptor &&
2214                         (!input_descriptor->props ||
2215                          !output_descriptor->props)) {
2216                         new_subtitle_stream(o, oc, i);
2217                         break;
2218                     }
2219                 }
2220         }
2221         /* Data only if codec id match */
2222         if (!o->data_disable ) {
2223             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2224             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2225                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2226                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2227                     new_data_stream(o, oc, i);
2228             }
2229         }
2230     } else {
2231         for (i = 0; i < o->nb_stream_maps; i++) {
2232             StreamMap *map = &o->stream_maps[i];
2233
2234             if (map->disabled)
2235                 continue;
2236
2237             if (map->linklabel) {
2238                 FilterGraph *fg;
2239                 OutputFilter *ofilter = NULL;
2240                 int j, k;
2241
2242                 for (j = 0; j < nb_filtergraphs; j++) {
2243                     fg = filtergraphs[j];
2244                     for (k = 0; k < fg->nb_outputs; k++) {
2245                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2246                         if (out && !strcmp(out->name, map->linklabel)) {
2247                             ofilter = fg->outputs[k];
2248                             goto loop_end;
2249                         }
2250                     }
2251                 }
2252 loop_end:
2253                 if (!ofilter) {
2254                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2255                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2256                     exit_program(1);
2257                 }
2258                 init_output_filter(ofilter, o, oc);
2259             } else {
2260                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2261
2262                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2263                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2264                     continue;
2265                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2266                     continue;
2267                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2268                     continue;
2269                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2270                     continue;
2271
2272                 ost = NULL;
2273                 switch (ist->st->codecpar->codec_type) {
2274                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2275                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2276                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2277                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2278                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2279                 case AVMEDIA_TYPE_UNKNOWN:
2280                     if (copy_unknown_streams) {
2281                         ost = new_unknown_stream   (o, oc, src_idx);
2282                         break;
2283                     }
2284                 default:
2285                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2286                            "Cannot map stream #%d:%d - unsupported type.\n",
2287                            map->file_index, map->stream_index);
2288                     if (!ignore_unknown_streams) {
2289                         av_log(NULL, AV_LOG_FATAL,
2290                                "If you want unsupported types ignored instead "
2291                                "of failing, please use the -ignore_unknown option\n"
2292                                "If you want them copied, please use -copy_unknown\n");
2293                         exit_program(1);
2294                     }
2295                 }
2296                 if (ost)
2297                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2298                                                   + map->sync_stream_index];
2299             }
2300         }
2301     }
2302
2303     /* handle attached files */
2304     for (i = 0; i < o->nb_attachments; i++) {
2305         AVIOContext *pb;
2306         uint8_t *attachment;
2307         const char *p;
2308         int64_t len;
2309
2310         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2311             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2312                    o->attachments[i]);
2313             exit_program(1);
2314         }
2315         if ((len = avio_size(pb)) <= 0) {
2316             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2317                    o->attachments[i]);
2318             exit_program(1);
2319         }
2320         if (!(attachment = av_malloc(len))) {
2321             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2322                    o->attachments[i]);
2323             exit_program(1);
2324         }
2325         avio_read(pb, attachment, len);
2326
2327         ost = new_attachment_stream(o, oc, -1);
2328         ost->stream_copy               = 0;
2329         ost->attachment_filename       = o->attachments[i];
2330         ost->st->codecpar->extradata      = attachment;
2331         ost->st->codecpar->extradata_size = len;
2332
2333         p = strrchr(o->attachments[i], '/');
2334         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2335         avio_closep(&pb);
2336     }
2337
2338 #if FF_API_LAVF_AVCTX
2339     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2340         AVDictionaryEntry *e;
2341         ost = output_streams[i];
2342
2343         if ((ost->stream_copy || ost->attachment_filename)
2344             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2345             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2346             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2347                 exit_program(1);
2348     }
2349 #endif
2350
2351     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2352         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2353         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2354         exit_program(1);
2355     }
2356
2357     /* check if all codec options have been used */
2358     unused_opts = strip_specifiers(o->g->codec_opts);
2359     for (i = of->ost_index; i < nb_output_streams; i++) {
2360         e = NULL;
2361         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2362                                 AV_DICT_IGNORE_SUFFIX)))
2363             av_dict_set(&unused_opts, e->key, NULL, 0);
2364     }
2365
2366     e = NULL;
2367     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2368         const AVClass *class = avcodec_get_class();
2369         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2370                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2371         const AVClass *fclass = avformat_get_class();
2372         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2373                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2374         if (!option || foption)
2375             continue;
2376
2377
2378         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2379             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2380                    "output file #%d (%s) is not an encoding option.\n", e->key,
2381                    option->help ? option->help : "", nb_output_files - 1,
2382                    filename);
2383             exit_program(1);
2384         }
2385
2386         // gop_timecode is injected by generic code but not always used
2387         if (!strcmp(e->key, "gop_timecode"))
2388             continue;
2389
2390         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2391                "output file #%d (%s) has not been used for any stream. The most "
2392                "likely reason is either wrong type (e.g. a video option with "
2393                "no video streams) or that it is a private option of some encoder "
2394                "which was not actually used for any stream.\n", e->key,
2395                option->help ? option->help : "", nb_output_files - 1, filename);
2396     }
2397     av_dict_free(&unused_opts);
2398
2399     /* set the decoding_needed flags and create simple filtergraphs */
2400     for (i = of->ost_index; i < nb_output_streams; i++) {
2401         OutputStream *ost = output_streams[i];
2402
2403         if (ost->encoding_needed && ost->source_index >= 0) {
2404             InputStream *ist = input_streams[ost->source_index];
2405             ist->decoding_needed |= DECODING_FOR_OST;
2406
2407             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2408                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2409                 err = init_simple_filtergraph(ist, ost);
2410                 if (err < 0) {
2411                     av_log(NULL, AV_LOG_ERROR,
2412                            "Error initializing a simple filtergraph between streams "
2413                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2414                            nb_output_files - 1, ost->st->index);
2415                     exit_program(1);
2416                 }
2417             }
2418         }
2419
2420         /* set the filter output constraints */
2421         if (ost->filter) {
2422             OutputFilter *f = ost->filter;
2423             int count;
2424             switch (ost->enc_ctx->codec_type) {
2425             case AVMEDIA_TYPE_VIDEO:
2426                 f->frame_rate = ost->frame_rate;
2427                 f->width      = ost->enc_ctx->width;
2428                 f->height     = ost->enc_ctx->height;
2429                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2430                     f->format = ost->enc_ctx->pix_fmt;
2431                 } else if (ost->enc->pix_fmts) {
2432                     count = 0;
2433                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2434                         count++;
2435                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2436                     if (!f->formats)
2437                         exit_program(1);
2438                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2439                 }
2440                 break;
2441             case AVMEDIA_TYPE_AUDIO:
2442                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2443                     f->format = ost->enc_ctx->sample_fmt;
2444                 } else if (ost->enc->sample_fmts) {
2445                     count = 0;
2446                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2447                         count++;
2448                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2449                     if (!f->formats)
2450                         exit_program(1);
2451                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2452                 }
2453                 if (ost->enc_ctx->sample_rate) {
2454                     f->sample_rate = ost->enc_ctx->sample_rate;
2455                 } else if (ost->enc->supported_samplerates) {
2456                     count = 0;
2457                     while (ost->enc->supported_samplerates[count])
2458                         count++;
2459                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2460                     if (!f->sample_rates)
2461                         exit_program(1);
2462                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2463                            (count + 1) * sizeof(*f->sample_rates));
2464                 }
2465                 if (ost->enc_ctx->channels) {
2466                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2467                 } else if (ost->enc->channel_layouts) {
2468                     count = 0;
2469                     while (ost->enc->channel_layouts[count])
2470                         count++;
2471                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2472                     if (!f->channel_layouts)
2473                         exit_program(1);
2474                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2475                            (count + 1) * sizeof(*f->channel_layouts));
2476                 }
2477                 break;
2478             }
2479         }
2480     }
2481
2482     /* check filename in case of an image number is expected */
2483     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2484         if (!av_filename_number_test(oc->filename)) {
2485             print_error(oc->filename, AVERROR(EINVAL));
2486             exit_program(1);
2487         }
2488     }
2489
2490     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2491         av_log(NULL, AV_LOG_ERROR,
2492                "No input streams but output needs an input stream\n");
2493         exit_program(1);
2494     }
2495
2496     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2497         /* test if it already exists to avoid losing precious files */
2498         assert_file_overwrite(filename);
2499
2500         /* open the file */
2501         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2502                               &oc->interrupt_callback,
2503                               &of->opts)) < 0) {
2504             print_error(filename, err);
2505             exit_program(1);
2506         }
2507     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2508         assert_file_overwrite(filename);
2509
2510     if (o->mux_preload) {
2511         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2512     }
2513     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2514
2515     /* copy metadata */
2516     for (i = 0; i < o->nb_metadata_map; i++) {
2517         char *p;
2518         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2519
2520         if (in_file_index >= nb_input_files) {
2521             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2522             exit_program(1);
2523         }
2524         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2525                       in_file_index >= 0 ?
2526                       input_files[in_file_index]->ctx : NULL, o);
2527     }
2528
2529     /* copy chapters */
2530     if (o->chapters_input_file >= nb_input_files) {
2531         if (o->chapters_input_file == INT_MAX) {
2532             /* copy chapters from the first input file that has them*/
2533             o->chapters_input_file = -1;
2534             for (i = 0; i < nb_input_files; i++)
2535                 if (input_files[i]->ctx->nb_chapters) {
2536                     o->chapters_input_file = i;
2537                     break;
2538                 }
2539         } else {
2540             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2541                    o->chapters_input_file);
2542             exit_program(1);
2543         }
2544     }
2545     if (o->chapters_input_file >= 0)
2546         copy_chapters(input_files[o->chapters_input_file], of,
2547                       !o->metadata_chapters_manual);
2548
2549     /* copy global metadata by default */
2550     if (!o->metadata_global_manual && nb_input_files){
2551         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2552                      AV_DICT_DONT_OVERWRITE);
2553         if(o->recording_time != INT64_MAX)
2554             av_dict_set(&oc->metadata, "duration", NULL, 0);
2555         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2556     }
2557     if (!o->metadata_streams_manual)
2558         for (i = of->ost_index; i < nb_output_streams; i++) {
2559             InputStream *ist;
2560             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2561                 continue;
2562             ist = input_streams[output_streams[i]->source_index];
2563             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2564             if (!output_streams[i]->stream_copy) {
2565                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2566                 if (ist->autorotate)
2567                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2568             }
2569         }
2570
2571     /* process manually set programs */
2572     for (i = 0; i < o->nb_program; i++) {
2573         const char *p = o->program[i].u.str;
2574         int progid = i+1;
2575         AVProgram *program;
2576
2577         while(*p) {
2578             const char *p2 = av_get_token(&p, ":");
2579             const char *to_dealloc = p2;
2580             char *key;
2581             if (!p2)
2582                 break;
2583
2584             if(*p) p++;
2585
2586             key = av_get_token(&p2, "=");
2587             if (!key || !*p2) {
2588                 av_freep(&to_dealloc);
2589                 av_freep(&key);
2590                 break;
2591             }
2592             p2++;
2593
2594             if (!strcmp(key, "program_num"))
2595                 progid = strtol(p2, NULL, 0);
2596             av_freep(&to_dealloc);
2597             av_freep(&key);
2598         }
2599
2600         program = av_new_program(oc, progid);
2601
2602         p = o->program[i].u.str;
2603         while(*p) {
2604             const char *p2 = av_get_token(&p, ":");
2605             const char *to_dealloc = p2;
2606             char *key;
2607             if (!p2)
2608                 break;
2609             if(*p) p++;
2610
2611             key = av_get_token(&p2, "=");
2612             if (!key) {
2613                 av_log(NULL, AV_LOG_FATAL,
2614                        "No '=' character in program string %s.\n",
2615                        p2);
2616                 exit_program(1);
2617             }
2618             if (!*p2)
2619                 exit_program(1);
2620             p2++;
2621
2622             if (!strcmp(key, "title")) {
2623                 av_dict_set(&program->metadata, "title", p2, 0);
2624             } else if (!strcmp(key, "program_num")) {
2625             } else if (!strcmp(key, "st")) {
2626                 int st_num = strtol(p2, NULL, 0);
2627                 av_program_add_stream_index(oc, progid, st_num);
2628             } else {
2629                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2630                 exit_program(1);
2631             }
2632             av_freep(&to_dealloc);
2633             av_freep(&key);
2634         }
2635     }
2636
2637     /* process manually set metadata */
2638     for (i = 0; i < o->nb_metadata; i++) {
2639         AVDictionary **m;
2640         char type, *val;
2641         const char *stream_spec;
2642         int index = 0, j, ret = 0;
2643
2644         val = strchr(o->metadata[i].u.str, '=');
2645         if (!val) {
2646             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2647                    o->metadata[i].u.str);
2648             exit_program(1);
2649         }
2650         *val++ = 0;
2651
2652         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2653         if (type == 's') {
2654             for (j = 0; j < oc->nb_streams; j++) {
2655                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2656                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2657                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2658                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2659                         ost->rotate_overridden = 1;
2660                     }
2661                 } else if (ret < 0)
2662                     exit_program(1);
2663             }
2664         }
2665         else {
2666             switch (type) {
2667             case 'g':
2668                 m = &oc->metadata;
2669                 break;
2670             case 'c':
2671                 if (index < 0 || index >= oc->nb_chapters) {
2672                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2673                     exit_program(1);
2674                 }
2675                 m = &oc->chapters[index]->metadata;
2676                 break;
2677             case 'p':
2678                 if (index < 0 || index >= oc->nb_programs) {
2679                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2680                     exit_program(1);
2681                 }
2682                 m = &oc->programs[index]->metadata;
2683                 break;
2684             default:
2685                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2686                 exit_program(1);
2687             }
2688             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2689         }
2690     }
2691
2692     return 0;
2693 }
2694
2695 static int opt_target(void *optctx, const char *opt, const char *arg)
2696 {
2697     OptionsContext *o = optctx;
2698     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2699     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2700
2701     if (!strncmp(arg, "pal-", 4)) {
2702         norm = PAL;
2703         arg += 4;
2704     } else if (!strncmp(arg, "ntsc-", 5)) {
2705         norm = NTSC;
2706         arg += 5;
2707     } else if (!strncmp(arg, "film-", 5)) {
2708         norm = FILM;
2709         arg += 5;
2710     } else {
2711         /* Try to determine PAL/NTSC by peeking in the input files */
2712         if (nb_input_files) {
2713             int i, j, fr;
2714             for (j = 0; j < nb_input_files; j++) {
2715                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2716                     AVStream *st = input_files[j]->ctx->streams[i];
2717                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2718                         continue;
2719                     fr = st->time_base.den * 1000 / st->time_base.num;
2720                     if (fr == 25000) {
2721                         norm = PAL;
2722                         break;
2723                     } else if ((fr == 29970) || (fr == 23976)) {
2724                         norm = NTSC;
2725                         break;
2726                     }
2727                 }
2728                 if (norm != UNKNOWN)
2729                     break;
2730             }
2731         }
2732         if (norm != UNKNOWN)
2733             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2734     }
2735
2736     if (norm == UNKNOWN) {
2737         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2738         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2739         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2740         exit_program(1);
2741     }
2742
2743     if (!strcmp(arg, "vcd")) {
2744         opt_video_codec(o, "c:v", "mpeg1video");
2745         opt_audio_codec(o, "c:a", "mp2");
2746         parse_option(o, "f", "vcd", options);
2747
2748         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2749         parse_option(o, "r", frame_rates[norm], options);
2750         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2751
2752         opt_default(NULL, "b:v", "1150000");
2753         opt_default(NULL, "maxrate:v", "1150000");
2754         opt_default(NULL, "minrate:v", "1150000");
2755         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2756
2757         opt_default(NULL, "b:a", "224000");
2758         parse_option(o, "ar", "44100", options);
2759         parse_option(o, "ac", "2", options);
2760
2761         opt_default(NULL, "packetsize", "2324");
2762         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2763
2764         /* We have to offset the PTS, so that it is consistent with the SCR.
2765            SCR starts at 36000, but the first two packs contain only padding
2766            and the first pack from the other stream, respectively, may also have
2767            been written before.
2768            So the real data starts at SCR 36000+3*1200. */
2769         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2770     } else if (!strcmp(arg, "svcd")) {
2771
2772         opt_video_codec(o, "c:v", "mpeg2video");
2773         opt_audio_codec(o, "c:a", "mp2");
2774         parse_option(o, "f", "svcd", options);
2775
2776         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2777         parse_option(o, "r", frame_rates[norm], options);
2778         parse_option(o, "pix_fmt", "yuv420p", options);
2779         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2780
2781         opt_default(NULL, "b:v", "2040000");
2782         opt_default(NULL, "maxrate:v", "2516000");
2783         opt_default(NULL, "minrate:v", "0"); // 1145000;
2784         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2785         opt_default(NULL, "scan_offset", "1");
2786
2787         opt_default(NULL, "b:a", "224000");
2788         parse_option(o, "ar", "44100", options);
2789
2790         opt_default(NULL, "packetsize", "2324");
2791
2792     } else if (!strcmp(arg, "dvd")) {
2793
2794         opt_video_codec(o, "c:v", "mpeg2video");
2795         opt_audio_codec(o, "c:a", "ac3");
2796         parse_option(o, "f", "dvd", options);
2797
2798         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2799         parse_option(o, "r", frame_rates[norm], options);
2800         parse_option(o, "pix_fmt", "yuv420p", options);
2801         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2802
2803         opt_default(NULL, "b:v", "6000000");
2804         opt_default(NULL, "maxrate:v", "9000000");
2805         opt_default(NULL, "minrate:v", "0"); // 1500000;
2806         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2807
2808         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2809         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2810
2811         opt_default(NULL, "b:a", "448000");
2812         parse_option(o, "ar", "48000", options);
2813
2814     } else if (!strncmp(arg, "dv", 2)) {
2815
2816         parse_option(o, "f", "dv", options);
2817
2818         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2819         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2820                           norm == PAL ? "yuv420p" : "yuv411p", options);
2821         parse_option(o, "r", frame_rates[norm], options);
2822
2823         parse_option(o, "ar", "48000", options);
2824         parse_option(o, "ac", "2", options);
2825
2826     } else {
2827         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2828         return AVERROR(EINVAL);
2829     }
2830
2831     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2832     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2833
2834     return 0;
2835 }
2836
2837 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2838 {
2839     av_free (vstats_filename);
2840     vstats_filename = av_strdup (arg);
2841     return 0;
2842 }
2843
2844 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2845 {
2846     char filename[40];
2847     time_t today2 = time(NULL);
2848     struct tm *today = localtime(&today2);
2849
2850     if (!today) { // maybe tomorrow
2851         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2852         exit_program(1);
2853     }
2854
2855     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2856              today->tm_sec);
2857     return opt_vstats_file(NULL, opt, filename);
2858 }
2859
2860 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2861 {
2862     OptionsContext *o = optctx;
2863     return parse_option(o, "frames:v", arg, options);
2864 }
2865
2866 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2867 {
2868     OptionsContext *o = optctx;
2869     return parse_option(o, "frames:a", arg, options);
2870 }
2871
2872 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2873 {
2874     OptionsContext *o = optctx;
2875     return parse_option(o, "frames:d", arg, options);
2876 }
2877
2878 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2879 {
2880     int ret;
2881     AVDictionary *cbak = codec_opts;
2882     AVDictionary *fbak = format_opts;
2883     codec_opts = NULL;
2884     format_opts = NULL;
2885
2886     ret = opt_default(NULL, opt, arg);
2887
2888     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2889     av_dict_copy(&o->g->format_opts, format_opts, 0);
2890     av_dict_free(&codec_opts);
2891     av_dict_free(&format_opts);
2892     codec_opts = cbak;
2893     format_opts = fbak;
2894
2895     return ret;
2896 }
2897
2898 static int opt_preset(void *optctx, const char *opt, const char *arg)
2899 {
2900     OptionsContext *o = optctx;
2901     FILE *f=NULL;
2902     char filename[1000], line[1000], tmp_line[1000];
2903     const char *codec_name = NULL;
2904
2905     tmp_line[0] = *opt;
2906     tmp_line[1] = 0;
2907     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2908
2909     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2910         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2911             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2912         }else
2913             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2914         exit_program(1);
2915     }
2916
2917     while (fgets(line, sizeof(line), f)) {
2918         char *key = tmp_line, *value, *endptr;
2919
2920         if (strcspn(line, "#\n\r") == 0)
2921             continue;
2922         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2923         if (!av_strtok(key,   "=",    &value) ||
2924             !av_strtok(value, "\r\n", &endptr)) {
2925             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2926             exit_program(1);
2927         }
2928         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2929
2930         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2931         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2932         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2933         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2934         else if (opt_default_new(o, key, value) < 0) {
2935             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2936                    filename, line, key, value);
2937             exit_program(1);
2938         }
2939     }
2940
2941     fclose(f);
2942
2943     return 0;
2944 }
2945
2946 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2947 {
2948     OptionsContext *o = optctx;
2949     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2950     int ret = parse_option(o, s, arg, options);
2951     av_free(s);
2952     return ret;
2953 }
2954
2955 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2956 {
2957     OptionsContext *o = optctx;
2958
2959     if(!strcmp(opt, "ab")){
2960         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2961         return 0;
2962     } else if(!strcmp(opt, "b")){
2963         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2964         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2965         return 0;
2966     }
2967     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2968     return 0;
2969 }
2970
2971 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2972 {
2973     OptionsContext *o = optctx;
2974     char *s;
2975     int ret;
2976     if(!strcmp(opt, "qscale")){
2977         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2978         return parse_option(o, "q:v", arg, options);
2979     }
2980     s = av_asprintf("q%s", opt + 6);
2981     ret = parse_option(o, s, arg, options);
2982     av_free(s);
2983     return ret;
2984 }
2985
2986 static int opt_profile(void *optctx, const char *opt, const char *arg)
2987 {
2988     OptionsContext *o = optctx;
2989     if(!strcmp(opt, "profile")){
2990         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2991         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2992         return 0;
2993     }
2994     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2995     return 0;
2996 }
2997
2998 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2999 {
3000     OptionsContext *o = optctx;
3001     return parse_option(o, "filter:v", arg, options);
3002 }
3003
3004 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3005 {
3006     OptionsContext *o = optctx;
3007     return parse_option(o, "filter:a", arg, options);
3008 }
3009
3010 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3011 {
3012     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3013     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3014     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3015     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3016
3017     if (video_sync_method == VSYNC_AUTO)
3018         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3019     return 0;
3020 }
3021
3022 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3023 {
3024     OptionsContext *o = optctx;
3025     char *tcr = av_asprintf("timecode=%s", arg);
3026     int ret = parse_option(o, "metadata:g", tcr, options);
3027     if (ret >= 0)
3028         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3029     av_free(tcr);
3030     return 0;
3031 }
3032
3033 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3034 {
3035     OptionsContext *o = optctx;
3036     char layout_str[32];
3037     char *stream_str;
3038     char *ac_str;
3039     int ret, channels, ac_str_size;
3040     uint64_t layout;
3041
3042     layout = av_get_channel_layout(arg);
3043     if (!layout) {
3044         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3045         return AVERROR(EINVAL);
3046     }
3047     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3048     ret = opt_default_new(o, opt, layout_str);
3049     if (ret < 0)
3050         return ret;
3051
3052     /* set 'ac' option based on channel layout */
3053     channels = av_get_channel_layout_nb_channels(layout);
3054     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3055     stream_str = strchr(opt, ':');
3056     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3057     ac_str = av_mallocz(ac_str_size);
3058     if (!ac_str)
3059         return AVERROR(ENOMEM);
3060     av_strlcpy(ac_str, "ac", 3);
3061     if (stream_str)
3062         av_strlcat(ac_str, stream_str, ac_str_size);
3063     ret = parse_option(o, ac_str, layout_str, options);
3064     av_free(ac_str);
3065
3066     return ret;
3067 }
3068
3069 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3070 {
3071     OptionsContext *o = optctx;
3072     return parse_option(o, "q:a", arg, options);
3073 }
3074
3075 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3076 {
3077     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3078     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3079         return AVERROR(ENOMEM);
3080     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3081     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3082     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3083         return AVERROR(ENOMEM);
3084
3085     input_stream_potentially_available = 1;
3086
3087     return 0;
3088 }
3089
3090 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3091 {
3092     uint8_t *graph_desc = read_file(arg);
3093     if (!graph_desc)
3094         return AVERROR(EINVAL);
3095
3096     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3097     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3098         return AVERROR(ENOMEM);
3099     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3100     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3101
3102     input_stream_potentially_available = 1;
3103
3104     return 0;
3105 }
3106
3107 void show_help_default(const char *opt, const char *arg)
3108 {
3109     /* per-file options have at least one of those set */
3110     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3111     int show_advanced = 0, show_avoptions = 0;
3112
3113     if (opt && *opt) {
3114         if (!strcmp(opt, "long"))
3115             show_advanced = 1;
3116         else if (!strcmp(opt, "full"))
3117             show_advanced = show_avoptions = 1;
3118         else
3119             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3120     }
3121
3122     show_usage();
3123
3124     printf("Getting help:\n"
3125            "    -h      -- print basic options\n"
3126            "    -h long -- print more options\n"
3127            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3128            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3129            "    See man %s for detailed description of the options.\n"
3130            "\n", program_name);
3131
3132     show_help_options(options, "Print help / information / capabilities:",
3133                       OPT_EXIT, 0, 0);
3134
3135     show_help_options(options, "Global options (affect whole program "
3136                       "instead of just one file:",
3137                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3138     if (show_advanced)
3139         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3140                           per_file | OPT_EXIT, 0);
3141
3142     show_help_options(options, "Per-file main options:", 0,
3143                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3144                       OPT_EXIT, per_file);
3145     if (show_advanced)
3146         show_help_options(options, "Advanced per-file options:",
3147                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3148
3149     show_help_options(options, "Video options:",
3150                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3151     if (show_advanced)
3152         show_help_options(options, "Advanced Video options:",
3153                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3154
3155     show_help_options(options, "Audio options:",
3156                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3157     if (show_advanced)
3158         show_help_options(options, "Advanced Audio options:",
3159                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3160     show_help_options(options, "Subtitle options:",
3161                       OPT_SUBTITLE, 0, 0);
3162     printf("\n");
3163
3164     if (show_avoptions) {
3165         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3166         show_help_children(avcodec_get_class(), flags);
3167         show_help_children(avformat_get_class(), flags);
3168 #if CONFIG_SWSCALE
3169         show_help_children(sws_get_class(), flags);
3170 #endif
3171         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3172         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3173     }
3174 }
3175
3176 void show_usage(void)
3177 {
3178     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3179     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3180     av_log(NULL, AV_LOG_INFO, "\n");
3181 }
3182
3183 enum OptGroup {
3184     GROUP_OUTFILE,
3185     GROUP_INFILE,
3186 };
3187
3188 static const OptionGroupDef groups[] = {
3189     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
3190     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
3191 };
3192
3193 static int open_files(OptionGroupList *l, const char *inout,
3194                       int (*open_file)(OptionsContext*, const char*))
3195 {
3196     int i, ret;
3197
3198     for (i = 0; i < l->nb_groups; i++) {
3199         OptionGroup *g = &l->groups[i];
3200         OptionsContext o;
3201
3202         init_options(&o);
3203         o.g = g;
3204
3205         ret = parse_optgroup(&o, g);
3206         if (ret < 0) {
3207             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3208                    "%s.\n", inout, g->arg);
3209             return ret;
3210         }
3211
3212         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3213         ret = open_file(&o, g->arg);
3214         uninit_options(&o);
3215         if (ret < 0) {
3216             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3217                    inout, g->arg);
3218             return ret;
3219         }
3220         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3221     }
3222
3223     return 0;
3224 }
3225
3226 int ffmpeg_parse_options(int argc, char **argv)
3227 {
3228     OptionParseContext octx;
3229     uint8_t error[128];
3230     int ret;
3231
3232     memset(&octx, 0, sizeof(octx));
3233
3234     /* split the commandline into an internal representation */
3235     ret = split_commandline(&octx, argc, argv, options, groups,
3236                             FF_ARRAY_ELEMS(groups));
3237     if (ret < 0) {
3238         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3239         goto fail;
3240     }
3241
3242     /* apply global options */
3243     ret = parse_optgroup(NULL, &octx.global_opts);
3244     if (ret < 0) {
3245         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3246         goto fail;
3247     }
3248
3249     /* configure terminal and setup signal handlers */
3250     term_init();
3251
3252     /* open input files */
3253     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3254     if (ret < 0) {
3255         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3256         goto fail;
3257     }
3258
3259     /* create the complex filtergraphs */
3260     ret = init_complex_filters();
3261     if (ret < 0) {
3262         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3263         goto fail;
3264     }
3265
3266     /* open output files */
3267     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3268     if (ret < 0) {
3269         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3270         goto fail;
3271     }
3272
3273     /* configure the complex filtergraphs */
3274     ret = configure_complex_filters();
3275     if (ret < 0) {
3276         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3277         goto fail;
3278     }
3279
3280 fail:
3281     uninit_parse_context(&octx);
3282     if (ret < 0) {
3283         av_strerror(ret, error, sizeof(error));
3284         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3285     }
3286     return ret;
3287 }
3288
3289 static int opt_progress(void *optctx, const char *opt, const char *arg)
3290 {
3291     AVIOContext *avio = NULL;
3292     int ret;
3293
3294     if (!strcmp(arg, "-"))
3295         arg = "pipe:";
3296     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3297     if (ret < 0) {
3298         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3299                arg, av_err2str(ret));
3300         return ret;
3301     }
3302     progress_avio = avio;
3303     return 0;
3304 }
3305
3306 #define OFFSET(x) offsetof(OptionsContext, x)
3307 const OptionDef options[] = {
3308     /* main options */
3309 #include "cmdutils_common_opts.h"
3310     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3311                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3312         "force format", "fmt" },
3313     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3314         "overwrite output files" },
3315     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3316         "never overwrite output files" },
3317     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3318         "Ignore unknown stream types" },
3319     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3320         "Copy unknown stream types" },
3321     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3322                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3323         "codec name", "codec" },
3324     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3325                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3326         "codec name", "codec" },
3327     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3328                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3329         "preset name", "preset" },
3330     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3331                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3332         "set input stream mapping",
3333         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3334     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3335         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3336     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3337                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3338         "set metadata information of outfile from infile",
3339         "outfile[,metadata]:infile[,metadata]" },
3340     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3341                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3342         "set chapters mapping", "input_file_index" },
3343     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3344                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3345         "record or transcode \"duration\" seconds of audio/video",
3346         "duration" },
3347     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3348         "record or transcode stop time", "time_stop" },
3349     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3350         "set the limit file size in bytes", "limit_size" },
3351     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3352                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3353         "set the start time offset", "time_off" },
3354     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3355                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3356         "set the start time offset relative to EOF", "time_off" },
3357     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3358                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3359         "enable/disable seeking by timestamp with -ss" },
3360     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3361                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3362         "enable/disable accurate seeking with -ss" },
3363     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3364                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3365         "set the input ts offset", "time_off" },
3366     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3367                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3368         "set the input ts scale", "scale" },
3369     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3370         "set the recording timestamp ('now' to set the current time)", "time" },
3371     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3372         "add metadata", "string=string" },
3373     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3374         "add program with specified streams", "title=string:st=number..." },
3375     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3376                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3377         "set the number of data frames to output", "number" },
3378     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3379         "add timings for benchmarking" },
3380     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3381       "add timings for each task" },
3382     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3383       "write program-readable progress information", "url" },
3384     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3385       "enable or disable interaction on standard input" },
3386     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3387         "set max runtime in seconds", "limit" },
3388     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3389         "dump each input packet" },
3390     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3391         "when dumping packets, also dump the payload" },
3392     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3393                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3394         "read input at native frame rate", "" },
3395     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3396         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3397         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3398     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3399         "video sync method", "" },
3400     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3401         "frame drop threshold", "" },
3402     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3403         "audio sync method", "" },
3404     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3405         "audio drift threshold", "threshold" },
3406     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3407         "copy timestamps" },
3408     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3409         "shift input timestamps to start at 0 when using copyts" },
3410     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3411         "copy input stream time base when stream copying", "mode" },
3412     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3413                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3414         "finish encoding within shortest input" },
3415     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3416                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3417         "audio pad", "" },
3418     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3419         "timestamp discontinuity delta threshold", "threshold" },
3420     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3421         "timestamp error delta threshold", "threshold" },
3422     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3423         "exit on error", "error" },
3424     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3425         "abort on the specified condition flags", "flags" },
3426     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3427                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3428         "copy initial non-keyframes" },
3429     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3430         "copy or discard frames before start time" },
3431     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3432         "set the number of frames to output", "number" },
3433     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3434                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3435         "force codec tag/fourcc", "fourcc/tag" },
3436     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3437                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3438         "use fixed quality scale (VBR)", "q" },
3439     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3440                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3441         "use fixed quality scale (VBR)", "q" },
3442     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3443         "set profile", "profile" },
3444     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3445         "set stream filtergraph", "filter_graph" },
3446     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3447         "number of non-complex filter threads" },
3448     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3449         "read stream filtergraph description from a file", "filename" },
3450     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3451         "reinit filtergraph on input parameter changes", "" },
3452     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3453         "create a complex filtergraph", "graph_description" },
3454     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3455         "number of threads for -filter_complex" },
3456     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3457         "create a complex filtergraph", "graph_description" },
3458     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3459         "read complex filtergraph description from a file", "filename" },
3460     { "stats",          OPT_BOOL,                                    { &print_stats },
3461         "print progress report during encoding", },
3462     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3463                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3464         "add an attachment to the output file", "filename" },
3465     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3466                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3467         "extract an attachment into a file", "filename" },
3468     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3469                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3470     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3471         "print timestamp debugging info" },
3472     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3473         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3474     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3475                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3476         "discard", "" },
3477     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3478                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3479         "disposition", "" },
3480     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3481                                                                      { .off = OFFSET(thread_queue_size) },
3482         "set the maximum number of queued packets from the demuxer" },
3483
3484     /* video options */
3485     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3486         "set the number of video frames to output", "number" },
3487     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3488                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3489         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3490     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3491                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3492         "set frame size (WxH or abbreviation)", "size" },
3493     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3494                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3495         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3496     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3497                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3498         "set pixel format", "format" },
3499     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3500         "set the number of bits per raw sample", "number" },
3501     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3502         "deprecated use -g 1" },
3503     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3504         "disable video" },
3505     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3506                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3507         "rate control override for specific intervals", "override" },
3508     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3509                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3510         "force video codec ('copy' to copy stream)", "codec" },
3511     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3512         "Removed" },
3513     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3514         "Removed" },
3515     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3516         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3517     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3518         "select the pass number (1 to 3)", "n" },
3519     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3520                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3521         "select two pass log file name prefix", "prefix" },
3522     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3523         "this option is deprecated, use the yadif filter instead" },
3524     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3525         "calculate PSNR of compressed frames" },
3526     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3527         "dump video coding statistics to file" },
3528     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3529         "dump video coding statistics to file", "file" },
3530     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3531         "set video filters", "filter_graph" },
3532     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3533                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3534         "specify intra matrix coeffs", "matrix" },
3535     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3536                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3537         "specify inter matrix coeffs", "matrix" },
3538     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3539                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3540         "specify intra matrix coeffs", "matrix" },
3541     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3542                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3543         "top=1/bottom=0/auto=-1 field first", "" },
3544     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3545                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3546         "force video tag/fourcc", "fourcc/tag" },
3547     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3548         "show QP histogram" },
3549     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3550                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3551         "force the selected framerate, disable the best supported framerate selection" },
3552     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3553                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3554         "set the value of an outfile streamid", "streamIndex:value" },
3555     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3556                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3557         "force key frames at specified timestamps", "timestamps" },
3558     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3559         "audio bitrate (please use -b:a)", "bitrate" },
3560     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3561         "video bitrate (please use -b:v)", "bitrate" },
3562     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3563                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3564         "use HW accelerated decoding", "hwaccel name" },
3565     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3566                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3567         "select a device for HW acceleration", "devicename" },
3568     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3569                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3570         "select output format used with HW accelerated decoding", "format" },
3571 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3572     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3573 #endif
3574     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3575         "show available HW acceleration methods" },
3576     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3577                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3578         "automatically insert correct rotate filters" },
3579     { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
3580         "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3581
3582     /* audio options */
3583     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3584         "set the number of audio frames to output", "number" },
3585     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3586         "set audio quality (codec-specific)", "quality", },
3587     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3588                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3589         "set audio sampling rate (in Hz)", "rate" },
3590     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3591                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3592         "set number of audio channels", "channels" },
3593     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3594         "disable audio" },
3595     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3596                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3597         "force audio codec ('copy' to copy stream)", "codec" },
3598     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3599                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3600         "force audio tag/fourcc", "fourcc/tag" },
3601     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3602         "change audio volume (256=normal)" , "volume" },
3603     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3604                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3605         "set sample format", "format" },
3606     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3607                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3608         "set channel layout", "layout" },
3609     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3610         "set audio filters", "filter_graph" },
3611     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3612       "set the maximum number of channels to try to guess the channel layout" },
3613
3614     /* subtitle options */
3615     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3616         "disable subtitle" },
3617     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3618         "force subtitle codec ('copy' to copy stream)", "codec" },
3619     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3620         , "force subtitle tag/fourcc", "fourcc/tag" },
3621     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3622         "fix subtitles duration" },
3623     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3624         "set canvas size (WxH or abbreviation)", "size" },
3625
3626     /* grab options */
3627     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3628         "deprecated, use -channel", "channel" },
3629     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3630         "deprecated, use -standard", "standard" },
3631     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3632
3633     /* muxer options */
3634     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3635         "set the maximum demux-decode delay", "seconds" },
3636     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3637         "set the initial demux-decode delay", "seconds" },
3638     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3639         "override the options from ffserver", "" },
3640     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3641         "specify a file in which to print sdp information", "file" },
3642
3643     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3644         "A comma-separated list of bitstream filters", "bitstream_filters" },
3645     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3646         "deprecated", "audio bitstream_filters" },
3647     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3648         "deprecated", "video bitstream_filters" },
3649
3650     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3651         "set the audio options to the indicated preset", "preset" },
3652     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3653         "set the video options to the indicated preset", "preset" },
3654     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3655         "set the subtitle options to the indicated preset", "preset" },
3656     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3657         "set options from indicated preset file", "filename" },
3658
3659     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3660         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3661
3662     /* data codec support */
3663     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3664         "force data codec ('copy' to copy stream)", "codec" },
3665     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3666         "disable data" },
3667
3668 #if CONFIG_VAAPI
3669     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3670         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3671 #endif
3672
3673     { NULL, },
3674 };