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