git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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