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

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