2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
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.
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.
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
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
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"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
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;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
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;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
76 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
78 #if CONFIG_VIDEOTOOLBOX
79 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
82 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
85 { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
88 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
92 int hwaccel_lax_profile_check = 0;
93 AVBufferRef *hw_device_ctx;
95 char *vstats_filename;
98 float audio_drift_threshold = 0.1;
99 float dts_delta_threshold = 10;
100 float dts_error_threshold = 3600*30;
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;
112 int start_at_zero = 0;
115 int exit_on_error = 0;
116 int abort_on_flags = 0;
117 int print_stats = -1;
119 int stdin_interaction = 1;
120 int frame_bits_per_raw_sample = 0;
121 float max_error_rate = 2.0/3;
122 int filter_nbthreads = 0;
123 int filter_complex_nbthreads = 0;
124 int vstats_version = 2;
127 static int intra_only = 0;
128 static int file_overwrite = 0;
129 static int no_file_overwrite = 0;
130 static int do_psnr = 0;
131 static int input_sync;
132 static int override_ffserver = 0;
133 static int input_stream_potentially_available = 0;
134 static int ignore_unknown_streams = 0;
135 static int copy_unknown_streams = 0;
137 static void uninit_options(OptionsContext *o)
139 const OptionDef *po = options;
142 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
144 void *dst = (uint8_t*)o + po->u.off;
146 if (po->flags & OPT_SPEC) {
147 SpecifierOpt **so = dst;
148 int i, *count = (int*)(so + 1);
149 for (i = 0; i < *count; i++) {
150 av_freep(&(*so)[i].specifier);
151 if (po->flags & OPT_STRING)
152 av_freep(&(*so)[i].u.str);
156 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
161 for (i = 0; i < o->nb_stream_maps; i++)
162 av_freep(&o->stream_maps[i].linklabel);
163 av_freep(&o->stream_maps);
164 av_freep(&o->audio_channel_maps);
165 av_freep(&o->streamid_map);
166 av_freep(&o->attachments);
169 static void init_options(OptionsContext *o)
171 memset(o, 0, sizeof(*o));
173 o->stop_time = INT64_MAX;
174 o->mux_max_delay = 0.7;
175 o->start_time = AV_NOPTS_VALUE;
176 o->start_time_eof = AV_NOPTS_VALUE;
177 o->recording_time = INT64_MAX;
178 o->limit_filesize = UINT64_MAX;
179 o->chapters_input_file = INT_MAX;
180 o->accurate_seek = 1;
183 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
187 printf("Hardware acceleration methods:\n");
188 for (i = 0; hwaccels[i].name; i++) {
189 printf("%s\n", hwaccels[i].name);
195 /* return a copy of the input with the stream specifiers removed from the keys */
196 static AVDictionary *strip_specifiers(AVDictionary *dict)
198 AVDictionaryEntry *e = NULL;
199 AVDictionary *ret = NULL;
201 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
202 char *p = strchr(e->key, ':');
206 av_dict_set(&ret, e->key, e->value, 0);
213 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
215 static const AVOption opts[] = {
216 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
217 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
220 static const AVClass class = {
222 .item_name = av_default_item_name,
224 .version = LIBAVUTIL_VERSION_INT,
226 const AVClass *pclass = &class;
228 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
231 static int opt_sameq(void *optctx, const char *opt, const char *arg)
233 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
234 "If you are looking for an option to preserve the quality (which is not "
235 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
237 return AVERROR(EINVAL);
240 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
242 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
243 return opt_default(optctx, "channel", arg);
246 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
248 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
249 return opt_default(optctx, "standard", arg);
252 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
254 OptionsContext *o = optctx;
255 return parse_option(o, "codec:a", arg, options);
258 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
260 OptionsContext *o = optctx;
261 return parse_option(o, "codec:v", arg, options);
264 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
266 OptionsContext *o = optctx;
267 return parse_option(o, "codec:s", arg, options);
270 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
272 OptionsContext *o = optctx;
273 return parse_option(o, "codec:d", arg, options);
276 static int opt_map(void *optctx, const char *opt, const char *arg)
278 OptionsContext *o = optctx;
280 int i, negative = 0, file_idx;
281 int sync_file_idx = -1, sync_stream_idx = 0;
290 map = av_strdup(arg);
292 return AVERROR(ENOMEM);
294 /* parse sync stream first, just pick first matching stream */
295 if (sync = strchr(map, ',')) {
297 sync_file_idx = strtol(sync + 1, &sync, 0);
298 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
299 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
304 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
305 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
306 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
310 if (i == input_files[sync_file_idx]->nb_streams) {
311 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
312 "match any streams.\n", arg);
319 /* this mapping refers to lavfi output */
320 const char *c = map + 1;
321 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
322 m = &o->stream_maps[o->nb_stream_maps - 1];
323 m->linklabel = av_get_token(&c, "]");
325 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
329 if (allow_unused = strchr(map, '?'))
331 file_idx = strtol(map, &p, 0);
332 if (file_idx >= nb_input_files || file_idx < 0) {
333 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
337 /* disable some already defined maps */
338 for (i = 0; i < o->nb_stream_maps; i++) {
339 m = &o->stream_maps[i];
340 if (file_idx == m->file_index &&
341 check_stream_specifier(input_files[m->file_index]->ctx,
342 input_files[m->file_index]->ctx->streams[m->stream_index],
343 *p == ':' ? p + 1 : p) > 0)
347 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
348 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
349 *p == ':' ? p + 1 : p) <= 0)
351 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
352 m = &o->stream_maps[o->nb_stream_maps - 1];
354 m->file_index = file_idx;
357 if (sync_file_idx >= 0) {
358 m->sync_file_index = sync_file_idx;
359 m->sync_stream_index = sync_stream_idx;
361 m->sync_file_index = file_idx;
362 m->sync_stream_index = i;
369 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
371 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
372 "To ignore this, add a trailing '?' to the map.\n", arg);
381 static int opt_attach(void *optctx, const char *opt, const char *arg)
383 OptionsContext *o = optctx;
384 GROW_ARRAY(o->attachments, o->nb_attachments);
385 o->attachments[o->nb_attachments - 1] = arg;
389 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
391 OptionsContext *o = optctx;
396 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
397 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
399 /* muted channel syntax */
400 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
401 if ((n == 1 || n == 3) && m->channel_idx == -1) {
402 m->file_idx = m->stream_idx = -1;
404 m->ofile_idx = m->ostream_idx = -1;
409 n = sscanf(arg, "%d.%d.%d:%d.%d",
410 &m->file_idx, &m->stream_idx, &m->channel_idx,
411 &m->ofile_idx, &m->ostream_idx);
413 if (n != 3 && n != 5) {
414 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
415 "[file.stream.channel|-1][:syncfile:syncstream]\n");
419 if (n != 5) // only file.stream.channel specified
420 m->ofile_idx = m->ostream_idx = -1;
423 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
424 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
428 if (m->stream_idx < 0 ||
429 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
430 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
431 m->file_idx, m->stream_idx);
434 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
435 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
436 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
437 m->file_idx, m->stream_idx);
440 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
441 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
442 m->file_idx, m->stream_idx, m->channel_idx);
448 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
450 av_free(sdp_filename);
451 sdp_filename = av_strdup(arg);
456 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
459 err = vaapi_device_init(arg);
467 * Parse a metadata specifier passed as 'arg' parameter.
468 * @param arg metadata string to parse
469 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
470 * @param index for type c/p, chapter/program index is written here
471 * @param stream_spec for type s, the stream specifier is written here
473 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
481 if (*(++arg) && *arg != ':') {
482 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
485 *stream_spec = *arg == ':' ? arg + 1 : "";
490 *index = strtol(++arg, NULL, 0);
493 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
500 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
502 AVDictionary **meta_in = NULL;
503 AVDictionary **meta_out = NULL;
505 char type_in, type_out;
506 const char *istream_spec = NULL, *ostream_spec = NULL;
507 int idx_in = 0, idx_out = 0;
509 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
510 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
513 if (type_out == 'g' || !*outspec)
514 o->metadata_global_manual = 1;
515 if (type_out == 's' || !*outspec)
516 o->metadata_streams_manual = 1;
517 if (type_out == 'c' || !*outspec)
518 o->metadata_chapters_manual = 1;
522 if (type_in == 'g' || type_out == 'g')
523 o->metadata_global_manual = 1;
524 if (type_in == 's' || type_out == 's')
525 o->metadata_streams_manual = 1;
526 if (type_in == 'c' || type_out == 'c')
527 o->metadata_chapters_manual = 1;
529 /* ic is NULL when just disabling automatic mappings */
533 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
534 if ((index) < 0 || (index) >= (nb_elems)) {\
535 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
540 #define SET_DICT(type, meta, context, index)\
543 meta = &context->metadata;\
546 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
547 meta = &context->chapters[index]->metadata;\
550 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
551 meta = &context->programs[index]->metadata;\
554 break; /* handled separately below */ \
555 default: av_assert0(0);\
558 SET_DICT(type_in, meta_in, ic, idx_in);
559 SET_DICT(type_out, meta_out, oc, idx_out);
561 /* for input streams choose first matching stream */
562 if (type_in == 's') {
563 for (i = 0; i < ic->nb_streams; i++) {
564 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
565 meta_in = &ic->streams[i]->metadata;
571 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
576 if (type_out == 's') {
577 for (i = 0; i < oc->nb_streams; i++) {
578 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
579 meta_out = &oc->streams[i]->metadata;
580 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
585 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
590 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
592 OptionsContext *o = optctx;
594 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
595 struct tm time = *gmtime((time_t*)&recording_timestamp);
596 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
598 parse_option(o, "metadata", buf, options);
600 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
601 "tag instead.\n", opt);
605 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
607 const AVCodecDescriptor *desc;
608 const char *codec_string = encoder ? "encoder" : "decoder";
612 avcodec_find_encoder_by_name(name) :
613 avcodec_find_decoder_by_name(name);
615 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
616 codec = encoder ? avcodec_find_encoder(desc->id) :
617 avcodec_find_decoder(desc->id);
619 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
620 codec_string, codec->name, desc->name);
624 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
627 if (codec->type != type) {
628 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
634 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
636 char *codec_name = NULL;
638 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
640 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
641 st->codecpar->codec_id = codec->id;
644 return avcodec_find_decoder(st->codecpar->codec_id);
647 /* Add all the streams from the given input file to the global
648 * list of input streams. */
649 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
653 for (i = 0; i < ic->nb_streams; i++) {
654 AVStream *st = ic->streams[i];
655 AVCodecParameters *par = st->codecpar;
656 InputStream *ist = av_mallocz(sizeof(*ist));
657 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
658 char *hwaccel_output_format = NULL;
659 char *codec_tag = NULL;
661 char *discard_str = NULL;
662 const AVClass *cc = avcodec_get_class();
663 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
668 GROW_ARRAY(input_streams, nb_input_streams);
669 input_streams[nb_input_streams - 1] = ist;
672 ist->file_index = nb_input_files;
674 st->discard = AVDISCARD_ALL;
676 ist->min_pts = INT64_MAX;
677 ist->max_pts = INT64_MIN;
680 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
683 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
685 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
687 uint32_t tag = strtol(codec_tag, &next, 0);
689 tag = AV_RL32(codec_tag);
690 st->codecpar->codec_tag = tag;
693 ist->dec = choose_decoder(o, ic, st);
694 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
696 ist->reinit_filters = -1;
697 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
699 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
700 ist->user_set_discard = AVDISCARD_NONE;
701 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
702 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
707 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
709 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
711 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
715 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
717 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
721 switch (par->codec_type) {
722 case AVMEDIA_TYPE_VIDEO:
724 ist->dec = avcodec_find_decoder(par->codec_id);
726 if (av_codec_get_lowres(st->codec)) {
727 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
728 ist->dec_ctx->width = st->codec->width;
729 ist->dec_ctx->height = st->codec->height;
730 ist->dec_ctx->coded_width = st->codec->coded_width;
731 ist->dec_ctx->coded_height = st->codec->coded_height;
732 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
736 // avformat_find_stream_info() doesn't set this for us anymore.
737 ist->dec_ctx->framerate = st->avg_frame_rate;
739 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
740 if (framerate && av_parse_video_rate(&ist->framerate,
742 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
747 ist->top_field_first = -1;
748 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
750 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
752 if (!strcmp(hwaccel, "none"))
753 ist->hwaccel_id = HWACCEL_NONE;
754 else if (!strcmp(hwaccel, "auto"))
755 ist->hwaccel_id = HWACCEL_AUTO;
758 for (i = 0; hwaccels[i].name; i++) {
759 if (!strcmp(hwaccels[i].name, hwaccel)) {
760 ist->hwaccel_id = hwaccels[i].id;
765 if (!ist->hwaccel_id) {
766 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
768 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
769 for (i = 0; hwaccels[i].name; i++)
770 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
771 av_log(NULL, AV_LOG_FATAL, "\n");
777 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
778 if (hwaccel_device) {
779 ist->hwaccel_device = av_strdup(hwaccel_device);
780 if (!ist->hwaccel_device)
784 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
785 hwaccel_output_format, ic, st);
786 if (hwaccel_output_format) {
787 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
788 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
789 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
790 "format: %s", hwaccel_output_format);
793 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
796 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
799 case AVMEDIA_TYPE_AUDIO:
800 ist->guess_layout_max = INT_MAX;
801 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
802 guess_input_channel_layout(ist);
804 case AVMEDIA_TYPE_DATA:
805 case AVMEDIA_TYPE_SUBTITLE: {
806 char *canvas_size = NULL;
808 ist->dec = avcodec_find_decoder(par->codec_id);
809 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
810 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
812 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
813 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
818 case AVMEDIA_TYPE_ATTACHMENT:
819 case AVMEDIA_TYPE_UNKNOWN:
825 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
827 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
833 static void assert_file_overwrite(const char *filename)
835 if (file_overwrite && no_file_overwrite) {
836 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
840 if (!file_overwrite) {
841 const char *proto_name = avio_find_protocol_name(filename);
842 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
843 if (stdin_interaction && !no_file_overwrite) {
844 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
847 signal(SIGINT, SIG_DFL);
849 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
855 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
862 static void dump_attachment(AVStream *st, const char *filename)
865 AVIOContext *out = NULL;
866 AVDictionaryEntry *e;
868 if (!st->codecpar->extradata_size) {
869 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
870 nb_input_files - 1, st->index);
873 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
876 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
877 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
881 assert_file_overwrite(filename);
883 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
884 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
889 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
894 static int open_input_file(OptionsContext *o, const char *filename)
898 AVInputFormat *file_iformat = NULL;
902 AVDictionary *unused_opts = NULL;
903 AVDictionaryEntry *e = NULL;
904 int orig_nb_streams; // number of streams before avformat_find_stream_info
905 char * video_codec_name = NULL;
906 char * audio_codec_name = NULL;
907 char *subtitle_codec_name = NULL;
908 char * data_codec_name = NULL;
909 int scan_all_pmts_set = 0;
912 if (!(file_iformat = av_find_input_format(o->format))) {
913 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
918 if (!strcmp(filename, "-"))
921 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
922 strcmp(filename, "/dev/stdin");
924 /* get default parameters from command line */
925 ic = avformat_alloc_context();
927 print_error(filename, AVERROR(ENOMEM));
930 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
931 if (o->nb_audio_sample_rate) {
932 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
934 if (o->nb_audio_channels) {
935 /* because we set audio_channels based on both the "ac" and
936 * "channel_layout" options, we need to check that the specified
937 * demuxer actually has the "channels" option before setting it */
938 if (file_iformat && file_iformat->priv_class &&
939 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
940 AV_OPT_SEARCH_FAKE_OBJ)) {
941 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
944 if (o->nb_frame_rates) {
945 /* set the format-level framerate option;
946 * this is important for video grabbers, e.g. x11 */
947 if (file_iformat && file_iformat->priv_class &&
948 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
949 AV_OPT_SEARCH_FAKE_OBJ)) {
950 av_dict_set(&o->g->format_opts, "framerate",
951 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
954 if (o->nb_frame_sizes) {
955 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
957 if (o->nb_frame_pix_fmts)
958 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
960 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
961 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
962 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
963 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
965 ic->video_codec_id = video_codec_name ?
966 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
967 ic->audio_codec_id = audio_codec_name ?
968 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
969 ic->subtitle_codec_id= subtitle_codec_name ?
970 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
971 ic->data_codec_id = data_codec_name ?
972 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
974 if (video_codec_name)
975 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
976 if (audio_codec_name)
977 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
978 if (subtitle_codec_name)
979 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
981 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
983 ic->flags |= AVFMT_FLAG_NONBLOCK;
984 ic->interrupt_callback = int_cb;
986 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
987 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
988 scan_all_pmts_set = 1;
990 /* open the input file with generic avformat function */
991 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
993 print_error(filename, err);
994 if (err == AVERROR_PROTOCOL_NOT_FOUND)
995 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
998 if (scan_all_pmts_set)
999 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1000 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1001 assert_avoptions(o->g->format_opts);
1003 /* apply forced codec ids */
1004 for (i = 0; i < ic->nb_streams; i++)
1005 choose_decoder(o, ic, ic->streams[i]);
1007 /* Set AVCodecContext options for avformat_find_stream_info */
1008 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1009 orig_nb_streams = ic->nb_streams;
1011 /* If not enough info to get the stream parameters, we decode the
1012 first frames to get it. (used in mpeg case for example) */
1013 ret = avformat_find_stream_info(ic, opts);
1015 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1016 if (ic->nb_streams == 0) {
1017 avformat_close_input(&ic);
1022 if (o->start_time_eof != AV_NOPTS_VALUE) {
1023 if (ic->duration>0) {
1024 o->start_time = o->start_time_eof + ic->duration;
1026 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1028 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1029 /* add the stream start time */
1030 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1031 timestamp += ic->start_time;
1033 /* if seeking requested, we execute it */
1034 if (o->start_time != AV_NOPTS_VALUE) {
1035 int64_t seek_timestamp = timestamp;
1037 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1038 int dts_heuristic = 0;
1039 for (i=0; i<ic->nb_streams; i++) {
1040 const AVCodecParameters *par = ic->streams[i]->codecpar;
1041 if (par->video_delay)
1044 if (dts_heuristic) {
1045 seek_timestamp -= 3*AV_TIME_BASE / 23;
1048 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1050 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1051 filename, (double)timestamp / AV_TIME_BASE);
1055 /* update the current parameters so that they match the one of the input stream */
1056 add_input_streams(o, ic);
1058 /* dump the file content */
1059 av_dump_format(ic, nb_input_files, filename, 0);
1061 GROW_ARRAY(input_files, nb_input_files);
1062 f = av_mallocz(sizeof(*f));
1065 input_files[nb_input_files - 1] = f;
1068 f->ist_index = nb_input_streams - ic->nb_streams;
1069 f->start_time = o->start_time;
1070 f->recording_time = o->recording_time;
1071 f->input_ts_offset = o->input_ts_offset;
1072 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1073 f->nb_streams = ic->nb_streams;
1074 f->rate_emu = o->rate_emu;
1075 f->accurate_seek = o->accurate_seek;
1078 f->time_base = (AVRational){ 1, 1 };
1080 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1083 /* check if all codec options have been used */
1084 unused_opts = strip_specifiers(o->g->codec_opts);
1085 for (i = f->ist_index; i < nb_input_streams; i++) {
1087 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1088 AV_DICT_IGNORE_SUFFIX)))
1089 av_dict_set(&unused_opts, e->key, NULL, 0);
1093 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1094 const AVClass *class = avcodec_get_class();
1095 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1096 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1097 const AVClass *fclass = avformat_get_class();
1098 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1099 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1100 if (!option || foption)
1104 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1105 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1106 "input file #%d (%s) is not a decoding option.\n", e->key,
1107 option->help ? option->help : "", nb_input_files - 1,
1112 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1113 "input file #%d (%s) has not been used for any stream. The most "
1114 "likely reason is either wrong type (e.g. a video option with "
1115 "no video streams) or that it is a private option of some decoder "
1116 "which was not actually used for any stream.\n", e->key,
1117 option->help ? option->help : "", nb_input_files - 1, filename);
1119 av_dict_free(&unused_opts);
1121 for (i = 0; i < o->nb_dump_attachment; i++) {
1124 for (j = 0; j < ic->nb_streams; j++) {
1125 AVStream *st = ic->streams[j];
1127 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1128 dump_attachment(st, o->dump_attachment[i].u.str);
1132 for (i = 0; i < orig_nb_streams; i++)
1133 av_dict_free(&opts[i]);
1136 input_stream_potentially_available = 1;
1141 static uint8_t *get_line(AVIOContext *s)
1147 if (avio_open_dyn_buf(&line) < 0) {
1148 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1152 while ((c = avio_r8(s)) && c != '\n')
1155 avio_close_dyn_buf(line, &buf);
1160 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1163 char filename[1000];
1164 const char *base[3] = { getenv("AVCONV_DATADIR"),
1169 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1173 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1174 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1175 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1178 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1179 i != 1 ? "" : "/.avconv", preset_name);
1180 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1186 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1188 enum AVMediaType type = ost->st->codecpar->codec_type;
1189 char *codec_name = NULL;
1191 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1192 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1194 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1195 NULL, ost->st->codecpar->codec_type);
1196 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1198 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1199 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1200 "probably disabled. Please choose an encoder manually.\n",
1201 ost->file_index, ost->index, s->oformat->name,
1202 avcodec_get_name(ost->st->codecpar->codec_id));
1203 return AVERROR_ENCODER_NOT_FOUND;
1205 } else if (!strcmp(codec_name, "copy"))
1206 ost->stream_copy = 1;
1208 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1209 ost->st->codecpar->codec_id = ost->enc->id;
1211 ost->encoding_needed = !ost->stream_copy;
1213 /* no encoding supported for other media types */
1214 ost->stream_copy = 1;
1215 ost->encoding_needed = 0;
1221 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1224 AVStream *st = avformat_new_stream(oc, NULL);
1225 int idx = oc->nb_streams - 1, ret = 0;
1226 const char *bsfs = NULL, *time_base = NULL;
1227 char *next, *codec_tag = NULL;
1232 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1236 if (oc->nb_streams - 1 < o->nb_streamid_map)
1237 st->id = o->streamid_map[oc->nb_streams - 1];
1239 GROW_ARRAY(output_streams, nb_output_streams);
1240 if (!(ost = av_mallocz(sizeof(*ost))))
1242 output_streams[nb_output_streams - 1] = ost;
1244 ost->file_index = nb_output_files - 1;
1247 st->codecpar->codec_type = type;
1249 ret = choose_encoder(o, oc, ost);
1251 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1252 "%d:%d\n", ost->file_index, ost->index);
1256 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1257 if (!ost->enc_ctx) {
1258 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1261 ost->enc_ctx->codec_type = type;
1263 ost->ref_par = avcodec_parameters_alloc();
1264 if (!ost->ref_par) {
1265 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1270 AVIOContext *s = NULL;
1271 char *buf = NULL, *arg = NULL, *preset = NULL;
1273 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1275 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1276 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1279 if (!buf[0] || buf[0] == '#') {
1283 if (!(arg = strchr(buf, '='))) {
1284 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1288 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1290 } while (!s->eof_reached);
1294 av_log(NULL, AV_LOG_FATAL,
1295 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1296 preset, ost->file_index, ost->index);
1300 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1303 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1306 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1307 q.num <= 0 || q.den <= 0) {
1308 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1314 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1317 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1319 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1322 ost->enc_timebase = q;
1325 ost->max_frames = INT64_MAX;
1326 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1327 for (i = 0; i<o->nb_max_frames; i++) {
1328 char *p = o->max_frames[i].specifier;
1329 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1330 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1335 ost->copy_prior_start = -1;
1336 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1338 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1339 while (bsfs && *bsfs) {
1340 const AVBitStreamFilter *filter;
1341 char *bsf, *bsf_options_str, *bsf_name;
1343 bsf = av_get_token(&bsfs, ",");
1346 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1350 filter = av_bsf_get_by_name(bsf_name);
1352 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1356 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1357 ost->nb_bitstream_filters + 1,
1358 sizeof(*ost->bsf_ctx));
1362 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1364 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1368 ost->nb_bitstream_filters++;
1370 if (bsf_options_str && filter->priv_class) {
1371 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1372 const char * shorthand[2] = {NULL};
1375 shorthand[0] = opt->name;
1377 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1379 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1388 if (ost->nb_bitstream_filters) {
1389 ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1390 if (!ost->bsf_extradata_updated) {
1391 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1396 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1398 uint32_t tag = strtol(codec_tag, &next, 0);
1400 tag = AV_RL32(codec_tag);
1401 ost->st->codecpar->codec_tag =
1402 ost->enc_ctx->codec_tag = tag;
1405 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1407 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1408 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1411 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1412 ost->disposition = av_strdup(ost->disposition);
1414 ost->max_muxing_queue_size = 128;
1415 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1416 ost->max_muxing_queue_size *= sizeof(AVPacket);
1418 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1419 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1421 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1423 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1424 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1425 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1427 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1429 ost->source_index = source_index;
1430 if (source_index >= 0) {
1431 ost->sync_ist = input_streams[source_index];
1432 input_streams[source_index]->discard = 0;
1433 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1435 ost->last_mux_dts = AV_NOPTS_VALUE;
1437 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1438 if (!ost->muxing_queue)
1444 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1447 const char *p = str;
1454 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1461 /* read file contents into a string */
1462 static uint8_t *read_file(const char *filename)
1464 AVIOContext *pb = NULL;
1465 AVIOContext *dyn_buf = NULL;
1466 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1467 uint8_t buf[1024], *str;
1470 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1474 ret = avio_open_dyn_buf(&dyn_buf);
1479 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1480 avio_write(dyn_buf, buf, ret);
1481 avio_w8(dyn_buf, 0);
1484 ret = avio_close_dyn_buf(dyn_buf, &str);
1490 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1493 AVStream *st = ost->st;
1495 if (ost->filters_script && ost->filters) {
1496 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1497 "output stream #%d:%d.\n", nb_output_files, st->index);
1501 if (ost->filters_script)
1502 return read_file(ost->filters_script);
1503 else if (ost->filters)
1504 return av_strdup(ost->filters);
1506 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1510 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1511 const OutputStream *ost, enum AVMediaType type)
1513 if (ost->filters_script || ost->filters) {
1514 av_log(NULL, AV_LOG_ERROR,
1515 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1516 "Filtering and streamcopy cannot be used together.\n",
1517 ost->filters ? "Filtergraph" : "Filtergraph script",
1518 ost->filters ? ost->filters : ost->filters_script,
1519 av_get_media_type_string(type), ost->file_index, ost->index);
1524 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1528 AVCodecContext *video_enc;
1529 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1531 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1533 video_enc = ost->enc_ctx;
1535 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1536 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1537 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1540 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1541 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1543 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1544 if (frame_aspect_ratio) {
1546 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1547 q.num <= 0 || q.den <= 0) {
1548 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1551 ost->frame_aspect_ratio = q;
1554 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1555 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1557 if (!ost->stream_copy) {
1558 const char *p = NULL;
1559 char *frame_size = NULL;
1560 char *frame_pix_fmt = NULL;
1561 char *intra_matrix = NULL, *inter_matrix = NULL;
1562 char *chroma_intra_matrix = NULL;
1566 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1567 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1568 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1572 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1573 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1574 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1575 ost->keep_pix_fmt = 1;
1576 if (!*++frame_pix_fmt)
1577 frame_pix_fmt = NULL;
1579 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1580 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1583 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1586 video_enc->gop_size = 0;
1587 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1589 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1590 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1593 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1595 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1596 if (chroma_intra_matrix) {
1597 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1599 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1602 av_codec_set_chroma_intra_matrix(video_enc, p);
1603 parse_matrix_coeffs(p, chroma_intra_matrix);
1605 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1607 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1608 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1611 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1614 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1615 for (i = 0; p; i++) {
1617 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1619 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1622 video_enc->rc_override =
1623 av_realloc_array(video_enc->rc_override,
1624 i + 1, sizeof(RcOverride));
1625 if (!video_enc->rc_override) {
1626 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1629 video_enc->rc_override[i].start_frame = start;
1630 video_enc->rc_override[i].end_frame = end;
1632 video_enc->rc_override[i].qscale = q;
1633 video_enc->rc_override[i].quality_factor = 1.0;
1636 video_enc->rc_override[i].qscale = 0;
1637 video_enc->rc_override[i].quality_factor = -q/100.0;
1642 video_enc->rc_override_count = i;
1645 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1648 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1651 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1652 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1655 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1656 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1660 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1661 if (ost->logfile_prefix &&
1662 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1666 char logfilename[1024];
1669 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1670 ost->logfile_prefix ? ost->logfile_prefix :
1671 DEFAULT_PASS_LOGFILENAME_PREFIX,
1673 if (!strcmp(ost->enc->name, "libx264")) {
1674 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1676 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1677 char *logbuffer = read_file(logfilename);
1680 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1684 video_enc->stats_in = logbuffer;
1686 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1687 f = av_fopen_utf8(logfilename, "wb");
1689 av_log(NULL, AV_LOG_FATAL,
1690 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1691 logfilename, strerror(errno));
1699 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1700 if (ost->forced_keyframes)
1701 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1703 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1705 ost->top_field_first = -1;
1706 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1709 ost->avfilter = get_ost_filters(o, oc, ost);
1713 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1716 if (ost->stream_copy)
1717 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1722 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1727 AVCodecContext *audio_enc;
1729 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1732 audio_enc = ost->enc_ctx;
1733 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1735 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1736 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1738 if (!ost->stream_copy) {
1739 char *sample_fmt = NULL;
1741 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1743 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1745 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1746 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1750 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1752 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1753 ost->apad = av_strdup(ost->apad);
1755 ost->avfilter = get_ost_filters(o, oc, ost);
1759 /* check for channel mapping for this audio stream */
1760 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1761 AudioChannelMap *map = &o->audio_channel_maps[n];
1762 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1763 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1766 if (map->channel_idx == -1) {
1768 } else if (ost->source_index < 0) {
1769 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1770 ost->file_index, ost->st->index);
1773 ist = input_streams[ost->source_index];
1776 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1777 if (av_reallocp_array(&ost->audio_channels_map,
1778 ost->audio_channels_mapped + 1,
1779 sizeof(*ost->audio_channels_map)
1783 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1789 if (ost->stream_copy)
1790 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1795 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1799 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1800 if (!ost->stream_copy) {
1801 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1808 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1812 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1813 if (!ost->stream_copy) {
1814 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1821 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1823 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1824 ost->stream_copy = 1;
1829 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1833 AVCodecContext *subtitle_enc;
1835 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1837 subtitle_enc = ost->enc_ctx;
1839 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1841 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1843 if (!ost->stream_copy) {
1844 char *frame_size = NULL;
1846 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1847 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1848 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1856 /* arg format is "output-stream-index:streamid-value". */
1857 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1859 OptionsContext *o = optctx;
1864 av_strlcpy(idx_str, arg, sizeof(idx_str));
1865 p = strchr(idx_str, ':');
1867 av_log(NULL, AV_LOG_FATAL,
1868 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1873 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1874 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1875 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1879 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1881 AVFormatContext *is = ifile->ctx;
1882 AVFormatContext *os = ofile->ctx;
1886 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1888 return AVERROR(ENOMEM);
1891 for (i = 0; i < is->nb_chapters; i++) {
1892 AVChapter *in_ch = is->chapters[i], *out_ch;
1893 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1894 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1895 AV_TIME_BASE_Q, in_ch->time_base);
1896 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1897 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1900 if (in_ch->end < ts_off)
1902 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1905 out_ch = av_mallocz(sizeof(AVChapter));
1907 return AVERROR(ENOMEM);
1909 out_ch->id = in_ch->id;
1910 out_ch->time_base = in_ch->time_base;
1911 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1912 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1915 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1917 os->chapters[os->nb_chapters++] = out_ch;
1922 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1925 AVFormatContext *ic = avformat_alloc_context();
1927 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1928 ic->interrupt_callback = int_cb;
1929 err = avformat_open_input(&ic, filename, NULL, NULL);
1932 /* copy stream format */
1933 for(i=0;i<ic->nb_streams;i++) {
1937 const char *enc_config;
1939 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1941 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1942 return AVERROR(EINVAL);
1944 if (codec->type == AVMEDIA_TYPE_AUDIO)
1945 opt_audio_codec(o, "c:a", codec->name);
1946 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1947 opt_video_codec(o, "c:v", codec->name);
1948 ost = new_output_stream(o, s, codec->type, -1);
1951 avcodec_get_context_defaults3(st->codec, codec);
1952 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1954 AVDictionary *opts = NULL;
1955 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1956 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1957 av_dict_free(&opts);
1960 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1961 choose_sample_fmt(st, codec);
1962 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1963 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1964 avcodec_copy_context(ost->enc_ctx, st->codec);
1966 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1969 avformat_close_input(&ic);
1973 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1974 AVFormatContext *oc)
1978 switch (ofilter->type) {
1979 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1980 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1982 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1987 ost->source_index = -1;
1988 ost->filter = ofilter;
1991 ofilter->format = -1;
1993 if (ost->stream_copy) {
1994 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1995 "which is fed from a complex filtergraph. Filtering and streamcopy "
1996 "cannot be used together.\n", ost->file_index, ost->index);
2000 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2001 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2002 av_log(NULL, AV_LOG_ERROR,
2003 "%s '%s' was specified through the %s option "
2004 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2005 "%s and -filter_complex cannot be used together for the same stream.\n",
2006 ost->filters ? "Filtergraph" : "Filtergraph script",
2007 ost->filters ? ost->filters : ost->filters_script,
2008 opt, ost->file_index, ost->index, opt);
2012 avfilter_inout_free(&ofilter->out_tmp);
2015 static int init_complex_filters(void)
2019 for (i = 0; i < nb_filtergraphs; i++) {
2020 ret = init_complex_filtergraph(filtergraphs[i]);
2027 static int open_output_file(OptionsContext *o, const char *filename)
2029 AVFormatContext *oc;
2031 AVOutputFormat *file_oformat;
2035 AVDictionary *unused_opts = NULL;
2036 AVDictionaryEntry *e = NULL;
2037 int format_flags = 0;
2039 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2040 o->stop_time = INT64_MAX;
2041 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2044 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2045 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2046 if (o->stop_time <= start_time) {
2047 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2050 o->recording_time = o->stop_time - start_time;
2054 GROW_ARRAY(output_files, nb_output_files);
2055 of = av_mallocz(sizeof(*of));
2058 output_files[nb_output_files - 1] = of;
2060 of->ost_index = nb_output_streams;
2061 of->recording_time = o->recording_time;
2062 of->start_time = o->start_time;
2063 of->limit_filesize = o->limit_filesize;
2064 of->shortest = o->shortest;
2065 av_dict_copy(&of->opts, o->g->format_opts, 0);
2067 if (!strcmp(filename, "-"))
2070 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2072 print_error(filename, err);
2077 if (o->recording_time != INT64_MAX)
2078 oc->duration = o->recording_time;
2080 file_oformat= oc->oformat;
2081 oc->interrupt_callback = int_cb;
2083 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2085 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2086 av_opt_eval_flags(oc, o, e->value, &format_flags);
2089 /* create streams for all unlabeled output pads */
2090 for (i = 0; i < nb_filtergraphs; i++) {
2091 FilterGraph *fg = filtergraphs[i];
2092 for (j = 0; j < fg->nb_outputs; j++) {
2093 OutputFilter *ofilter = fg->outputs[j];
2095 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2098 switch (ofilter->type) {
2099 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2100 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2101 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2103 init_output_filter(ofilter, o, oc);
2107 /* ffserver seeking with date=... needs a date reference */
2108 if (!strcmp(file_oformat->name, "ffm") &&
2109 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2110 av_strstart(filename, "http:", NULL)) {
2111 int err = parse_option(o, "metadata", "creation_time=now", options);
2113 print_error(filename, err);
2118 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2119 av_strstart(filename, "http:", NULL)) {
2121 /* special case for files sent to ffserver: we get the stream
2122 parameters from ffserver */
2123 int err = read_ffserver_streams(o, oc, filename);
2125 print_error(filename, err);
2128 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2129 ost = output_streams[j];
2130 for (i = 0; i < nb_input_streams; i++) {
2131 ist = input_streams[i];
2132 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2134 ost->source_index= i;
2135 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2136 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2138 ist->st->discard = ist->user_set_discard;
2143 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2147 } else if (!o->nb_stream_maps) {
2148 char *subtitle_codec_name = NULL;
2149 /* pick the "best" stream of each type */
2151 /* video: highest resolution */
2152 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2153 int area = 0, idx = -1;
2154 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2155 for (i = 0; i < nb_input_streams; i++) {
2157 ist = input_streams[i];
2158 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2159 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2161 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2163 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2170 new_video_stream(o, oc, idx);
2173 /* audio: most channels */
2174 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2175 int best_score = 0, idx = -1;
2176 for (i = 0; i < nb_input_streams; i++) {
2178 ist = input_streams[i];
2179 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2180 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2181 score > best_score) {
2187 new_audio_stream(o, oc, idx);
2190 /* subtitles: pick first */
2191 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2192 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2193 for (i = 0; i < nb_input_streams; i++)
2194 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2195 AVCodecDescriptor const *input_descriptor =
2196 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2197 AVCodecDescriptor const *output_descriptor = NULL;
2198 AVCodec const *output_codec =
2199 avcodec_find_encoder(oc->oformat->subtitle_codec);
2200 int input_props = 0, output_props = 0;
2202 output_descriptor = avcodec_descriptor_get(output_codec->id);
2203 if (input_descriptor)
2204 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2205 if (output_descriptor)
2206 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2207 if (subtitle_codec_name ||
2208 input_props & output_props ||
2209 // Map dvb teletext which has neither property to any output subtitle encoder
2210 input_descriptor && output_descriptor &&
2211 (!input_descriptor->props ||
2212 !output_descriptor->props)) {
2213 new_subtitle_stream(o, oc, i);
2218 /* Data only if codec id match */
2219 if (!o->data_disable ) {
2220 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2221 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2222 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2223 && input_streams[i]->st->codecpar->codec_id == codec_id )
2224 new_data_stream(o, oc, i);
2228 for (i = 0; i < o->nb_stream_maps; i++) {
2229 StreamMap *map = &o->stream_maps[i];
2234 if (map->linklabel) {
2236 OutputFilter *ofilter = NULL;
2239 for (j = 0; j < nb_filtergraphs; j++) {
2240 fg = filtergraphs[j];
2241 for (k = 0; k < fg->nb_outputs; k++) {
2242 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2243 if (out && !strcmp(out->name, map->linklabel)) {
2244 ofilter = fg->outputs[k];
2251 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2252 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2255 init_output_filter(ofilter, o, oc);
2257 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2259 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2260 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2262 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2264 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2266 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2270 switch (ist->st->codecpar->codec_type) {
2271 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2272 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2273 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2274 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2275 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2276 case AVMEDIA_TYPE_UNKNOWN:
2277 if (copy_unknown_streams) {
2278 ost = new_unknown_stream (o, oc, src_idx);
2282 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2283 "Cannot map stream #%d:%d - unsupported type.\n",
2284 map->file_index, map->stream_index);
2285 if (!ignore_unknown_streams) {
2286 av_log(NULL, AV_LOG_FATAL,
2287 "If you want unsupported types ignored instead "
2288 "of failing, please use the -ignore_unknown option\n"
2289 "If you want them copied, please use -copy_unknown\n");
2294 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2295 + map->sync_stream_index];
2300 /* handle attached files */
2301 for (i = 0; i < o->nb_attachments; i++) {
2303 uint8_t *attachment;
2307 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2308 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2312 if ((len = avio_size(pb)) <= 0) {
2313 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2317 if (!(attachment = av_malloc(len))) {
2318 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2322 avio_read(pb, attachment, len);
2324 ost = new_attachment_stream(o, oc, -1);
2325 ost->stream_copy = 0;
2326 ost->attachment_filename = o->attachments[i];
2327 ost->st->codecpar->extradata = attachment;
2328 ost->st->codecpar->extradata_size = len;
2330 p = strrchr(o->attachments[i], '/');
2331 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2335 #if FF_API_LAVF_AVCTX
2336 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2337 AVDictionaryEntry *e;
2338 ost = output_streams[i];
2340 if ((ost->stream_copy || ost->attachment_filename)
2341 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2342 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2343 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2348 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2349 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2350 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2354 /* check if all codec options have been used */
2355 unused_opts = strip_specifiers(o->g->codec_opts);
2356 for (i = of->ost_index; i < nb_output_streams; i++) {
2358 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2359 AV_DICT_IGNORE_SUFFIX)))
2360 av_dict_set(&unused_opts, e->key, NULL, 0);
2364 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2365 const AVClass *class = avcodec_get_class();
2366 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2367 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2368 const AVClass *fclass = avformat_get_class();
2369 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2370 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2371 if (!option || foption)
2375 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2376 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2377 "output file #%d (%s) is not an encoding option.\n", e->key,
2378 option->help ? option->help : "", nb_output_files - 1,
2383 // gop_timecode is injected by generic code but not always used
2384 if (!strcmp(e->key, "gop_timecode"))
2387 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2388 "output file #%d (%s) has not been used for any stream. The most "
2389 "likely reason is either wrong type (e.g. a video option with "
2390 "no video streams) or that it is a private option of some encoder "
2391 "which was not actually used for any stream.\n", e->key,
2392 option->help ? option->help : "", nb_output_files - 1, filename);
2394 av_dict_free(&unused_opts);
2396 /* set the decoding_needed flags and create simple filtergraphs */
2397 for (i = of->ost_index; i < nb_output_streams; i++) {
2398 OutputStream *ost = output_streams[i];
2400 if (ost->encoding_needed && ost->source_index >= 0) {
2401 InputStream *ist = input_streams[ost->source_index];
2402 ist->decoding_needed |= DECODING_FOR_OST;
2404 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2405 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2406 err = init_simple_filtergraph(ist, ost);
2408 av_log(NULL, AV_LOG_ERROR,
2409 "Error initializing a simple filtergraph between streams "
2410 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2411 nb_output_files - 1, ost->st->index);
2417 /* set the filter output constraints */
2419 OutputFilter *f = ost->filter;
2421 switch (ost->enc_ctx->codec_type) {
2422 case AVMEDIA_TYPE_VIDEO:
2423 f->frame_rate = ost->frame_rate;
2424 f->width = ost->enc_ctx->width;
2425 f->height = ost->enc_ctx->height;
2426 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2427 f->format = ost->enc_ctx->pix_fmt;
2428 } else if (ost->enc->pix_fmts) {
2430 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2432 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2435 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2438 case AVMEDIA_TYPE_AUDIO:
2439 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2440 f->format = ost->enc_ctx->sample_fmt;
2441 } else if (ost->enc->sample_fmts) {
2443 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2445 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2448 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2450 if (ost->enc_ctx->sample_rate) {
2451 f->sample_rate = ost->enc_ctx->sample_rate;
2452 } else if (ost->enc->supported_samplerates) {
2454 while (ost->enc->supported_samplerates[count])
2456 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2457 if (!f->sample_rates)
2459 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2460 (count + 1) * sizeof(*f->sample_rates));
2462 if (ost->enc_ctx->channels) {
2463 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2464 } else if (ost->enc->channel_layouts) {
2466 while (ost->enc->channel_layouts[count])
2468 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2469 if (!f->channel_layouts)
2471 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2472 (count + 1) * sizeof(*f->channel_layouts));
2479 /* check filename in case of an image number is expected */
2480 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2481 if (!av_filename_number_test(oc->filename)) {
2482 print_error(oc->filename, AVERROR(EINVAL));
2487 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2488 av_log(NULL, AV_LOG_ERROR,
2489 "No input streams but output needs an input stream\n");
2493 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2494 /* test if it already exists to avoid losing precious files */
2495 assert_file_overwrite(filename);
2498 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2499 &oc->interrupt_callback,
2501 print_error(filename, err);
2504 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2505 assert_file_overwrite(filename);
2507 if (o->mux_preload) {
2508 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2510 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2513 for (i = 0; i < o->nb_metadata_map; i++) {
2515 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2517 if (in_file_index >= nb_input_files) {
2518 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2521 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2522 in_file_index >= 0 ?
2523 input_files[in_file_index]->ctx : NULL, o);
2527 if (o->chapters_input_file >= nb_input_files) {
2528 if (o->chapters_input_file == INT_MAX) {
2529 /* copy chapters from the first input file that has them*/
2530 o->chapters_input_file = -1;
2531 for (i = 0; i < nb_input_files; i++)
2532 if (input_files[i]->ctx->nb_chapters) {
2533 o->chapters_input_file = i;
2537 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2538 o->chapters_input_file);
2542 if (o->chapters_input_file >= 0)
2543 copy_chapters(input_files[o->chapters_input_file], of,
2544 !o->metadata_chapters_manual);
2546 /* copy global metadata by default */
2547 if (!o->metadata_global_manual && nb_input_files){
2548 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2549 AV_DICT_DONT_OVERWRITE);
2550 if(o->recording_time != INT64_MAX)
2551 av_dict_set(&oc->metadata, "duration", NULL, 0);
2552 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2554 if (!o->metadata_streams_manual)
2555 for (i = of->ost_index; i < nb_output_streams; i++) {
2557 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2559 ist = input_streams[output_streams[i]->source_index];
2560 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2561 if (!output_streams[i]->stream_copy) {
2562 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2566 /* process manually set programs */
2567 for (i = 0; i < o->nb_program; i++) {
2568 const char *p = o->program[i].u.str;
2573 const char *p2 = av_get_token(&p, ":");
2574 const char *to_dealloc = p2;
2581 key = av_get_token(&p2, "=");
2583 av_freep(&to_dealloc);
2589 if (!strcmp(key, "program_num"))
2590 progid = strtol(p2, NULL, 0);
2591 av_freep(&to_dealloc);
2595 program = av_new_program(oc, progid);
2597 p = o->program[i].u.str;
2599 const char *p2 = av_get_token(&p, ":");
2600 const char *to_dealloc = p2;
2606 key = av_get_token(&p2, "=");
2608 av_log(NULL, AV_LOG_FATAL,
2609 "No '=' character in program string %s.\n",
2617 if (!strcmp(key, "title")) {
2618 av_dict_set(&program->metadata, "title", p2, 0);
2619 } else if (!strcmp(key, "program_num")) {
2620 } else if (!strcmp(key, "st")) {
2621 int st_num = strtol(p2, NULL, 0);
2622 av_program_add_stream_index(oc, progid, st_num);
2624 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2627 av_freep(&to_dealloc);
2632 /* process manually set metadata */
2633 for (i = 0; i < o->nb_metadata; i++) {
2636 const char *stream_spec;
2637 int index = 0, j, ret = 0;
2639 val = strchr(o->metadata[i].u.str, '=');
2641 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2642 o->metadata[i].u.str);
2647 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2649 for (j = 0; j < oc->nb_streams; j++) {
2650 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2651 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2652 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2654 double theta = av_strtod(val, &tail);
2656 ost->rotate_overridden = 1;
2657 ost->rotate_override_value = theta;
2660 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2672 if (index < 0 || index >= oc->nb_chapters) {
2673 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2676 m = &oc->chapters[index]->metadata;
2679 if (index < 0 || index >= oc->nb_programs) {
2680 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2683 m = &oc->programs[index]->metadata;
2686 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2689 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2696 static int opt_target(void *optctx, const char *opt, const char *arg)
2698 OptionsContext *o = optctx;
2699 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2700 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2702 if (!strncmp(arg, "pal-", 4)) {
2705 } else if (!strncmp(arg, "ntsc-", 5)) {
2708 } else if (!strncmp(arg, "film-", 5)) {
2712 /* Try to determine PAL/NTSC by peeking in the input files */
2713 if (nb_input_files) {
2715 for (j = 0; j < nb_input_files; j++) {
2716 for (i = 0; i < input_files[j]->nb_streams; i++) {
2717 AVStream *st = input_files[j]->ctx->streams[i];
2718 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2720 fr = st->time_base.den * 1000 / st->time_base.num;
2724 } else if ((fr == 29970) || (fr == 23976)) {
2729 if (norm != UNKNOWN)
2733 if (norm != UNKNOWN)
2734 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2737 if (norm == UNKNOWN) {
2738 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2739 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2740 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2744 if (!strcmp(arg, "vcd")) {
2745 opt_video_codec(o, "c:v", "mpeg1video");
2746 opt_audio_codec(o, "c:a", "mp2");
2747 parse_option(o, "f", "vcd", options);
2749 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2750 parse_option(o, "r", frame_rates[norm], options);
2751 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2753 opt_default(NULL, "b:v", "1150000");
2754 opt_default(NULL, "maxrate:v", "1150000");
2755 opt_default(NULL, "minrate:v", "1150000");
2756 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2758 opt_default(NULL, "b:a", "224000");
2759 parse_option(o, "ar", "44100", options);
2760 parse_option(o, "ac", "2", options);
2762 opt_default(NULL, "packetsize", "2324");
2763 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2765 /* We have to offset the PTS, so that it is consistent with the SCR.
2766 SCR starts at 36000, but the first two packs contain only padding
2767 and the first pack from the other stream, respectively, may also have
2768 been written before.
2769 So the real data starts at SCR 36000+3*1200. */
2770 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2771 } else if (!strcmp(arg, "svcd")) {
2773 opt_video_codec(o, "c:v", "mpeg2video");
2774 opt_audio_codec(o, "c:a", "mp2");
2775 parse_option(o, "f", "svcd", options);
2777 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2778 parse_option(o, "r", frame_rates[norm], options);
2779 parse_option(o, "pix_fmt", "yuv420p", options);
2780 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2782 opt_default(NULL, "b:v", "2040000");
2783 opt_default(NULL, "maxrate:v", "2516000");
2784 opt_default(NULL, "minrate:v", "0"); // 1145000;
2785 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2786 opt_default(NULL, "scan_offset", "1");
2788 opt_default(NULL, "b:a", "224000");
2789 parse_option(o, "ar", "44100", options);
2791 opt_default(NULL, "packetsize", "2324");
2793 } else if (!strcmp(arg, "dvd")) {
2795 opt_video_codec(o, "c:v", "mpeg2video");
2796 opt_audio_codec(o, "c:a", "ac3");
2797 parse_option(o, "f", "dvd", options);
2799 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2800 parse_option(o, "r", frame_rates[norm], options);
2801 parse_option(o, "pix_fmt", "yuv420p", options);
2802 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2804 opt_default(NULL, "b:v", "6000000");
2805 opt_default(NULL, "maxrate:v", "9000000");
2806 opt_default(NULL, "minrate:v", "0"); // 1500000;
2807 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2809 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2810 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2812 opt_default(NULL, "b:a", "448000");
2813 parse_option(o, "ar", "48000", options);
2815 } else if (!strncmp(arg, "dv", 2)) {
2817 parse_option(o, "f", "dv", options);
2819 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2820 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2821 norm == PAL ? "yuv420p" : "yuv411p", options);
2822 parse_option(o, "r", frame_rates[norm], options);
2824 parse_option(o, "ar", "48000", options);
2825 parse_option(o, "ac", "2", options);
2828 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2829 return AVERROR(EINVAL);
2832 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2833 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2838 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2840 av_free (vstats_filename);
2841 vstats_filename = av_strdup (arg);
2845 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2848 time_t today2 = time(NULL);
2849 struct tm *today = localtime(&today2);
2851 if (!today) { // maybe tomorrow
2852 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2856 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2858 return opt_vstats_file(NULL, opt, filename);
2861 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2863 OptionsContext *o = optctx;
2864 return parse_option(o, "frames:v", arg, options);
2867 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2869 OptionsContext *o = optctx;
2870 return parse_option(o, "frames:a", arg, options);
2873 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2875 OptionsContext *o = optctx;
2876 return parse_option(o, "frames:d", arg, options);
2879 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2882 AVDictionary *cbak = codec_opts;
2883 AVDictionary *fbak = format_opts;
2887 ret = opt_default(NULL, opt, arg);
2889 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2890 av_dict_copy(&o->g->format_opts, format_opts, 0);
2891 av_dict_free(&codec_opts);
2892 av_dict_free(&format_opts);
2899 static int opt_preset(void *optctx, const char *opt, const char *arg)
2901 OptionsContext *o = optctx;
2903 char filename[1000], line[1000], tmp_line[1000];
2904 const char *codec_name = NULL;
2908 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2910 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2911 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2912 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2914 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2918 while (fgets(line, sizeof(line), f)) {
2919 char *key = tmp_line, *value, *endptr;
2921 if (strcspn(line, "#\n\r") == 0)
2923 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2924 if (!av_strtok(key, "=", &value) ||
2925 !av_strtok(value, "\r\n", &endptr)) {
2926 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2929 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2931 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2932 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2933 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2934 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2935 else if (opt_default_new(o, key, value) < 0) {
2936 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2937 filename, line, key, value);
2947 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2949 OptionsContext *o = optctx;
2950 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2951 int ret = parse_option(o, s, arg, options);
2956 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2958 OptionsContext *o = optctx;
2960 if(!strcmp(opt, "ab")){
2961 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2963 } else if(!strcmp(opt, "b")){
2964 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2965 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2968 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2972 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2974 OptionsContext *o = optctx;
2977 if(!strcmp(opt, "qscale")){
2978 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2979 return parse_option(o, "q:v", arg, options);
2981 s = av_asprintf("q%s", opt + 6);
2982 ret = parse_option(o, s, arg, options);
2987 static int opt_profile(void *optctx, const char *opt, const char *arg)
2989 OptionsContext *o = optctx;
2990 if(!strcmp(opt, "profile")){
2991 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2992 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2995 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2999 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3001 OptionsContext *o = optctx;
3002 return parse_option(o, "filter:v", arg, options);
3005 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3007 OptionsContext *o = optctx;
3008 return parse_option(o, "filter:a", arg, options);
3011 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3013 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3014 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3015 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3016 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3018 if (video_sync_method == VSYNC_AUTO)
3019 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3023 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3025 OptionsContext *o = optctx;
3026 char *tcr = av_asprintf("timecode=%s", arg);
3027 int ret = parse_option(o, "metadata:g", tcr, options);
3029 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3034 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3036 OptionsContext *o = optctx;
3037 char layout_str[32];
3040 int ret, channels, ac_str_size;
3043 layout = av_get_channel_layout(arg);
3045 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3046 return AVERROR(EINVAL);
3048 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3049 ret = opt_default_new(o, opt, layout_str);
3053 /* set 'ac' option based on channel layout */
3054 channels = av_get_channel_layout_nb_channels(layout);
3055 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3056 stream_str = strchr(opt, ':');
3057 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3058 ac_str = av_mallocz(ac_str_size);
3060 return AVERROR(ENOMEM);
3061 av_strlcpy(ac_str, "ac", 3);
3063 av_strlcat(ac_str, stream_str, ac_str_size);
3064 ret = parse_option(o, ac_str, layout_str, options);
3070 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3072 OptionsContext *o = optctx;
3073 return parse_option(o, "q:a", arg, options);
3076 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3078 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3079 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3080 return AVERROR(ENOMEM);
3081 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3082 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3083 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3084 return AVERROR(ENOMEM);
3086 input_stream_potentially_available = 1;
3091 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3093 uint8_t *graph_desc = read_file(arg);
3095 return AVERROR(EINVAL);
3097 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3098 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3099 return AVERROR(ENOMEM);
3100 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3101 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3103 input_stream_potentially_available = 1;
3108 void show_help_default(const char *opt, const char *arg)
3110 /* per-file options have at least one of those set */
3111 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3112 int show_advanced = 0, show_avoptions = 0;
3115 if (!strcmp(opt, "long"))
3117 else if (!strcmp(opt, "full"))
3118 show_advanced = show_avoptions = 1;
3120 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3125 printf("Getting help:\n"
3126 " -h -- print basic options\n"
3127 " -h long -- print more options\n"
3128 " -h full -- print all options (including all format and codec specific options, very long)\n"
3129 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3130 " See man %s for detailed description of the options.\n"
3131 "\n", program_name);
3133 show_help_options(options, "Print help / information / capabilities:",
3136 show_help_options(options, "Global options (affect whole program "
3137 "instead of just one file:",
3138 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3140 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3141 per_file | OPT_EXIT, 0);
3143 show_help_options(options, "Per-file main options:", 0,
3144 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3145 OPT_EXIT, per_file);
3147 show_help_options(options, "Advanced per-file options:",
3148 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3150 show_help_options(options, "Video options:",
3151 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3153 show_help_options(options, "Advanced Video options:",
3154 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3156 show_help_options(options, "Audio options:",
3157 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3159 show_help_options(options, "Advanced Audio options:",
3160 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3161 show_help_options(options, "Subtitle options:",
3162 OPT_SUBTITLE, 0, 0);
3165 if (show_avoptions) {
3166 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3167 show_help_children(avcodec_get_class(), flags);
3168 show_help_children(avformat_get_class(), flags);
3170 show_help_children(sws_get_class(), flags);
3172 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3173 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3177 void show_usage(void)
3179 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3180 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3181 av_log(NULL, AV_LOG_INFO, "\n");
3189 static const OptionGroupDef groups[] = {
3190 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3191 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3194 static int open_files(OptionGroupList *l, const char *inout,
3195 int (*open_file)(OptionsContext*, const char*))
3199 for (i = 0; i < l->nb_groups; i++) {
3200 OptionGroup *g = &l->groups[i];
3206 ret = parse_optgroup(&o, g);
3208 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3209 "%s.\n", inout, g->arg);
3213 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3214 ret = open_file(&o, g->arg);
3217 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3221 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3227 int ffmpeg_parse_options(int argc, char **argv)
3229 OptionParseContext octx;
3233 memset(&octx, 0, sizeof(octx));
3235 /* split the commandline into an internal representation */
3236 ret = split_commandline(&octx, argc, argv, options, groups,
3237 FF_ARRAY_ELEMS(groups));
3239 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3243 /* apply global options */
3244 ret = parse_optgroup(NULL, &octx.global_opts);
3246 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3250 /* configure terminal and setup signal handlers */
3253 /* open input files */
3254 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3256 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3260 /* create the complex filtergraphs */
3261 ret = init_complex_filters();
3263 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3267 /* open output files */
3268 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3270 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3274 check_filter_outputs();
3277 uninit_parse_context(&octx);
3279 av_strerror(ret, error, sizeof(error));
3280 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3285 static int opt_progress(void *optctx, const char *opt, const char *arg)
3287 AVIOContext *avio = NULL;
3290 if (!strcmp(arg, "-"))
3292 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3294 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3295 arg, av_err2str(ret));
3298 progress_avio = avio;
3302 #define OFFSET(x) offsetof(OptionsContext, x)
3303 const OptionDef options[] = {
3305 CMDUTILS_COMMON_OPTIONS
3306 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3307 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3308 "force format", "fmt" },
3309 { "y", OPT_BOOL, { &file_overwrite },
3310 "overwrite output files" },
3311 { "n", OPT_BOOL, { &no_file_overwrite },
3312 "never overwrite output files" },
3313 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3314 "Ignore unknown stream types" },
3315 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3316 "Copy unknown stream types" },
3317 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3318 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3319 "codec name", "codec" },
3320 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3321 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3322 "codec name", "codec" },
3323 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3324 OPT_OUTPUT, { .off = OFFSET(presets) },
3325 "preset name", "preset" },
3326 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3327 OPT_OUTPUT, { .func_arg = opt_map },
3328 "set input stream mapping",
3329 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3330 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3331 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3332 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3333 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3334 "set metadata information of outfile from infile",
3335 "outfile[,metadata]:infile[,metadata]" },
3336 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3337 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3338 "set chapters mapping", "input_file_index" },
3339 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3340 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3341 "record or transcode \"duration\" seconds of audio/video",
3343 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3344 "record or transcode stop time", "time_stop" },
3345 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3346 "set the limit file size in bytes", "limit_size" },
3347 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3348 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3349 "set the start time offset", "time_off" },
3350 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3351 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3352 "set the start time offset relative to EOF", "time_off" },
3353 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3354 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3355 "enable/disable seeking by timestamp with -ss" },
3356 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3357 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3358 "enable/disable accurate seeking with -ss" },
3359 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3360 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3361 "set the input ts offset", "time_off" },
3362 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3363 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3364 "set the input ts scale", "scale" },
3365 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3366 "set the recording timestamp ('now' to set the current time)", "time" },
3367 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3368 "add metadata", "string=string" },
3369 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3370 "add program with specified streams", "title=string:st=number..." },
3371 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3372 OPT_OUTPUT, { .func_arg = opt_data_frames },
3373 "set the number of data frames to output", "number" },
3374 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3375 "add timings for benchmarking" },
3376 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3377 "add timings for each task" },
3378 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3379 "write program-readable progress information", "url" },
3380 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3381 "enable or disable interaction on standard input" },
3382 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3383 "set max runtime in seconds", "limit" },
3384 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3385 "dump each input packet" },
3386 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3387 "when dumping packets, also dump the payload" },
3388 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3389 OPT_INPUT, { .off = OFFSET(rate_emu) },
3390 "read input at native frame rate", "" },
3391 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3392 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3393 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3394 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3395 "video sync method", "" },
3396 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3397 "frame drop threshold", "" },
3398 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3399 "audio sync method", "" },
3400 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3401 "audio drift threshold", "threshold" },
3402 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3403 "copy timestamps" },
3404 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3405 "shift input timestamps to start at 0 when using copyts" },
3406 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3407 "copy input stream time base when stream copying", "mode" },
3408 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3409 OPT_OUTPUT, { .off = OFFSET(shortest) },
3410 "finish encoding within shortest input" },
3411 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3412 OPT_OUTPUT, { .off = OFFSET(apad) },
3414 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3415 "timestamp discontinuity delta threshold", "threshold" },
3416 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3417 "timestamp error delta threshold", "threshold" },
3418 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3419 "exit on error", "error" },
3420 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3421 "abort on the specified condition flags", "flags" },
3422 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3423 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3424 "copy initial non-keyframes" },
3425 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3426 "copy or discard frames before start time" },
3427 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3428 "set the number of frames to output", "number" },
3429 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3430 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3431 "force codec tag/fourcc", "fourcc/tag" },
3432 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3433 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3434 "use fixed quality scale (VBR)", "q" },
3435 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3436 OPT_OUTPUT, { .func_arg = opt_qscale },
3437 "use fixed quality scale (VBR)", "q" },
3438 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3439 "set profile", "profile" },
3440 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3441 "set stream filtergraph", "filter_graph" },
3442 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3443 "number of non-complex filter threads" },
3444 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3445 "read stream filtergraph description from a file", "filename" },
3446 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3447 "reinit filtergraph on input parameter changes", "" },
3448 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3449 "create a complex filtergraph", "graph_description" },
3450 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3451 "number of threads for -filter_complex" },
3452 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3453 "create a complex filtergraph", "graph_description" },
3454 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3455 "read complex filtergraph description from a file", "filename" },
3456 { "stats", OPT_BOOL, { &print_stats },
3457 "print progress report during encoding", },
3458 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3459 OPT_OUTPUT, { .func_arg = opt_attach },
3460 "add an attachment to the output file", "filename" },
3461 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3462 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3463 "extract an attachment into a file", "filename" },
3464 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3465 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3466 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3467 "print timestamp debugging info" },
3468 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3469 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3470 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3471 OPT_INPUT, { .off = OFFSET(discard) },
3473 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3474 OPT_OUTPUT, { .off = OFFSET(disposition) },
3475 "disposition", "" },
3476 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3477 { .off = OFFSET(thread_queue_size) },
3478 "set the maximum number of queued packets from the demuxer" },
3481 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3482 "set the number of video frames to output", "number" },
3483 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3484 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3485 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3486 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3487 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3488 "set frame size (WxH or abbreviation)", "size" },
3489 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3490 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3491 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3492 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3493 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3494 "set pixel format", "format" },
3495 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3496 "set the number of bits per raw sample", "number" },
3497 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3498 "deprecated use -g 1" },
3499 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3501 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3502 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3503 "rate control override for specific intervals", "override" },
3504 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3505 OPT_OUTPUT, { .func_arg = opt_video_codec },
3506 "force video codec ('copy' to copy stream)", "codec" },
3507 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3509 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3511 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3512 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3513 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3514 "select the pass number (1 to 3)", "n" },
3515 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3516 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3517 "select two pass log file name prefix", "prefix" },
3518 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3519 "this option is deprecated, use the yadif filter instead" },
3520 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3521 "calculate PSNR of compressed frames" },
3522 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3523 "dump video coding statistics to file" },
3524 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3525 "dump video coding statistics to file", "file" },
3526 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3527 "Version of the vstats format to use."},
3528 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3529 "set video filters", "filter_graph" },
3530 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3531 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3532 "specify intra matrix coeffs", "matrix" },
3533 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3534 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3535 "specify inter matrix coeffs", "matrix" },
3536 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3537 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3538 "specify intra matrix coeffs", "matrix" },
3539 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3540 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3541 "top=1/bottom=0/auto=-1 field first", "" },
3542 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3543 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3544 "force video tag/fourcc", "fourcc/tag" },
3545 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3546 "show QP histogram" },
3547 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3548 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3549 "force the selected framerate, disable the best supported framerate selection" },
3550 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3551 OPT_OUTPUT, { .func_arg = opt_streamid },
3552 "set the value of an outfile streamid", "streamIndex:value" },
3553 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3554 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3555 "force key frames at specified timestamps", "timestamps" },
3556 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3557 "audio bitrate (please use -b:a)", "bitrate" },
3558 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3559 "video bitrate (please use -b:v)", "bitrate" },
3560 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3561 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3562 "use HW accelerated decoding", "hwaccel name" },
3563 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3564 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3565 "select a device for HW acceleration", "devicename" },
3566 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3567 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3568 "select output format used with HW accelerated decoding", "format" },
3569 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3570 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3572 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3573 "show available HW acceleration methods" },
3574 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3575 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3576 "automatically insert correct rotate filters" },
3577 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3578 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3581 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3582 "set the number of audio frames to output", "number" },
3583 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3584 "set audio quality (codec-specific)", "quality", },
3585 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3586 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3587 "set audio sampling rate (in Hz)", "rate" },
3588 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3589 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3590 "set number of audio channels", "channels" },
3591 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3593 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3594 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3595 "force audio codec ('copy' to copy stream)", "codec" },
3596 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3597 OPT_OUTPUT, { .func_arg = opt_old2new },
3598 "force audio tag/fourcc", "fourcc/tag" },
3599 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3600 "change audio volume (256=normal)" , "volume" },
3601 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3602 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3603 "set sample format", "format" },
3604 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3605 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3606 "set channel layout", "layout" },
3607 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3608 "set audio filters", "filter_graph" },
3609 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3610 "set the maximum number of channels to try to guess the channel layout" },
3612 /* subtitle options */
3613 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3614 "disable subtitle" },
3615 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3616 "force subtitle codec ('copy' to copy stream)", "codec" },
3617 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3618 , "force subtitle tag/fourcc", "fourcc/tag" },
3619 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3620 "fix subtitles duration" },
3621 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3622 "set canvas size (WxH or abbreviation)", "size" },
3625 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3626 "deprecated, use -channel", "channel" },
3627 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3628 "deprecated, use -standard", "standard" },
3629 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3632 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3633 "set the maximum demux-decode delay", "seconds" },
3634 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3635 "set the initial demux-decode delay", "seconds" },
3636 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3637 "override the options from ffserver", "" },
3638 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3639 "specify a file in which to print sdp information", "file" },
3641 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3642 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3643 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3644 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3645 "two special values are defined - "
3646 "0 = use frame rate (video) or sample rate (audio),"
3647 "-1 = match source time base", "ratio" },
3649 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3650 "A comma-separated list of bitstream filters", "bitstream_filters" },
3651 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3652 "deprecated", "audio bitstream_filters" },
3653 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3654 "deprecated", "video bitstream_filters" },
3656 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3657 "set the audio options to the indicated preset", "preset" },
3658 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3659 "set the video options to the indicated preset", "preset" },
3660 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3661 "set the subtitle options to the indicated preset", "preset" },
3662 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3663 "set options from indicated preset file", "filename" },
3665 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3666 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3668 /* data codec support */
3669 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3670 "force data codec ('copy' to copy stream)", "codec" },
3671 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3675 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3676 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3680 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3681 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},