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