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