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     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1399         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1400
1401     av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1402
1403     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1404     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1405         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1406
1407     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1408
1409     ost->source_index = source_index;
1410     if (source_index >= 0) {
1411         ost->sync_ist = input_streams[source_index];
1412         input_streams[source_index]->discard = 0;
1413         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1414     }
1415     ost->last_mux_dts = AV_NOPTS_VALUE;
1416
1417     return ost;
1418 }
1419
1420 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1421 {
1422     int i;
1423     const char *p = str;
1424     for (i = 0;; i++) {
1425         dest[i] = atoi(p);
1426         if (i == 63)
1427             break;
1428         p = strchr(p, ',');
1429         if (!p) {
1430             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1431             exit_program(1);
1432         }
1433         p++;
1434     }
1435 }
1436
1437 /* read file contents into a string */
1438 static uint8_t *read_file(const char *filename)
1439 {
1440     AVIOContext *pb      = NULL;
1441     AVIOContext *dyn_buf = NULL;
1442     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1443     uint8_t buf[1024], *str;
1444
1445     if (ret < 0) {
1446         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1447         return NULL;
1448     }
1449
1450     ret = avio_open_dyn_buf(&dyn_buf);
1451     if (ret < 0) {
1452         avio_closep(&pb);
1453         return NULL;
1454     }
1455     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1456         avio_write(dyn_buf, buf, ret);
1457     avio_w8(dyn_buf, 0);
1458     avio_closep(&pb);
1459
1460     ret = avio_close_dyn_buf(dyn_buf, &str);
1461     if (ret < 0)
1462         return NULL;
1463     return str;
1464 }
1465
1466 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1467                              OutputStream *ost)
1468 {
1469     AVStream *st = ost->st;
1470
1471     if (ost->filters_script && ost->filters) {
1472         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1473                "output stream #%d:%d.\n", nb_output_files, st->index);
1474         exit_program(1);
1475     }
1476
1477     if (ost->filters_script)
1478         return read_file(ost->filters_script);
1479     else if (ost->filters)
1480         return av_strdup(ost->filters);
1481
1482     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1483                      "null" : "anull");
1484 }
1485
1486 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1487                                      const OutputStream *ost, enum AVMediaType type)
1488 {
1489     if (ost->filters_script || ost->filters) {
1490         av_log(NULL, AV_LOG_ERROR,
1491                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1492                "Filtering and streamcopy cannot be used together.\n",
1493                ost->filters ? "Filtergraph" : "Filtergraph script",
1494                ost->filters ? ost->filters : ost->filters_script,
1495                av_get_media_type_string(type), ost->file_index, ost->index);
1496         exit_program(1);
1497     }
1498 }
1499
1500 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1501 {
1502     AVStream *st;
1503     OutputStream *ost;
1504     AVCodecContext *video_enc;
1505     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1506
1507     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1508     st  = ost->st;
1509     video_enc = ost->enc_ctx;
1510
1511     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1512     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1513         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1514         exit_program(1);
1515     }
1516     if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1517         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1518
1519     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1520     if (frame_aspect_ratio) {
1521         AVRational q;
1522         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1523             q.num <= 0 || q.den <= 0) {
1524             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1525             exit_program(1);
1526         }
1527         ost->frame_aspect_ratio = q;
1528     }
1529
1530     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1531     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1532
1533     if (!ost->stream_copy) {
1534         const char *p = NULL;
1535         char *frame_size = NULL;
1536         char *frame_pix_fmt = NULL;
1537         char *intra_matrix = NULL, *inter_matrix = NULL;
1538         char *chroma_intra_matrix = NULL;
1539         int do_pass = 0;
1540         int i;
1541
1542         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1543         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1544             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1545             exit_program(1);
1546         }
1547
1548         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1549         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1550         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1551             ost->keep_pix_fmt = 1;
1552             if (!*++frame_pix_fmt)
1553                 frame_pix_fmt = NULL;
1554         }
1555         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1556             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1557             exit_program(1);
1558         }
1559         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1560
1561         if (intra_only)
1562             video_enc->gop_size = 0;
1563         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1564         if (intra_matrix) {
1565             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1566                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1567                 exit_program(1);
1568             }
1569             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1570         }
1571         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1572         if (chroma_intra_matrix) {
1573             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1574             if (!p) {
1575                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1576                 exit_program(1);
1577             }
1578             av_codec_set_chroma_intra_matrix(video_enc, p);
1579             parse_matrix_coeffs(p, chroma_intra_matrix);
1580         }
1581         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1582         if (inter_matrix) {
1583             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1584                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1585                 exit_program(1);
1586             }
1587             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1588         }
1589
1590         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1591         for (i = 0; p; i++) {
1592             int start, end, q;
1593             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1594             if (e != 3) {
1595                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1596                 exit_program(1);
1597             }
1598             video_enc->rc_override =
1599                 av_realloc_array(video_enc->rc_override,
1600                                  i + 1, sizeof(RcOverride));
1601             if (!video_enc->rc_override) {
1602                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1603                 exit_program(1);
1604             }
1605             video_enc->rc_override[i].start_frame = start;
1606             video_enc->rc_override[i].end_frame   = end;
1607             if (q > 0) {
1608                 video_enc->rc_override[i].qscale         = q;
1609                 video_enc->rc_override[i].quality_factor = 1.0;
1610             }
1611             else {
1612                 video_enc->rc_override[i].qscale         = 0;
1613                 video_enc->rc_override[i].quality_factor = -q/100.0;
1614             }
1615             p = strchr(p, '/');
1616             if (p) p++;
1617         }
1618         video_enc->rc_override_count = i;
1619
1620         if (do_psnr)
1621             video_enc->flags|= AV_CODEC_FLAG_PSNR;
1622
1623         /* two pass mode */
1624         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1625         if (do_pass) {
1626             if (do_pass & 1) {
1627                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1628                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1629             }
1630             if (do_pass & 2) {
1631                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1632                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1633             }
1634         }
1635
1636         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1637         if (ost->logfile_prefix &&
1638             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1639             exit_program(1);
1640
1641         if (do_pass) {
1642             char logfilename[1024];
1643             FILE *f;
1644
1645             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1646                      ost->logfile_prefix ? ost->logfile_prefix :
1647                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1648                      i);
1649             if (!strcmp(ost->enc->name, "libx264")) {
1650                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1651             } else {
1652                 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1653                     char  *logbuffer = read_file(logfilename);
1654
1655                     if (!logbuffer) {
1656                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1657                                logfilename);
1658                         exit_program(1);
1659                     }
1660                     video_enc->stats_in = logbuffer;
1661                 }
1662                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1663                     f = av_fopen_utf8(logfilename, "wb");
1664                     if (!f) {
1665                         av_log(NULL, AV_LOG_FATAL,
1666                                "Cannot write log file '%s' for pass-1 encoding: %s\n",
1667                                logfilename, strerror(errno));
1668                         exit_program(1);
1669                     }
1670                     ost->logfile = f;
1671                 }
1672             }
1673         }
1674
1675         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1676         if (ost->forced_keyframes)
1677             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1678
1679         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1680
1681         ost->top_field_first = -1;
1682         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1683
1684
1685         ost->avfilter = get_ost_filters(o, oc, ost);
1686         if (!ost->avfilter)
1687             exit_program(1);
1688     } else {
1689         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1690     }
1691
1692     if (ost->stream_copy)
1693         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1694
1695     return ost;
1696 }
1697
1698 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1699 {
1700     int n;
1701     AVStream *st;
1702     OutputStream *ost;
1703     AVCodecContext *audio_enc;
1704
1705     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1706     st  = ost->st;
1707
1708     audio_enc = ost->enc_ctx;
1709     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1710
1711     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1712     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1713
1714     if (!ost->stream_copy) {
1715         char *sample_fmt = NULL;
1716
1717         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1718
1719         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1720         if (sample_fmt &&
1721             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1722             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1723             exit_program(1);
1724         }
1725
1726         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1727
1728         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1729         ost->apad = av_strdup(ost->apad);
1730
1731         ost->avfilter = get_ost_filters(o, oc, ost);
1732         if (!ost->avfilter)
1733             exit_program(1);
1734
1735         /* check for channel mapping for this audio stream */
1736         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1737             AudioChannelMap *map = &o->audio_channel_maps[n];
1738             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1739                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1740                 InputStream *ist;
1741
1742                 if (map->channel_idx == -1) {
1743                     ist = NULL;
1744                 } else if (ost->source_index < 0) {
1745                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1746                            ost->file_index, ost->st->index);
1747                     continue;
1748                 } else {
1749                     ist = input_streams[ost->source_index];
1750                 }
1751
1752                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1753                     if (av_reallocp_array(&ost->audio_channels_map,
1754                                           ost->audio_channels_mapped + 1,
1755                                           sizeof(*ost->audio_channels_map)
1756                                           ) < 0 )
1757                         exit_program(1);
1758
1759                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1760                 }
1761             }
1762         }
1763     }
1764
1765     if (ost->stream_copy)
1766         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1767
1768     return ost;
1769 }
1770
1771 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1772 {
1773     OutputStream *ost;
1774
1775     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1776     if (!ost->stream_copy) {
1777         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1778         exit_program(1);
1779     }
1780
1781     return ost;
1782 }
1783
1784 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1785 {
1786     OutputStream *ost;
1787
1788     ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1789     if (!ost->stream_copy) {
1790         av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1791         exit_program(1);
1792     }
1793
1794     return ost;
1795 }
1796
1797 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1798 {
1799     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1800     ost->stream_copy = 1;
1801     ost->finished    = 1;
1802     return ost;
1803 }
1804
1805 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1806 {
1807     AVStream *st;
1808     OutputStream *ost;
1809     AVCodecContext *subtitle_enc;
1810
1811     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1812     st  = ost->st;
1813     subtitle_enc = ost->enc_ctx;
1814
1815     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1816
1817     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1818
1819     if (!ost->stream_copy) {
1820         char *frame_size = NULL;
1821
1822         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1823         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1824             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1825             exit_program(1);
1826         }
1827     }
1828
1829     return ost;
1830 }
1831
1832 /* arg format is "output-stream-index:streamid-value". */
1833 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1834 {
1835     OptionsContext *o = optctx;
1836     int idx;
1837     char *p;
1838     char idx_str[16];
1839
1840     av_strlcpy(idx_str, arg, sizeof(idx_str));
1841     p = strchr(idx_str, ':');
1842     if (!p) {
1843         av_log(NULL, AV_LOG_FATAL,
1844                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1845                arg, opt);
1846         exit_program(1);
1847     }
1848     *p++ = '\0';
1849     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1850     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1851     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1852     return 0;
1853 }
1854
1855 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1856 {
1857     AVFormatContext *is = ifile->ctx;
1858     AVFormatContext *os = ofile->ctx;
1859     AVChapter **tmp;
1860     int i;
1861
1862     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1863     if (!tmp)
1864         return AVERROR(ENOMEM);
1865     os->chapters = tmp;
1866
1867     for (i = 0; i < is->nb_chapters; i++) {
1868         AVChapter *in_ch = is->chapters[i], *out_ch;
1869         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1870         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1871                                        AV_TIME_BASE_Q, in_ch->time_base);
1872         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1873                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1874
1875
1876         if (in_ch->end < ts_off)
1877             continue;
1878         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1879             break;
1880
1881         out_ch = av_mallocz(sizeof(AVChapter));
1882         if (!out_ch)
1883             return AVERROR(ENOMEM);
1884
1885         out_ch->id        = in_ch->id;
1886         out_ch->time_base = in_ch->time_base;
1887         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1888         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1889
1890         if (copy_metadata)
1891             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1892
1893         os->chapters[os->nb_chapters++] = out_ch;
1894     }
1895     return 0;
1896 }
1897
1898 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1899 {
1900     int i, err;
1901     AVFormatContext *ic = avformat_alloc_context();
1902
1903     ic->interrupt_callback = int_cb;
1904     err = avformat_open_input(&ic, filename, NULL, NULL);
1905     if (err < 0)
1906         return err;
1907     /* copy stream format */
1908     for(i=0;i<ic->nb_streams;i++) {
1909         AVStream *st;
1910         OutputStream *ost;
1911         AVCodec *codec;
1912         const char *enc_config;
1913
1914         codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1915         if (!codec) {
1916             av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1917             return AVERROR(EINVAL);
1918         }
1919         if (codec->type == AVMEDIA_TYPE_AUDIO)
1920             opt_audio_codec(o, "c:a", codec->name);
1921         else if (codec->type == AVMEDIA_TYPE_VIDEO)
1922             opt_video_codec(o, "c:v", codec->name);
1923         ost   = new_output_stream(o, s, codec->type, -1);
1924         st    = ost->st;
1925
1926         avcodec_get_context_defaults3(st->codec, codec);
1927         enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1928         if (enc_config) {
1929             AVDictionary *opts = NULL;
1930             av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1931             av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1932             av_dict_free(&opts);
1933         }
1934
1935         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1936             choose_sample_fmt(st, codec);
1937         else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1938             choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1939         avcodec_copy_context(ost->enc_ctx, st->codec);
1940         if (enc_config)
1941             av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1942     }
1943
1944     avformat_close_input(&ic);
1945     return err;
1946 }
1947
1948 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1949                                AVFormatContext *oc)
1950 {
1951     OutputStream *ost;
1952
1953     switch (ofilter->type) {
1954     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1955     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1956     default:
1957         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1958                "currently.\n");
1959         exit_program(1);
1960     }
1961
1962     ost->source_index = -1;
1963     ost->filter       = ofilter;
1964
1965     ofilter->ost      = ost;
1966
1967     if (ost->stream_copy) {
1968         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1969                "which is fed from a complex filtergraph. Filtering and streamcopy "
1970                "cannot be used together.\n", ost->file_index, ost->index);
1971         exit_program(1);
1972     }
1973
1974     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1975         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1976         av_log(NULL, AV_LOG_ERROR,
1977                "%s '%s' was specified through the %s option "
1978                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1979                "%s and -filter_complex cannot be used together for the same stream.\n",
1980                ost->filters ? "Filtergraph" : "Filtergraph script",
1981                ost->filters ? ost->filters : ost->filters_script,
1982                opt, ost->file_index, ost->index, opt);
1983         exit_program(1);
1984     }
1985
1986     avfilter_inout_free(&ofilter->out_tmp);
1987 }
1988
1989 static int init_complex_filters(void)
1990 {
1991     int i, ret = 0;
1992
1993     for (i = 0; i < nb_filtergraphs; i++) {
1994         ret = init_complex_filtergraph(filtergraphs[i]);
1995         if (ret < 0)
1996             return ret;
1997     }
1998     return 0;
1999 }
2000
2001 static int configure_complex_filters(void)
2002 {
2003     int i, ret = 0;
2004
2005     for (i = 0; i < nb_filtergraphs; i++)
2006         if (!filtergraph_is_simple(filtergraphs[i]) &&
2007             (ret = configure_filtergraph(filtergraphs[i])) < 0)
2008             return ret;
2009     return 0;
2010 }
2011
2012 static int open_output_file(OptionsContext *o, const char *filename)
2013 {
2014     AVFormatContext *oc;
2015     int i, j, err;
2016     AVOutputFormat *file_oformat;
2017     OutputFile *of;
2018     OutputStream *ost;
2019     InputStream  *ist;
2020     AVDictionary *unused_opts = NULL;
2021     AVDictionaryEntry *e = NULL;
2022
2023
2024     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2025         o->stop_time = INT64_MAX;
2026         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2027     }
2028
2029     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2030         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2031         if (o->stop_time <= start_time) {
2032             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2033             exit_program(1);
2034         } else {
2035             o->recording_time = o->stop_time - start_time;
2036         }
2037     }
2038
2039     GROW_ARRAY(output_files, nb_output_files);
2040     of = av_mallocz(sizeof(*of));
2041     if (!of)
2042         exit_program(1);
2043     output_files[nb_output_files - 1] = of;
2044
2045     of->ost_index      = nb_output_streams;
2046     of->recording_time = o->recording_time;
2047     of->start_time     = o->start_time;
2048     of->limit_filesize = o->limit_filesize;
2049     of->shortest       = o->shortest;
2050     av_dict_copy(&of->opts, o->g->format_opts, 0);
2051
2052     if (!strcmp(filename, "-"))
2053         filename = "pipe:";
2054
2055     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2056     if (!oc) {
2057         print_error(filename, err);
2058         exit_program(1);
2059     }
2060
2061     of->ctx = oc;
2062     if (o->recording_time != INT64_MAX)
2063         oc->duration = o->recording_time;
2064
2065     file_oformat= oc->oformat;
2066     oc->interrupt_callback = int_cb;
2067
2068     /* create streams for all unlabeled output pads */
2069     for (i = 0; i < nb_filtergraphs; i++) {
2070         FilterGraph *fg = filtergraphs[i];
2071         for (j = 0; j < fg->nb_outputs; j++) {
2072             OutputFilter *ofilter = fg->outputs[j];
2073
2074             if (!ofilter->out_tmp || ofilter->out_tmp->name)
2075                 continue;
2076
2077             switch (ofilter->type) {
2078             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2079             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2080             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2081             }
2082             init_output_filter(ofilter, o, oc);
2083         }
2084     }
2085
2086     /* ffserver seeking with date=... needs a date reference */
2087     if (!strcmp(file_oformat->name, "ffm") &&
2088         av_strstart(filename, "http:", NULL)) {
2089         int err = parse_option(o, "metadata", "creation_time=now", options);
2090         if (err < 0) {
2091             print_error(filename, err);
2092             exit_program(1);
2093         }
2094     }
2095
2096     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2097         av_strstart(filename, "http:", NULL)) {
2098         int j;
2099         /* special case for files sent to ffserver: we get the stream
2100            parameters from ffserver */
2101         int err = read_ffserver_streams(o, oc, filename);
2102         if (err < 0) {
2103             print_error(filename, err);
2104             exit_program(1);
2105         }
2106         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2107             ost = output_streams[j];
2108             for (i = 0; i < nb_input_streams; i++) {
2109                 ist = input_streams[i];
2110                 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2111                     ost->sync_ist= ist;
2112                     ost->source_index= i;
2113                     if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2114                     if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2115                     ist->discard = 0;
2116                     ist->st->discard = ist->user_set_discard;
2117                     break;
2118                 }
2119             }
2120             if(!ost->sync_ist){
2121                 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));
2122                 exit_program(1);
2123             }
2124         }
2125     } else if (!o->nb_stream_maps) {
2126         char *subtitle_codec_name = NULL;
2127         /* pick the "best" stream of each type */
2128
2129         /* video: highest resolution */
2130         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2131             int area = 0, idx = -1;
2132             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2133             for (i = 0; i < nb_input_streams; i++) {
2134                 int new_area;
2135                 ist = input_streams[i];
2136                 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2137                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2138                     new_area = 1;
2139                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2140                     new_area > area) {
2141                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2142                         continue;
2143                     area = new_area;
2144                     idx = i;
2145                 }
2146             }
2147             if (idx >= 0)
2148                 new_video_stream(o, oc, idx);
2149         }
2150
2151         /* audio: most channels */
2152         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2153             int best_score = 0, idx = -1;
2154             for (i = 0; i < nb_input_streams; i++) {
2155                 int score;
2156                 ist = input_streams[i];
2157                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2158                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2159                     score > best_score) {
2160                     best_score = score;
2161                     idx = i;
2162                 }
2163             }
2164             if (idx >= 0)
2165                 new_audio_stream(o, oc, idx);
2166         }
2167
2168         /* subtitles: pick first */
2169         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2170         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2171             for (i = 0; i < nb_input_streams; i++)
2172                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2173                     AVCodecDescriptor const *input_descriptor =
2174                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2175                     AVCodecDescriptor const *output_descriptor = NULL;
2176                     AVCodec const *output_codec =
2177                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2178                     int input_props = 0, output_props = 0;
2179                     if (output_codec)
2180                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2181                     if (input_descriptor)
2182                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2183                     if (output_descriptor)
2184                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2185                     if (subtitle_codec_name ||
2186                         input_props & output_props ||
2187                         // Map dvb teletext which has neither property to any output subtitle encoder
2188                         input_descriptor && output_descriptor &&
2189                         (!input_descriptor->props ||
2190                          !output_descriptor->props)) {
2191                         new_subtitle_stream(o, oc, i);
2192                         break;
2193                     }
2194                 }
2195         }
2196         /* Data only if codec id match */
2197         if (!o->data_disable ) {
2198             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2199             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2200                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2201                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2202                     new_data_stream(o, oc, i);
2203             }
2204         }
2205     } else {
2206         for (i = 0; i < o->nb_stream_maps; i++) {
2207             StreamMap *map = &o->stream_maps[i];
2208
2209             if (map->disabled)
2210                 continue;
2211
2212             if (map->linklabel) {
2213                 FilterGraph *fg;
2214                 OutputFilter *ofilter = NULL;
2215                 int j, k;
2216
2217                 for (j = 0; j < nb_filtergraphs; j++) {
2218                     fg = filtergraphs[j];
2219                     for (k = 0; k < fg->nb_outputs; k++) {
2220                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2221                         if (out && !strcmp(out->name, map->linklabel)) {
2222                             ofilter = fg->outputs[k];
2223                             goto loop_end;
2224                         }
2225                     }
2226                 }
2227 loop_end:
2228                 if (!ofilter) {
2229                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2230                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2231                     exit_program(1);
2232                 }
2233                 init_output_filter(ofilter, o, oc);
2234             } else {
2235                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2236
2237                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2238                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2239                     continue;
2240                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2241                     continue;
2242                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2243                     continue;
2244                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2245                     continue;
2246
2247                 ost = NULL;
2248                 switch (ist->st->codecpar->codec_type) {
2249                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2250                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2251                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2252                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2253                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2254                 case AVMEDIA_TYPE_UNKNOWN:
2255                     if (copy_unknown_streams) {
2256                         ost = new_unknown_stream   (o, oc, src_idx);
2257                         break;
2258                     }
2259                 default:
2260                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2261                            "Cannot map stream #%d:%d - unsupported type.\n",
2262                            map->file_index, map->stream_index);
2263                     if (!ignore_unknown_streams) {
2264                         av_log(NULL, AV_LOG_FATAL,
2265                                "If you want unsupported types ignored instead "
2266                                "of failing, please use the -ignore_unknown option\n"
2267                                "If you want them copied, please use -copy_unknown\n");
2268                         exit_program(1);
2269                     }
2270                 }
2271                 if (ost)
2272                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2273                                                   + map->sync_stream_index];
2274             }
2275         }
2276     }
2277
2278     /* handle attached files */
2279     for (i = 0; i < o->nb_attachments; i++) {
2280         AVIOContext *pb;
2281         uint8_t *attachment;
2282         const char *p;
2283         int64_t len;
2284
2285         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2286             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2287                    o->attachments[i]);
2288             exit_program(1);
2289         }
2290         if ((len = avio_size(pb)) <= 0) {
2291             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2292                    o->attachments[i]);
2293             exit_program(1);
2294         }
2295         if (!(attachment = av_malloc(len))) {
2296             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2297                    o->attachments[i]);
2298             exit_program(1);
2299         }
2300         avio_read(pb, attachment, len);
2301
2302         ost = new_attachment_stream(o, oc, -1);
2303         ost->stream_copy               = 0;
2304         ost->attachment_filename       = o->attachments[i];
2305         ost->st->codecpar->extradata      = attachment;
2306         ost->st->codecpar->extradata_size = len;
2307
2308         p = strrchr(o->attachments[i], '/');
2309         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2310         avio_closep(&pb);
2311     }
2312
2313 #if FF_API_LAVF_AVCTX
2314     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2315         AVDictionaryEntry *e;
2316         ost = output_streams[i];
2317
2318         if ((ost->stream_copy || ost->attachment_filename)
2319             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2320             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2321             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2322                 exit_program(1);
2323     }
2324 #endif
2325
2326     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2327         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2328         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2329         exit_program(1);
2330     }
2331
2332     /* check if all codec options have been used */
2333     unused_opts = strip_specifiers(o->g->codec_opts);
2334     for (i = of->ost_index; i < nb_output_streams; i++) {
2335         e = NULL;
2336         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2337                                 AV_DICT_IGNORE_SUFFIX)))
2338             av_dict_set(&unused_opts, e->key, NULL, 0);
2339     }
2340
2341     e = NULL;
2342     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2343         const AVClass *class = avcodec_get_class();
2344         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2345                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2346         const AVClass *fclass = avformat_get_class();
2347         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2348                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2349         if (!option || foption)
2350             continue;
2351
2352
2353         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2354             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2355                    "output file #%d (%s) is not an encoding option.\n", e->key,
2356                    option->help ? option->help : "", nb_output_files - 1,
2357                    filename);
2358             exit_program(1);
2359         }
2360
2361         // gop_timecode is injected by generic code but not always used
2362         if (!strcmp(e->key, "gop_timecode"))
2363             continue;
2364
2365         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2366                "output file #%d (%s) has not been used for any stream. The most "
2367                "likely reason is either wrong type (e.g. a video option with "
2368                "no video streams) or that it is a private option of some encoder "
2369                "which was not actually used for any stream.\n", e->key,
2370                option->help ? option->help : "", nb_output_files - 1, filename);
2371     }
2372     av_dict_free(&unused_opts);
2373
2374     /* set the decoding_needed flags and create simple filtergraphs */
2375     for (i = of->ost_index; i < nb_output_streams; i++) {
2376         OutputStream *ost = output_streams[i];
2377
2378         if (ost->encoding_needed && ost->source_index >= 0) {
2379             InputStream *ist = input_streams[ost->source_index];
2380             ist->decoding_needed |= DECODING_FOR_OST;
2381
2382             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2383                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2384                 err = init_simple_filtergraph(ist, ost);
2385                 if (err < 0) {
2386                     av_log(NULL, AV_LOG_ERROR,
2387                            "Error initializing a simple filtergraph between streams "
2388                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2389                            nb_output_files - 1, ost->st->index);
2390                     exit_program(1);
2391                 }
2392             }
2393         }
2394     }
2395
2396     /* check filename in case of an image number is expected */
2397     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2398         if (!av_filename_number_test(oc->filename)) {
2399             print_error(oc->filename, AVERROR(EINVAL));
2400             exit_program(1);
2401         }
2402     }
2403
2404     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2405         av_log(NULL, AV_LOG_ERROR,
2406                "No input streams but output needs an input stream\n");
2407         exit_program(1);
2408     }
2409
2410     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2411         /* test if it already exists to avoid losing precious files */
2412         assert_file_overwrite(filename);
2413
2414         /* open the file */
2415         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2416                               &oc->interrupt_callback,
2417                               &of->opts)) < 0) {
2418             print_error(filename, err);
2419             exit_program(1);
2420         }
2421     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2422         assert_file_overwrite(filename);
2423
2424     if (o->mux_preload) {
2425         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2426     }
2427     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2428
2429     /* copy metadata */
2430     for (i = 0; i < o->nb_metadata_map; i++) {
2431         char *p;
2432         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2433
2434         if (in_file_index >= nb_input_files) {
2435             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2436             exit_program(1);
2437         }
2438         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2439                       in_file_index >= 0 ?
2440                       input_files[in_file_index]->ctx : NULL, o);
2441     }
2442
2443     /* copy chapters */
2444     if (o->chapters_input_file >= nb_input_files) {
2445         if (o->chapters_input_file == INT_MAX) {
2446             /* copy chapters from the first input file that has them*/
2447             o->chapters_input_file = -1;
2448             for (i = 0; i < nb_input_files; i++)
2449                 if (input_files[i]->ctx->nb_chapters) {
2450                     o->chapters_input_file = i;
2451                     break;
2452                 }
2453         } else {
2454             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2455                    o->chapters_input_file);
2456             exit_program(1);
2457         }
2458     }
2459     if (o->chapters_input_file >= 0)
2460         copy_chapters(input_files[o->chapters_input_file], of,
2461                       !o->metadata_chapters_manual);
2462
2463     /* copy global metadata by default */
2464     if (!o->metadata_global_manual && nb_input_files){
2465         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2466                      AV_DICT_DONT_OVERWRITE);
2467         if(o->recording_time != INT64_MAX)
2468             av_dict_set(&oc->metadata, "duration", NULL, 0);
2469         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2470     }
2471     if (!o->metadata_streams_manual)
2472         for (i = of->ost_index; i < nb_output_streams; i++) {
2473             InputStream *ist;
2474             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2475                 continue;
2476             ist = input_streams[output_streams[i]->source_index];
2477             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2478             if (!output_streams[i]->stream_copy) {
2479                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2480                 if (ist->autorotate)
2481                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2482             }
2483         }
2484
2485     /* process manually set programs */
2486     for (i = 0; i < o->nb_program; i++) {
2487         const char *p = o->program[i].u.str;
2488         int progid = i+1;
2489         AVProgram *program;
2490
2491         while(*p) {
2492             const char *p2 = av_get_token(&p, ":");
2493             const char *to_dealloc = p2;
2494             char *key;
2495             if (!p2)
2496                 break;
2497
2498             if(*p) p++;
2499
2500             key = av_get_token(&p2, "=");
2501             if (!key || !*p2) {
2502                 av_freep(&to_dealloc);
2503                 av_freep(&key);
2504                 break;
2505             }
2506             p2++;
2507
2508             if (!strcmp(key, "program_num"))
2509                 progid = strtol(p2, NULL, 0);
2510             av_freep(&to_dealloc);
2511             av_freep(&key);
2512         }
2513
2514         program = av_new_program(oc, progid);
2515
2516         p = o->program[i].u.str;
2517         while(*p) {
2518             const char *p2 = av_get_token(&p, ":");
2519             const char *to_dealloc = p2;
2520             char *key;
2521             if (!p2)
2522                 break;
2523             if(*p) p++;
2524
2525             key = av_get_token(&p2, "=");
2526             if (!key) {
2527                 av_log(NULL, AV_LOG_FATAL,
2528                        "No '=' character in program string %s.\n",
2529                        p2);
2530                 exit_program(1);
2531             }
2532             if (!*p2)
2533                 exit_program(1);
2534             p2++;
2535
2536             if (!strcmp(key, "title")) {
2537                 av_dict_set(&program->metadata, "title", p2, 0);
2538             } else if (!strcmp(key, "program_num")) {
2539             } else if (!strcmp(key, "st")) {
2540                 int st_num = strtol(p2, NULL, 0);
2541                 av_program_add_stream_index(oc, progid, st_num);
2542             } else {
2543                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2544                 exit_program(1);
2545             }
2546             av_freep(&to_dealloc);
2547             av_freep(&key);
2548         }
2549     }
2550
2551     /* process manually set metadata */
2552     for (i = 0; i < o->nb_metadata; i++) {
2553         AVDictionary **m;
2554         char type, *val;
2555         const char *stream_spec;
2556         int index = 0, j, ret = 0;
2557
2558         val = strchr(o->metadata[i].u.str, '=');
2559         if (!val) {
2560             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2561                    o->metadata[i].u.str);
2562             exit_program(1);
2563         }
2564         *val++ = 0;
2565
2566         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2567         if (type == 's') {
2568             for (j = 0; j < oc->nb_streams; j++) {
2569                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2570                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2571                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2572                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2573                         ost->rotate_overridden = 1;
2574                     }
2575                 } else if (ret < 0)
2576                     exit_program(1);
2577             }
2578         }
2579         else {
2580             switch (type) {
2581             case 'g':
2582                 m = &oc->metadata;
2583                 break;
2584             case 'c':
2585                 if (index < 0 || index >= oc->nb_chapters) {
2586                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2587                     exit_program(1);
2588                 }
2589                 m = &oc->chapters[index]->metadata;
2590                 break;
2591             case 'p':
2592                 if (index < 0 || index >= oc->nb_programs) {
2593                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2594                     exit_program(1);
2595                 }
2596                 m = &oc->programs[index]->metadata;
2597                 break;
2598             default:
2599                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2600                 exit_program(1);
2601             }
2602             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2603         }
2604     }
2605
2606     return 0;
2607 }
2608
2609 static int opt_target(void *optctx, const char *opt, const char *arg)
2610 {
2611     OptionsContext *o = optctx;
2612     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2613     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2614
2615     if (!strncmp(arg, "pal-", 4)) {
2616         norm = PAL;
2617         arg += 4;
2618     } else if (!strncmp(arg, "ntsc-", 5)) {
2619         norm = NTSC;
2620         arg += 5;
2621     } else if (!strncmp(arg, "film-", 5)) {
2622         norm = FILM;
2623         arg += 5;
2624     } else {
2625         /* Try to determine PAL/NTSC by peeking in the input files */
2626         if (nb_input_files) {
2627             int i, j, fr;
2628             for (j = 0; j < nb_input_files; j++) {
2629                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2630                     AVStream *st = input_files[j]->ctx->streams[i];
2631                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2632                         continue;
2633                     fr = st->time_base.den * 1000 / st->time_base.num;
2634                     if (fr == 25000) {
2635                         norm = PAL;
2636                         break;
2637                     } else if ((fr == 29970) || (fr == 23976)) {
2638                         norm = NTSC;
2639                         break;
2640                     }
2641                 }
2642                 if (norm != UNKNOWN)
2643                     break;
2644             }
2645         }
2646         if (norm != UNKNOWN)
2647             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2648     }
2649
2650     if (norm == UNKNOWN) {
2651         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2652         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2653         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2654         exit_program(1);
2655     }
2656
2657     if (!strcmp(arg, "vcd")) {
2658         opt_video_codec(o, "c:v", "mpeg1video");
2659         opt_audio_codec(o, "c:a", "mp2");
2660         parse_option(o, "f", "vcd", options);
2661
2662         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2663         parse_option(o, "r", frame_rates[norm], options);
2664         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2665
2666         opt_default(NULL, "b:v", "1150000");
2667         opt_default(NULL, "maxrate:v", "1150000");
2668         opt_default(NULL, "minrate:v", "1150000");
2669         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2670
2671         opt_default(NULL, "b:a", "224000");
2672         parse_option(o, "ar", "44100", options);
2673         parse_option(o, "ac", "2", options);
2674
2675         opt_default(NULL, "packetsize", "2324");
2676         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2677
2678         /* We have to offset the PTS, so that it is consistent with the SCR.
2679            SCR starts at 36000, but the first two packs contain only padding
2680            and the first pack from the other stream, respectively, may also have
2681            been written before.
2682            So the real data starts at SCR 36000+3*1200. */
2683         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2684     } else if (!strcmp(arg, "svcd")) {
2685
2686         opt_video_codec(o, "c:v", "mpeg2video");
2687         opt_audio_codec(o, "c:a", "mp2");
2688         parse_option(o, "f", "svcd", options);
2689
2690         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2691         parse_option(o, "r", frame_rates[norm], options);
2692         parse_option(o, "pix_fmt", "yuv420p", options);
2693         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2694
2695         opt_default(NULL, "b:v", "2040000");
2696         opt_default(NULL, "maxrate:v", "2516000");
2697         opt_default(NULL, "minrate:v", "0"); // 1145000;
2698         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2699         opt_default(NULL, "scan_offset", "1");
2700
2701         opt_default(NULL, "b:a", "224000");
2702         parse_option(o, "ar", "44100", options);
2703
2704         opt_default(NULL, "packetsize", "2324");
2705
2706     } else if (!strcmp(arg, "dvd")) {
2707
2708         opt_video_codec(o, "c:v", "mpeg2video");
2709         opt_audio_codec(o, "c:a", "ac3");
2710         parse_option(o, "f", "dvd", options);
2711
2712         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2713         parse_option(o, "r", frame_rates[norm], options);
2714         parse_option(o, "pix_fmt", "yuv420p", options);
2715         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2716
2717         opt_default(NULL, "b:v", "6000000");
2718         opt_default(NULL, "maxrate:v", "9000000");
2719         opt_default(NULL, "minrate:v", "0"); // 1500000;
2720         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2721
2722         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2723         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2724
2725         opt_default(NULL, "b:a", "448000");
2726         parse_option(o, "ar", "48000", options);
2727
2728     } else if (!strncmp(arg, "dv", 2)) {
2729
2730         parse_option(o, "f", "dv", options);
2731
2732         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2733         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2734                           norm == PAL ? "yuv420p" : "yuv411p", options);
2735         parse_option(o, "r", frame_rates[norm], options);
2736
2737         parse_option(o, "ar", "48000", options);
2738         parse_option(o, "ac", "2", options);
2739
2740     } else {
2741         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2742         return AVERROR(EINVAL);
2743     }
2744
2745     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2746     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2747
2748     return 0;
2749 }
2750
2751 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2752 {
2753     av_free (vstats_filename);
2754     vstats_filename = av_strdup (arg);
2755     return 0;
2756 }
2757
2758 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2759 {
2760     char filename[40];
2761     time_t today2 = time(NULL);
2762     struct tm *today = localtime(&today2);
2763
2764     if (!today) { // maybe tomorrow
2765         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2766         exit_program(1);
2767     }
2768
2769     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2770              today->tm_sec);
2771     return opt_vstats_file(NULL, opt, filename);
2772 }
2773
2774 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2775 {
2776     OptionsContext *o = optctx;
2777     return parse_option(o, "frames:v", arg, options);
2778 }
2779
2780 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2781 {
2782     OptionsContext *o = optctx;
2783     return parse_option(o, "frames:a", arg, options);
2784 }
2785
2786 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2787 {
2788     OptionsContext *o = optctx;
2789     return parse_option(o, "frames:d", arg, options);
2790 }
2791
2792 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2793 {
2794     int ret;
2795     AVDictionary *cbak = codec_opts;
2796     AVDictionary *fbak = format_opts;
2797     codec_opts = NULL;
2798     format_opts = NULL;
2799
2800     ret = opt_default(NULL, opt, arg);
2801
2802     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2803     av_dict_copy(&o->g->format_opts, format_opts, 0);
2804     av_dict_free(&codec_opts);
2805     av_dict_free(&format_opts);
2806     codec_opts = cbak;
2807     format_opts = fbak;
2808
2809     return ret;
2810 }
2811
2812 static int opt_preset(void *optctx, const char *opt, const char *arg)
2813 {
2814     OptionsContext *o = optctx;
2815     FILE *f=NULL;
2816     char filename[1000], line[1000], tmp_line[1000];
2817     const char *codec_name = NULL;
2818
2819     tmp_line[0] = *opt;
2820     tmp_line[1] = 0;
2821     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2822
2823     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2824         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2825             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2826         }else
2827             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2828         exit_program(1);
2829     }
2830
2831     while (fgets(line, sizeof(line), f)) {
2832         char *key = tmp_line, *value, *endptr;
2833
2834         if (strcspn(line, "#\n\r") == 0)
2835             continue;
2836         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2837         if (!av_strtok(key,   "=",    &value) ||
2838             !av_strtok(value, "\r\n", &endptr)) {
2839             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2840             exit_program(1);
2841         }
2842         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2843
2844         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2845         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2846         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2847         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2848         else if (opt_default_new(o, key, value) < 0) {
2849             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2850                    filename, line, key, value);
2851             exit_program(1);
2852         }
2853     }
2854
2855     fclose(f);
2856
2857     return 0;
2858 }
2859
2860 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2861 {
2862     OptionsContext *o = optctx;
2863     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2864     int ret = parse_option(o, s, arg, options);
2865     av_free(s);
2866     return ret;
2867 }
2868
2869 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2870 {
2871     OptionsContext *o = optctx;
2872
2873     if(!strcmp(opt, "ab")){
2874         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2875         return 0;
2876     } else if(!strcmp(opt, "b")){
2877         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2878         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2879         return 0;
2880     }
2881     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2882     return 0;
2883 }
2884
2885 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2886 {
2887     OptionsContext *o = optctx;
2888     char *s;
2889     int ret;
2890     if(!strcmp(opt, "qscale")){
2891         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2892         return parse_option(o, "q:v", arg, options);
2893     }
2894     s = av_asprintf("q%s", opt + 6);
2895     ret = parse_option(o, s, arg, options);
2896     av_free(s);
2897     return ret;
2898 }
2899
2900 static int opt_profile(void *optctx, const char *opt, const char *arg)
2901 {
2902     OptionsContext *o = optctx;
2903     if(!strcmp(opt, "profile")){
2904         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2905         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2906         return 0;
2907     }
2908     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2909     return 0;
2910 }
2911
2912 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2913 {
2914     OptionsContext *o = optctx;
2915     return parse_option(o, "filter:v", arg, options);
2916 }
2917
2918 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2919 {
2920     OptionsContext *o = optctx;
2921     return parse_option(o, "filter:a", arg, options);
2922 }
2923
2924 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2925 {
2926     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2927     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2928     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2929     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2930
2931     if (video_sync_method == VSYNC_AUTO)
2932         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2933     return 0;
2934 }
2935
2936 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2937 {
2938     OptionsContext *o = optctx;
2939     char *tcr = av_asprintf("timecode=%s", arg);
2940     int ret = parse_option(o, "metadata:g", tcr, options);
2941     if (ret >= 0)
2942         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2943     av_free(tcr);
2944     return 0;
2945 }
2946
2947 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2948 {
2949     OptionsContext *o = optctx;
2950     char layout_str[32];
2951     char *stream_str;
2952     char *ac_str;
2953     int ret, channels, ac_str_size;
2954     uint64_t layout;
2955
2956     layout = av_get_channel_layout(arg);
2957     if (!layout) {
2958         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2959         return AVERROR(EINVAL);
2960     }
2961     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2962     ret = opt_default_new(o, opt, layout_str);
2963     if (ret < 0)
2964         return ret;
2965
2966     /* set 'ac' option based on channel layout */
2967     channels = av_get_channel_layout_nb_channels(layout);
2968     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2969     stream_str = strchr(opt, ':');
2970     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2971     ac_str = av_mallocz(ac_str_size);
2972     if (!ac_str)
2973         return AVERROR(ENOMEM);
2974     av_strlcpy(ac_str, "ac", 3);
2975     if (stream_str)
2976         av_strlcat(ac_str, stream_str, ac_str_size);
2977     ret = parse_option(o, ac_str, layout_str, options);
2978     av_free(ac_str);
2979
2980     return ret;
2981 }
2982
2983 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2984 {
2985     OptionsContext *o = optctx;
2986     return parse_option(o, "q:a", arg, options);
2987 }
2988
2989 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2990 {
2991     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2992     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2993         return AVERROR(ENOMEM);
2994     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2995     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2996     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2997         return AVERROR(ENOMEM);
2998
2999     input_stream_potentially_available = 1;
3000
3001     return 0;
3002 }
3003
3004 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3005 {
3006     uint8_t *graph_desc = read_file(arg);
3007     if (!graph_desc)
3008         return AVERROR(EINVAL);
3009
3010     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3011     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3012         return AVERROR(ENOMEM);
3013     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3014     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3015
3016     input_stream_potentially_available = 1;
3017
3018     return 0;
3019 }
3020
3021 void show_help_default(const char *opt, const char *arg)
3022 {
3023     /* per-file options have at least one of those set */
3024     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3025     int show_advanced = 0, show_avoptions = 0;
3026
3027     if (opt && *opt) {
3028         if (!strcmp(opt, "long"))
3029             show_advanced = 1;
3030         else if (!strcmp(opt, "full"))
3031             show_advanced = show_avoptions = 1;
3032         else
3033             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3034     }
3035
3036     show_usage();
3037
3038     printf("Getting help:\n"
3039            "    -h      -- print basic options\n"
3040            "    -h long -- print more options\n"
3041            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3042            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3043            "    See man %s for detailed description of the options.\n"
3044            "\n", program_name);
3045
3046     show_help_options(options, "Print help / information / capabilities:",
3047                       OPT_EXIT, 0, 0);
3048
3049     show_help_options(options, "Global options (affect whole program "
3050                       "instead of just one file:",
3051                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3052     if (show_advanced)
3053         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3054                           per_file | OPT_EXIT, 0);
3055
3056     show_help_options(options, "Per-file main options:", 0,
3057                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3058                       OPT_EXIT, per_file);
3059     if (show_advanced)
3060         show_help_options(options, "Advanced per-file options:",
3061                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3062
3063     show_help_options(options, "Video options:",
3064                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3065     if (show_advanced)
3066         show_help_options(options, "Advanced Video options:",
3067                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3068
3069     show_help_options(options, "Audio options:",
3070                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3071     if (show_advanced)
3072         show_help_options(options, "Advanced Audio options:",
3073                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3074     show_help_options(options, "Subtitle options:",
3075                       OPT_SUBTITLE, 0, 0);
3076     printf("\n");
3077
3078     if (show_avoptions) {
3079         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3080         show_help_children(avcodec_get_class(), flags);
3081         show_help_children(avformat_get_class(), flags);
3082 #if CONFIG_SWSCALE
3083         show_help_children(sws_get_class(), flags);
3084 #endif
3085         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3086         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3087     }
3088 }
3089
3090 void show_usage(void)
3091 {
3092     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3093     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3094     av_log(NULL, AV_LOG_INFO, "\n");
3095 }
3096
3097 enum OptGroup {
3098     GROUP_OUTFILE,
3099     GROUP_INFILE,
3100 };
3101
3102 static const OptionGroupDef groups[] = {
3103     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
3104     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
3105 };
3106
3107 static int open_files(OptionGroupList *l, const char *inout,
3108                       int (*open_file)(OptionsContext*, const char*))
3109 {
3110     int i, ret;
3111
3112     for (i = 0; i < l->nb_groups; i++) {
3113         OptionGroup *g = &l->groups[i];
3114         OptionsContext o;
3115
3116         init_options(&o);
3117         o.g = g;
3118
3119         ret = parse_optgroup(&o, g);
3120         if (ret < 0) {
3121             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3122                    "%s.\n", inout, g->arg);
3123             return ret;
3124         }
3125
3126         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3127         ret = open_file(&o, g->arg);
3128         uninit_options(&o);
3129         if (ret < 0) {
3130             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3131                    inout, g->arg);
3132             return ret;
3133         }
3134         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3135     }
3136
3137     return 0;
3138 }
3139
3140 int ffmpeg_parse_options(int argc, char **argv)
3141 {
3142     OptionParseContext octx;
3143     uint8_t error[128];
3144     int ret;
3145
3146     memset(&octx, 0, sizeof(octx));
3147
3148     /* split the commandline into an internal representation */
3149     ret = split_commandline(&octx, argc, argv, options, groups,
3150                             FF_ARRAY_ELEMS(groups));
3151     if (ret < 0) {
3152         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3153         goto fail;
3154     }
3155
3156     /* apply global options */
3157     ret = parse_optgroup(NULL, &octx.global_opts);
3158     if (ret < 0) {
3159         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3160         goto fail;
3161     }
3162
3163     /* configure terminal and setup signal handlers */
3164     term_init();
3165
3166     /* open input files */
3167     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3168     if (ret < 0) {
3169         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3170         goto fail;
3171     }
3172
3173     /* create the complex filtergraphs */
3174     ret = init_complex_filters();
3175     if (ret < 0) {
3176         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3177         goto fail;
3178     }
3179
3180     /* open output files */
3181     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3182     if (ret < 0) {
3183         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3184         goto fail;
3185     }
3186
3187     /* configure the complex filtergraphs */
3188     ret = configure_complex_filters();
3189     if (ret < 0) {
3190         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3191         goto fail;
3192     }
3193
3194 fail:
3195     uninit_parse_context(&octx);
3196     if (ret < 0) {
3197         av_strerror(ret, error, sizeof(error));
3198         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3199     }
3200     return ret;
3201 }
3202
3203 static int opt_progress(void *optctx, const char *opt, const char *arg)
3204 {
3205     AVIOContext *avio = NULL;
3206     int ret;
3207
3208     if (!strcmp(arg, "-"))
3209         arg = "pipe:";
3210     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3211     if (ret < 0) {
3212         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3213                arg, av_err2str(ret));
3214         return ret;
3215     }
3216     progress_avio = avio;
3217     return 0;
3218 }
3219
3220 #define OFFSET(x) offsetof(OptionsContext, x)
3221 const OptionDef options[] = {
3222     /* main options */
3223 #include "cmdutils_common_opts.h"
3224     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3225                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3226         "force format", "fmt" },
3227     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3228         "overwrite output files" },
3229     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3230         "never overwrite output files" },
3231     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3232         "Ignore unknown stream types" },
3233     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3234         "Copy unknown stream types" },
3235     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3236                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3237         "codec name", "codec" },
3238     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3239                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3240         "codec name", "codec" },
3241     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3242                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3243         "preset name", "preset" },
3244     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3245                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3246         "set input stream mapping",
3247         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3248     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3249         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3250     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3251                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3252         "set metadata information of outfile from infile",
3253         "outfile[,metadata]:infile[,metadata]" },
3254     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3255                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3256         "set chapters mapping", "input_file_index" },
3257     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3258                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3259         "record or transcode \"duration\" seconds of audio/video",
3260         "duration" },
3261     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3262         "record or transcode stop time", "time_stop" },
3263     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3264         "set the limit file size in bytes", "limit_size" },
3265     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3266                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3267         "set the start time offset", "time_off" },
3268     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3269                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3270         "set the start time offset relative to EOF", "time_off" },
3271     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3272                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3273         "enable/disable seeking by timestamp with -ss" },
3274     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3275                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3276         "enable/disable accurate seeking with -ss" },
3277     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3278                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3279         "set the input ts offset", "time_off" },
3280     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3281                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3282         "set the input ts scale", "scale" },
3283     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3284         "set the recording timestamp ('now' to set the current time)", "time" },
3285     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3286         "add metadata", "string=string" },
3287     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3288         "add program with specified streams", "title=string:st=number..." },
3289     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3290                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3291         "set the number of data frames to output", "number" },
3292     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3293         "add timings for benchmarking" },
3294     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3295       "add timings for each task" },
3296     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3297       "write program-readable progress information", "url" },
3298     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3299       "enable or disable interaction on standard input" },
3300     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3301         "set max runtime in seconds", "limit" },
3302     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3303         "dump each input packet" },
3304     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3305         "when dumping packets, also dump the payload" },
3306     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3307                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3308         "read input at native frame rate", "" },
3309     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3310         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3311         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3312     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3313         "video sync method", "" },
3314     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3315         "frame drop threshold", "" },
3316     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3317         "audio sync method", "" },
3318     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3319         "audio drift threshold", "threshold" },
3320     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3321         "copy timestamps" },
3322     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3323         "shift input timestamps to start at 0 when using copyts" },
3324     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3325         "copy input stream time base when stream copying", "mode" },
3326     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3327                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3328         "finish encoding within shortest input" },
3329     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3330                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3331         "audio pad", "" },
3332     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3333         "timestamp discontinuity delta threshold", "threshold" },
3334     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3335         "timestamp error delta threshold", "threshold" },
3336     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3337         "exit on error", "error" },
3338     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3339         "abort on the specified condition flags", "flags" },
3340     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3341                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3342         "copy initial non-keyframes" },
3343     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3344         "copy or discard frames before start time" },
3345     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3346         "set the number of frames to output", "number" },
3347     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3348                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3349         "force codec tag/fourcc", "fourcc/tag" },
3350     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3351                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3352         "use fixed quality scale (VBR)", "q" },
3353     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3354                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3355         "use fixed quality scale (VBR)", "q" },
3356     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3357         "set profile", "profile" },
3358     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3359         "set stream filtergraph", "filter_graph" },
3360     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3361         "read stream filtergraph description from a file", "filename" },
3362     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3363         "reinit filtergraph on input parameter changes", "" },
3364     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3365         "create a complex filtergraph", "graph_description" },
3366     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3367         "create a complex filtergraph", "graph_description" },
3368     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3369         "read complex filtergraph description from a file", "filename" },
3370     { "stats",          OPT_BOOL,                                    { &print_stats },
3371         "print progress report during encoding", },
3372     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3373                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3374         "add an attachment to the output file", "filename" },
3375     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3376                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3377         "extract an attachment into a file", "filename" },
3378     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3379                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3380     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3381         "print timestamp debugging info" },
3382     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3383         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3384     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3385                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3386         "discard", "" },
3387     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3388                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3389         "disposition", "" },
3390     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3391                                                                      { .off = OFFSET(thread_queue_size) },
3392         "set the maximum number of queued packets from the demuxer" },
3393
3394     /* video options */
3395     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3396         "set the number of video frames to output", "number" },
3397     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3398                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3399         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3400     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3401                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3402         "set frame size (WxH or abbreviation)", "size" },
3403     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3404                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3405         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3406     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3407                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3408         "set pixel format", "format" },
3409     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3410         "set the number of bits per raw sample", "number" },
3411     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3412         "deprecated use -g 1" },
3413     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3414         "disable video" },
3415     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3416                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3417         "rate control override for specific intervals", "override" },
3418     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3419                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3420         "force video codec ('copy' to copy stream)", "codec" },
3421     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3422         "Removed" },
3423     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3424         "Removed" },
3425     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3426         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3427     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3428         "select the pass number (1 to 3)", "n" },
3429     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3430                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3431         "select two pass log file name prefix", "prefix" },
3432     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3433         "this option is deprecated, use the yadif filter instead" },
3434     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3435         "calculate PSNR of compressed frames" },
3436     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3437         "dump video coding statistics to file" },
3438     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3439         "dump video coding statistics to file", "file" },
3440     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3441         "set video filters", "filter_graph" },
3442     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3443                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3444         "specify intra matrix coeffs", "matrix" },
3445     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3446                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3447         "specify inter matrix coeffs", "matrix" },
3448     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3449                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3450         "specify intra matrix coeffs", "matrix" },
3451     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3452                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3453         "top=1/bottom=0/auto=-1 field first", "" },
3454     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3455                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3456         "force video tag/fourcc", "fourcc/tag" },
3457     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3458         "show QP histogram" },
3459     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3460                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3461         "force the selected framerate, disable the best supported framerate selection" },
3462     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3463                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3464         "set the value of an outfile streamid", "streamIndex:value" },
3465     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3466                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3467         "force key frames at specified timestamps", "timestamps" },
3468     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3469         "audio bitrate (please use -b:a)", "bitrate" },
3470     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3471         "video bitrate (please use -b:v)", "bitrate" },
3472     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3473                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3474         "use HW accelerated decoding", "hwaccel name" },
3475     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3476                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3477         "select a device for HW acceleration", "devicename" },
3478     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3479                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3480         "select output format used with HW accelerated decoding", "format" },
3481 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3482     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3483 #endif
3484     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3485         "show available HW acceleration methods" },
3486     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3487                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3488         "automatically insert correct rotate filters" },
3489     { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
3490         "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3491
3492     /* audio options */
3493     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3494         "set the number of audio frames to output", "number" },
3495     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3496         "set audio quality (codec-specific)", "quality", },
3497     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3498                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3499         "set audio sampling rate (in Hz)", "rate" },
3500     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3501                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3502         "set number of audio channels", "channels" },
3503     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3504         "disable audio" },
3505     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3506                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3507         "force audio codec ('copy' to copy stream)", "codec" },
3508     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3509                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3510         "force audio tag/fourcc", "fourcc/tag" },
3511     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3512         "change audio volume (256=normal)" , "volume" },
3513     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3514                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3515         "set sample format", "format" },
3516     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3517                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3518         "set channel layout", "layout" },
3519     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3520         "set audio filters", "filter_graph" },
3521     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3522       "set the maximum number of channels to try to guess the channel layout" },
3523
3524     /* subtitle options */
3525     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3526         "disable subtitle" },
3527     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3528         "force subtitle codec ('copy' to copy stream)", "codec" },
3529     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3530         , "force subtitle tag/fourcc", "fourcc/tag" },
3531     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3532         "fix subtitles duration" },
3533     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3534         "set canvas size (WxH or abbreviation)", "size" },
3535
3536     /* grab options */
3537     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3538         "deprecated, use -channel", "channel" },
3539     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3540         "deprecated, use -standard", "standard" },
3541     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3542
3543     /* muxer options */
3544     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3545         "set the maximum demux-decode delay", "seconds" },
3546     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3547         "set the initial demux-decode delay", "seconds" },
3548     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3549         "override the options from ffserver", "" },
3550     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3551         "specify a file in which to print sdp information", "file" },
3552
3553     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3554         "A comma-separated list of bitstream filters", "bitstream_filters" },
3555     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3556         "deprecated", "audio bitstream_filters" },
3557     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3558         "deprecated", "video bitstream_filters" },
3559
3560     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3561         "set the audio options to the indicated preset", "preset" },
3562     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3563         "set the video options to the indicated preset", "preset" },
3564     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3565         "set the subtitle options to the indicated preset", "preset" },
3566     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3567         "set options from indicated preset file", "filename" },
3568     /* data codec support */
3569     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3570         "force data codec ('copy' to copy stream)", "codec" },
3571     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3572         "disable data" },
3573
3574 #if CONFIG_VAAPI
3575     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3576         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3577 #endif
3578
3579     { NULL, },
3580 };