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