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