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