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; i < FF_ARRAY_ELEMS(hwaccels) - 1; 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 if (o->nb_audio_sample_rate) {
931 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
933 if (o->nb_audio_channels) {
934 /* because we set audio_channels based on both the "ac" and
935 * "channel_layout" options, we need to check that the specified
936 * demuxer actually has the "channels" option before setting it */
937 if (file_iformat && file_iformat->priv_class &&
938 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
939 AV_OPT_SEARCH_FAKE_OBJ)) {
940 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
943 if (o->nb_frame_rates) {
944 /* set the format-level framerate option;
945 * this is important for video grabbers, e.g. x11 */
946 if (file_iformat && file_iformat->priv_class &&
947 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
948 AV_OPT_SEARCH_FAKE_OBJ)) {
949 av_dict_set(&o->g->format_opts, "framerate",
950 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
953 if (o->nb_frame_sizes) {
954 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
956 if (o->nb_frame_pix_fmts)
957 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
959 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
960 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
961 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
962 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
964 ic->video_codec_id = video_codec_name ?
965 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
966 ic->audio_codec_id = audio_codec_name ?
967 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
968 ic->subtitle_codec_id= subtitle_codec_name ?
969 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
970 ic->data_codec_id = data_codec_name ?
971 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
973 if (video_codec_name)
974 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
975 if (audio_codec_name)
976 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
977 if (subtitle_codec_name)
978 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
980 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
982 ic->flags |= AVFMT_FLAG_NONBLOCK;
983 ic->interrupt_callback = int_cb;
985 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
986 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
987 scan_all_pmts_set = 1;
989 /* open the input file with generic avformat function */
990 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
992 print_error(filename, err);
993 if (err == AVERROR_PROTOCOL_NOT_FOUND)
994 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
997 if (scan_all_pmts_set)
998 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
999 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1000 assert_avoptions(o->g->format_opts);
1002 /* apply forced codec ids */
1003 for (i = 0; i < ic->nb_streams; i++)
1004 choose_decoder(o, ic, ic->streams[i]);
1006 /* Set AVCodecContext options for avformat_find_stream_info */
1007 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1008 orig_nb_streams = ic->nb_streams;
1010 /* If not enough info to get the stream parameters, we decode the
1011 first frames to get it. (used in mpeg case for example) */
1012 ret = avformat_find_stream_info(ic, opts);
1014 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1015 if (ic->nb_streams == 0) {
1016 avformat_close_input(&ic);
1021 if (o->start_time_eof != AV_NOPTS_VALUE) {
1022 if (ic->duration>0) {
1023 o->start_time = o->start_time_eof + ic->duration;
1025 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1027 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1028 /* add the stream start time */
1029 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1030 timestamp += ic->start_time;
1032 /* if seeking requested, we execute it */
1033 if (o->start_time != AV_NOPTS_VALUE) {
1034 int64_t seek_timestamp = timestamp;
1036 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1037 int dts_heuristic = 0;
1038 for (i=0; i<ic->nb_streams; i++) {
1039 const AVCodecParameters *par = ic->streams[i]->codecpar;
1040 if (par->video_delay)
1043 if (dts_heuristic) {
1044 seek_timestamp -= 3*AV_TIME_BASE / 23;
1047 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1049 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1050 filename, (double)timestamp / AV_TIME_BASE);
1054 /* update the current parameters so that they match the one of the input stream */
1055 add_input_streams(o, ic);
1057 /* dump the file content */
1058 av_dump_format(ic, nb_input_files, filename, 0);
1060 GROW_ARRAY(input_files, nb_input_files);
1061 f = av_mallocz(sizeof(*f));
1064 input_files[nb_input_files - 1] = f;
1067 f->ist_index = nb_input_streams - ic->nb_streams;
1068 f->start_time = o->start_time;
1069 f->recording_time = o->recording_time;
1070 f->input_ts_offset = o->input_ts_offset;
1071 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1072 f->nb_streams = ic->nb_streams;
1073 f->rate_emu = o->rate_emu;
1074 f->accurate_seek = o->accurate_seek;
1077 f->time_base = (AVRational){ 1, 1 };
1079 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1082 /* check if all codec options have been used */
1083 unused_opts = strip_specifiers(o->g->codec_opts);
1084 for (i = f->ist_index; i < nb_input_streams; i++) {
1086 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1087 AV_DICT_IGNORE_SUFFIX)))
1088 av_dict_set(&unused_opts, e->key, NULL, 0);
1092 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1093 const AVClass *class = avcodec_get_class();
1094 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1095 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1096 const AVClass *fclass = avformat_get_class();
1097 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1098 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1099 if (!option || foption)
1103 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1104 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1105 "input file #%d (%s) is not a decoding option.\n", e->key,
1106 option->help ? option->help : "", nb_input_files - 1,
1111 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1112 "input file #%d (%s) has not been used for any stream. The most "
1113 "likely reason is either wrong type (e.g. a video option with "
1114 "no video streams) or that it is a private option of some decoder "
1115 "which was not actually used for any stream.\n", e->key,
1116 option->help ? option->help : "", nb_input_files - 1, filename);
1118 av_dict_free(&unused_opts);
1120 for (i = 0; i < o->nb_dump_attachment; i++) {
1123 for (j = 0; j < ic->nb_streams; j++) {
1124 AVStream *st = ic->streams[j];
1126 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1127 dump_attachment(st, o->dump_attachment[i].u.str);
1131 for (i = 0; i < orig_nb_streams; i++)
1132 av_dict_free(&opts[i]);
1135 input_stream_potentially_available = 1;
1140 static uint8_t *get_line(AVIOContext *s)
1146 if (avio_open_dyn_buf(&line) < 0) {
1147 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1151 while ((c = avio_r8(s)) && c != '\n')
1154 avio_close_dyn_buf(line, &buf);
1159 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1162 char filename[1000];
1163 const char *base[3] = { getenv("AVCONV_DATADIR"),
1168 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1172 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1173 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1174 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1177 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1178 i != 1 ? "" : "/.avconv", preset_name);
1179 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1185 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1187 enum AVMediaType type = ost->st->codecpar->codec_type;
1188 char *codec_name = NULL;
1190 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1191 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1193 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1194 NULL, ost->st->codecpar->codec_type);
1195 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1197 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1198 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1199 "probably disabled. Please choose an encoder manually.\n",
1200 ost->file_index, ost->index, s->oformat->name,
1201 avcodec_get_name(ost->st->codecpar->codec_id));
1202 return AVERROR_ENCODER_NOT_FOUND;
1204 } else if (!strcmp(codec_name, "copy"))
1205 ost->stream_copy = 1;
1207 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1208 ost->st->codecpar->codec_id = ost->enc->id;
1210 ost->encoding_needed = !ost->stream_copy;
1212 /* no encoding supported for other media types */
1213 ost->stream_copy = 1;
1214 ost->encoding_needed = 0;
1220 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1223 AVStream *st = avformat_new_stream(oc, NULL);
1224 int idx = oc->nb_streams - 1, ret = 0;
1225 const char *bsfs = NULL, *time_base = NULL;
1226 char *next, *codec_tag = NULL;
1231 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1235 if (oc->nb_streams - 1 < o->nb_streamid_map)
1236 st->id = o->streamid_map[oc->nb_streams - 1];
1238 GROW_ARRAY(output_streams, nb_output_streams);
1239 if (!(ost = av_mallocz(sizeof(*ost))))
1241 output_streams[nb_output_streams - 1] = ost;
1243 ost->file_index = nb_output_files - 1;
1246 st->codecpar->codec_type = type;
1248 ret = choose_encoder(o, oc, ost);
1250 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1251 "%d:%d\n", ost->file_index, ost->index);
1255 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1256 if (!ost->enc_ctx) {
1257 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1260 ost->enc_ctx->codec_type = type;
1262 ost->ref_par = avcodec_parameters_alloc();
1263 if (!ost->ref_par) {
1264 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1269 AVIOContext *s = NULL;
1270 char *buf = NULL, *arg = NULL, *preset = NULL;
1272 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1274 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1275 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1278 if (!buf[0] || buf[0] == '#') {
1282 if (!(arg = strchr(buf, '='))) {
1283 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1287 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1289 } while (!s->eof_reached);
1293 av_log(NULL, AV_LOG_FATAL,
1294 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1295 preset, ost->file_index, ost->index);
1299 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1302 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1305 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1306 q.num <= 0 || q.den <= 0) {
1307 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1313 ost->max_frames = INT64_MAX;
1314 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1315 for (i = 0; i<o->nb_max_frames; i++) {
1316 char *p = o->max_frames[i].specifier;
1317 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1318 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1323 ost->copy_prior_start = -1;
1324 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1326 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1327 while (bsfs && *bsfs) {
1328 const AVBitStreamFilter *filter;
1329 char *bsf, *bsf_options_str, *bsf_name;
1331 bsf = av_get_token(&bsfs, ",");
1334 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1338 filter = av_bsf_get_by_name(bsf_name);
1340 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1344 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1345 ost->nb_bitstream_filters + 1,
1346 sizeof(*ost->bsf_ctx));
1350 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1352 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1356 ost->nb_bitstream_filters++;
1358 if (bsf_options_str && filter->priv_class) {
1359 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1360 const char * shorthand[2] = {NULL};
1363 shorthand[0] = opt->name;
1365 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1367 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1376 if (ost->nb_bitstream_filters) {
1377 ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1378 if (!ost->bsf_extradata_updated) {
1379 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1384 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1386 uint32_t tag = strtol(codec_tag, &next, 0);
1388 tag = AV_RL32(codec_tag);
1389 ost->st->codecpar->codec_tag =
1390 ost->enc_ctx->codec_tag = tag;
1393 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1395 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1396 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1399 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1400 ost->disposition = av_strdup(ost->disposition);
1402 ost->max_muxing_queue_size = 128;
1403 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1404 ost->max_muxing_queue_size *= sizeof(AVPacket);
1406 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1407 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1409 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1411 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1412 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1413 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1415 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1417 ost->source_index = source_index;
1418 if (source_index >= 0) {
1419 ost->sync_ist = input_streams[source_index];
1420 input_streams[source_index]->discard = 0;
1421 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1423 ost->last_mux_dts = AV_NOPTS_VALUE;
1425 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1426 if (!ost->muxing_queue)
1432 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1435 const char *p = str;
1442 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1449 /* read file contents into a string */
1450 static uint8_t *read_file(const char *filename)
1452 AVIOContext *pb = NULL;
1453 AVIOContext *dyn_buf = NULL;
1454 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1455 uint8_t buf[1024], *str;
1458 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1462 ret = avio_open_dyn_buf(&dyn_buf);
1467 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1468 avio_write(dyn_buf, buf, ret);
1469 avio_w8(dyn_buf, 0);
1472 ret = avio_close_dyn_buf(dyn_buf, &str);
1478 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1481 AVStream *st = ost->st;
1483 if (ost->filters_script && ost->filters) {
1484 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1485 "output stream #%d:%d.\n", nb_output_files, st->index);
1489 if (ost->filters_script)
1490 return read_file(ost->filters_script);
1491 else if (ost->filters)
1492 return av_strdup(ost->filters);
1494 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1498 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1499 const OutputStream *ost, enum AVMediaType type)
1501 if (ost->filters_script || ost->filters) {
1502 av_log(NULL, AV_LOG_ERROR,
1503 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1504 "Filtering and streamcopy cannot be used together.\n",
1505 ost->filters ? "Filtergraph" : "Filtergraph script",
1506 ost->filters ? ost->filters : ost->filters_script,
1507 av_get_media_type_string(type), ost->file_index, ost->index);
1512 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1516 AVCodecContext *video_enc;
1517 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1519 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1521 video_enc = ost->enc_ctx;
1523 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1524 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1525 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1528 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1529 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1531 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1532 if (frame_aspect_ratio) {
1534 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1535 q.num <= 0 || q.den <= 0) {
1536 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1539 ost->frame_aspect_ratio = q;
1542 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1543 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1545 if (!ost->stream_copy) {
1546 const char *p = NULL;
1547 char *frame_size = NULL;
1548 char *frame_pix_fmt = NULL;
1549 char *intra_matrix = NULL, *inter_matrix = NULL;
1550 char *chroma_intra_matrix = NULL;
1554 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1555 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1556 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1560 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1561 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1562 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1563 ost->keep_pix_fmt = 1;
1564 if (!*++frame_pix_fmt)
1565 frame_pix_fmt = NULL;
1567 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1568 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1571 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1574 video_enc->gop_size = 0;
1575 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1577 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1578 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1581 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1583 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1584 if (chroma_intra_matrix) {
1585 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1587 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1590 av_codec_set_chroma_intra_matrix(video_enc, p);
1591 parse_matrix_coeffs(p, chroma_intra_matrix);
1593 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1595 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1596 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1599 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1602 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1603 for (i = 0; p; i++) {
1605 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1607 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1610 video_enc->rc_override =
1611 av_realloc_array(video_enc->rc_override,
1612 i + 1, sizeof(RcOverride));
1613 if (!video_enc->rc_override) {
1614 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1617 video_enc->rc_override[i].start_frame = start;
1618 video_enc->rc_override[i].end_frame = end;
1620 video_enc->rc_override[i].qscale = q;
1621 video_enc->rc_override[i].quality_factor = 1.0;
1624 video_enc->rc_override[i].qscale = 0;
1625 video_enc->rc_override[i].quality_factor = -q/100.0;
1630 video_enc->rc_override_count = i;
1633 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1636 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1639 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1640 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1643 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1644 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1648 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1649 if (ost->logfile_prefix &&
1650 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1654 char logfilename[1024];
1657 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1658 ost->logfile_prefix ? ost->logfile_prefix :
1659 DEFAULT_PASS_LOGFILENAME_PREFIX,
1661 if (!strcmp(ost->enc->name, "libx264")) {
1662 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1664 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1665 char *logbuffer = read_file(logfilename);
1668 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1672 video_enc->stats_in = logbuffer;
1674 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1675 f = av_fopen_utf8(logfilename, "wb");
1677 av_log(NULL, AV_LOG_FATAL,
1678 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1679 logfilename, strerror(errno));
1687 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1688 if (ost->forced_keyframes)
1689 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1691 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1693 ost->top_field_first = -1;
1694 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1697 ost->avfilter = get_ost_filters(o, oc, ost);
1701 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1704 if (ost->stream_copy)
1705 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1710 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1715 AVCodecContext *audio_enc;
1717 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1720 audio_enc = ost->enc_ctx;
1721 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1723 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1724 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1726 if (!ost->stream_copy) {
1727 char *sample_fmt = NULL;
1729 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1731 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1733 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1734 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1738 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1740 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1741 ost->apad = av_strdup(ost->apad);
1743 ost->avfilter = get_ost_filters(o, oc, ost);
1747 /* check for channel mapping for this audio stream */
1748 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1749 AudioChannelMap *map = &o->audio_channel_maps[n];
1750 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1751 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1754 if (map->channel_idx == -1) {
1756 } else if (ost->source_index < 0) {
1757 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1758 ost->file_index, ost->st->index);
1761 ist = input_streams[ost->source_index];
1764 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1765 if (av_reallocp_array(&ost->audio_channels_map,
1766 ost->audio_channels_mapped + 1,
1767 sizeof(*ost->audio_channels_map)
1771 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1777 if (ost->stream_copy)
1778 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1783 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1787 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1788 if (!ost->stream_copy) {
1789 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1796 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1800 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1801 if (!ost->stream_copy) {
1802 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1809 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1811 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1812 ost->stream_copy = 1;
1817 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1821 AVCodecContext *subtitle_enc;
1823 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1825 subtitle_enc = ost->enc_ctx;
1827 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1829 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1831 if (!ost->stream_copy) {
1832 char *frame_size = NULL;
1834 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1835 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1836 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1844 /* arg format is "output-stream-index:streamid-value". */
1845 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1847 OptionsContext *o = optctx;
1852 av_strlcpy(idx_str, arg, sizeof(idx_str));
1853 p = strchr(idx_str, ':');
1855 av_log(NULL, AV_LOG_FATAL,
1856 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1861 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1862 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1863 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1867 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1869 AVFormatContext *is = ifile->ctx;
1870 AVFormatContext *os = ofile->ctx;
1874 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1876 return AVERROR(ENOMEM);
1879 for (i = 0; i < is->nb_chapters; i++) {
1880 AVChapter *in_ch = is->chapters[i], *out_ch;
1881 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1882 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1883 AV_TIME_BASE_Q, in_ch->time_base);
1884 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1885 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1888 if (in_ch->end < ts_off)
1890 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1893 out_ch = av_mallocz(sizeof(AVChapter));
1895 return AVERROR(ENOMEM);
1897 out_ch->id = in_ch->id;
1898 out_ch->time_base = in_ch->time_base;
1899 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1900 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1903 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1905 os->chapters[os->nb_chapters++] = out_ch;
1910 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1913 AVFormatContext *ic = avformat_alloc_context();
1915 ic->interrupt_callback = int_cb;
1916 err = avformat_open_input(&ic, filename, NULL, NULL);
1919 /* copy stream format */
1920 for(i=0;i<ic->nb_streams;i++) {
1924 const char *enc_config;
1926 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1928 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1929 return AVERROR(EINVAL);
1931 if (codec->type == AVMEDIA_TYPE_AUDIO)
1932 opt_audio_codec(o, "c:a", codec->name);
1933 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1934 opt_video_codec(o, "c:v", codec->name);
1935 ost = new_output_stream(o, s, codec->type, -1);
1938 avcodec_get_context_defaults3(st->codec, codec);
1939 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1941 AVDictionary *opts = NULL;
1942 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1943 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1944 av_dict_free(&opts);
1947 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1948 choose_sample_fmt(st, codec);
1949 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1950 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1951 avcodec_copy_context(ost->enc_ctx, st->codec);
1953 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1956 avformat_close_input(&ic);
1960 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1961 AVFormatContext *oc)
1965 switch (ofilter->type) {
1966 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1967 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1969 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1974 ost->source_index = -1;
1975 ost->filter = ofilter;
1978 ofilter->format = -1;
1980 if (ost->stream_copy) {
1981 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1982 "which is fed from a complex filtergraph. Filtering and streamcopy "
1983 "cannot be used together.\n", ost->file_index, ost->index);
1987 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1988 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1989 av_log(NULL, AV_LOG_ERROR,
1990 "%s '%s' was specified through the %s option "
1991 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1992 "%s and -filter_complex cannot be used together for the same stream.\n",
1993 ost->filters ? "Filtergraph" : "Filtergraph script",
1994 ost->filters ? ost->filters : ost->filters_script,
1995 opt, ost->file_index, ost->index, opt);
1999 avfilter_inout_free(&ofilter->out_tmp);
2002 static int init_complex_filters(void)
2006 for (i = 0; i < nb_filtergraphs; i++) {
2007 ret = init_complex_filtergraph(filtergraphs[i]);
2014 static int open_output_file(OptionsContext *o, const char *filename)
2016 AVFormatContext *oc;
2018 AVOutputFormat *file_oformat;
2022 AVDictionary *unused_opts = NULL;
2023 AVDictionaryEntry *e = NULL;
2024 int format_flags = 0;
2026 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2027 o->stop_time = INT64_MAX;
2028 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2031 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2032 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2033 if (o->stop_time <= start_time) {
2034 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2037 o->recording_time = o->stop_time - start_time;
2041 GROW_ARRAY(output_files, nb_output_files);
2042 of = av_mallocz(sizeof(*of));
2045 output_files[nb_output_files - 1] = of;
2047 of->ost_index = nb_output_streams;
2048 of->recording_time = o->recording_time;
2049 of->start_time = o->start_time;
2050 of->limit_filesize = o->limit_filesize;
2051 of->shortest = o->shortest;
2052 av_dict_copy(&of->opts, o->g->format_opts, 0);
2054 if (!strcmp(filename, "-"))
2057 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2059 print_error(filename, err);
2064 if (o->recording_time != INT64_MAX)
2065 oc->duration = o->recording_time;
2067 file_oformat= oc->oformat;
2068 oc->interrupt_callback = int_cb;
2070 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2072 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2073 av_opt_eval_flags(oc, o, e->value, &format_flags);
2076 /* create streams for all unlabeled output pads */
2077 for (i = 0; i < nb_filtergraphs; i++) {
2078 FilterGraph *fg = filtergraphs[i];
2079 for (j = 0; j < fg->nb_outputs; j++) {
2080 OutputFilter *ofilter = fg->outputs[j];
2082 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2085 switch (ofilter->type) {
2086 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2087 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2088 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2090 init_output_filter(ofilter, o, oc);
2094 /* ffserver seeking with date=... needs a date reference */
2095 if (!strcmp(file_oformat->name, "ffm") &&
2096 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2097 av_strstart(filename, "http:", NULL)) {
2098 int err = parse_option(o, "metadata", "creation_time=now", options);
2100 print_error(filename, err);
2105 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2106 av_strstart(filename, "http:", NULL)) {
2108 /* special case for files sent to ffserver: we get the stream
2109 parameters from ffserver */
2110 int err = read_ffserver_streams(o, oc, filename);
2112 print_error(filename, err);
2115 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2116 ost = output_streams[j];
2117 for (i = 0; i < nb_input_streams; i++) {
2118 ist = input_streams[i];
2119 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2121 ost->source_index= i;
2122 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2123 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2125 ist->st->discard = ist->user_set_discard;
2130 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));
2134 } else if (!o->nb_stream_maps) {
2135 char *subtitle_codec_name = NULL;
2136 /* pick the "best" stream of each type */
2138 /* video: highest resolution */
2139 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2140 int area = 0, idx = -1;
2141 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2142 for (i = 0; i < nb_input_streams; i++) {
2144 ist = input_streams[i];
2145 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2146 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2148 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2150 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2157 new_video_stream(o, oc, idx);
2160 /* audio: most channels */
2161 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2162 int best_score = 0, idx = -1;
2163 for (i = 0; i < nb_input_streams; i++) {
2165 ist = input_streams[i];
2166 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2167 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2168 score > best_score) {
2174 new_audio_stream(o, oc, idx);
2177 /* subtitles: pick first */
2178 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2179 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2180 for (i = 0; i < nb_input_streams; i++)
2181 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2182 AVCodecDescriptor const *input_descriptor =
2183 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2184 AVCodecDescriptor const *output_descriptor = NULL;
2185 AVCodec const *output_codec =
2186 avcodec_find_encoder(oc->oformat->subtitle_codec);
2187 int input_props = 0, output_props = 0;
2189 output_descriptor = avcodec_descriptor_get(output_codec->id);
2190 if (input_descriptor)
2191 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2192 if (output_descriptor)
2193 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2194 if (subtitle_codec_name ||
2195 input_props & output_props ||
2196 // Map dvb teletext which has neither property to any output subtitle encoder
2197 input_descriptor && output_descriptor &&
2198 (!input_descriptor->props ||
2199 !output_descriptor->props)) {
2200 new_subtitle_stream(o, oc, i);
2205 /* Data only if codec id match */
2206 if (!o->data_disable ) {
2207 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2208 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2209 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2210 && input_streams[i]->st->codecpar->codec_id == codec_id )
2211 new_data_stream(o, oc, i);
2215 for (i = 0; i < o->nb_stream_maps; i++) {
2216 StreamMap *map = &o->stream_maps[i];
2221 if (map->linklabel) {
2223 OutputFilter *ofilter = NULL;
2226 for (j = 0; j < nb_filtergraphs; j++) {
2227 fg = filtergraphs[j];
2228 for (k = 0; k < fg->nb_outputs; k++) {
2229 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2230 if (out && !strcmp(out->name, map->linklabel)) {
2231 ofilter = fg->outputs[k];
2238 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2239 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2242 init_output_filter(ofilter, o, oc);
2244 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2246 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2247 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2249 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2251 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2253 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2257 switch (ist->st->codecpar->codec_type) {
2258 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2259 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2260 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2261 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2262 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2263 case AVMEDIA_TYPE_UNKNOWN:
2264 if (copy_unknown_streams) {
2265 ost = new_unknown_stream (o, oc, src_idx);
2269 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2270 "Cannot map stream #%d:%d - unsupported type.\n",
2271 map->file_index, map->stream_index);
2272 if (!ignore_unknown_streams) {
2273 av_log(NULL, AV_LOG_FATAL,
2274 "If you want unsupported types ignored instead "
2275 "of failing, please use the -ignore_unknown option\n"
2276 "If you want them copied, please use -copy_unknown\n");
2281 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2282 + map->sync_stream_index];
2287 /* handle attached files */
2288 for (i = 0; i < o->nb_attachments; i++) {
2290 uint8_t *attachment;
2294 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2295 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2299 if ((len = avio_size(pb)) <= 0) {
2300 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2304 if (!(attachment = av_malloc(len))) {
2305 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2309 avio_read(pb, attachment, len);
2311 ost = new_attachment_stream(o, oc, -1);
2312 ost->stream_copy = 0;
2313 ost->attachment_filename = o->attachments[i];
2314 ost->st->codecpar->extradata = attachment;
2315 ost->st->codecpar->extradata_size = len;
2317 p = strrchr(o->attachments[i], '/');
2318 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2322 #if FF_API_LAVF_AVCTX
2323 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2324 AVDictionaryEntry *e;
2325 ost = output_streams[i];
2327 if ((ost->stream_copy || ost->attachment_filename)
2328 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2329 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2330 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2335 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2336 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2337 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2341 /* check if all codec options have been used */
2342 unused_opts = strip_specifiers(o->g->codec_opts);
2343 for (i = of->ost_index; i < nb_output_streams; i++) {
2345 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2346 AV_DICT_IGNORE_SUFFIX)))
2347 av_dict_set(&unused_opts, e->key, NULL, 0);
2351 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2352 const AVClass *class = avcodec_get_class();
2353 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2354 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2355 const AVClass *fclass = avformat_get_class();
2356 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2357 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2358 if (!option || foption)
2362 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2363 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2364 "output file #%d (%s) is not an encoding option.\n", e->key,
2365 option->help ? option->help : "", nb_output_files - 1,
2370 // gop_timecode is injected by generic code but not always used
2371 if (!strcmp(e->key, "gop_timecode"))
2374 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2375 "output file #%d (%s) has not been used for any stream. The most "
2376 "likely reason is either wrong type (e.g. a video option with "
2377 "no video streams) or that it is a private option of some encoder "
2378 "which was not actually used for any stream.\n", e->key,
2379 option->help ? option->help : "", nb_output_files - 1, filename);
2381 av_dict_free(&unused_opts);
2383 /* set the decoding_needed flags and create simple filtergraphs */
2384 for (i = of->ost_index; i < nb_output_streams; i++) {
2385 OutputStream *ost = output_streams[i];
2387 if (ost->encoding_needed && ost->source_index >= 0) {
2388 InputStream *ist = input_streams[ost->source_index];
2389 ist->decoding_needed |= DECODING_FOR_OST;
2391 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2392 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2393 err = init_simple_filtergraph(ist, ost);
2395 av_log(NULL, AV_LOG_ERROR,
2396 "Error initializing a simple filtergraph between streams "
2397 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2398 nb_output_files - 1, ost->st->index);
2404 /* set the filter output constraints */
2406 OutputFilter *f = ost->filter;
2408 switch (ost->enc_ctx->codec_type) {
2409 case AVMEDIA_TYPE_VIDEO:
2410 f->frame_rate = ost->frame_rate;
2411 f->width = ost->enc_ctx->width;
2412 f->height = ost->enc_ctx->height;
2413 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2414 f->format = ost->enc_ctx->pix_fmt;
2415 } else if (ost->enc->pix_fmts) {
2417 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2419 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2422 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2425 case AVMEDIA_TYPE_AUDIO:
2426 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2427 f->format = ost->enc_ctx->sample_fmt;
2428 } else if (ost->enc->sample_fmts) {
2430 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2432 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2435 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2437 if (ost->enc_ctx->sample_rate) {
2438 f->sample_rate = ost->enc_ctx->sample_rate;
2439 } else if (ost->enc->supported_samplerates) {
2441 while (ost->enc->supported_samplerates[count])
2443 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2444 if (!f->sample_rates)
2446 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2447 (count + 1) * sizeof(*f->sample_rates));
2449 if (ost->enc_ctx->channels) {
2450 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2451 } else if (ost->enc->channel_layouts) {
2453 while (ost->enc->channel_layouts[count])
2455 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2456 if (!f->channel_layouts)
2458 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2459 (count + 1) * sizeof(*f->channel_layouts));
2466 /* check filename in case of an image number is expected */
2467 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2468 if (!av_filename_number_test(oc->filename)) {
2469 print_error(oc->filename, AVERROR(EINVAL));
2474 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2475 av_log(NULL, AV_LOG_ERROR,
2476 "No input streams but output needs an input stream\n");
2480 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2481 /* test if it already exists to avoid losing precious files */
2482 assert_file_overwrite(filename);
2485 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2486 &oc->interrupt_callback,
2488 print_error(filename, err);
2491 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2492 assert_file_overwrite(filename);
2494 if (o->mux_preload) {
2495 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2497 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2500 for (i = 0; i < o->nb_metadata_map; i++) {
2502 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2504 if (in_file_index >= nb_input_files) {
2505 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2508 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2509 in_file_index >= 0 ?
2510 input_files[in_file_index]->ctx : NULL, o);
2514 if (o->chapters_input_file >= nb_input_files) {
2515 if (o->chapters_input_file == INT_MAX) {
2516 /* copy chapters from the first input file that has them*/
2517 o->chapters_input_file = -1;
2518 for (i = 0; i < nb_input_files; i++)
2519 if (input_files[i]->ctx->nb_chapters) {
2520 o->chapters_input_file = i;
2524 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2525 o->chapters_input_file);
2529 if (o->chapters_input_file >= 0)
2530 copy_chapters(input_files[o->chapters_input_file], of,
2531 !o->metadata_chapters_manual);
2533 /* copy global metadata by default */
2534 if (!o->metadata_global_manual && nb_input_files){
2535 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2536 AV_DICT_DONT_OVERWRITE);
2537 if(o->recording_time != INT64_MAX)
2538 av_dict_set(&oc->metadata, "duration", NULL, 0);
2539 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2541 if (!o->metadata_streams_manual)
2542 for (i = of->ost_index; i < nb_output_streams; i++) {
2544 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2546 ist = input_streams[output_streams[i]->source_index];
2547 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2548 if (!output_streams[i]->stream_copy) {
2549 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2550 if (ist->autorotate)
2551 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2555 /* process manually set programs */
2556 for (i = 0; i < o->nb_program; i++) {
2557 const char *p = o->program[i].u.str;
2562 const char *p2 = av_get_token(&p, ":");
2563 const char *to_dealloc = p2;
2570 key = av_get_token(&p2, "=");
2572 av_freep(&to_dealloc);
2578 if (!strcmp(key, "program_num"))
2579 progid = strtol(p2, NULL, 0);
2580 av_freep(&to_dealloc);
2584 program = av_new_program(oc, progid);
2586 p = o->program[i].u.str;
2588 const char *p2 = av_get_token(&p, ":");
2589 const char *to_dealloc = p2;
2595 key = av_get_token(&p2, "=");
2597 av_log(NULL, AV_LOG_FATAL,
2598 "No '=' character in program string %s.\n",
2606 if (!strcmp(key, "title")) {
2607 av_dict_set(&program->metadata, "title", p2, 0);
2608 } else if (!strcmp(key, "program_num")) {
2609 } else if (!strcmp(key, "st")) {
2610 int st_num = strtol(p2, NULL, 0);
2611 av_program_add_stream_index(oc, progid, st_num);
2613 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2616 av_freep(&to_dealloc);
2621 /* process manually set metadata */
2622 for (i = 0; i < o->nb_metadata; i++) {
2625 const char *stream_spec;
2626 int index = 0, j, ret = 0;
2628 val = strchr(o->metadata[i].u.str, '=');
2630 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2631 o->metadata[i].u.str);
2636 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2638 for (j = 0; j < oc->nb_streams; j++) {
2639 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2640 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2641 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2642 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2643 ost->rotate_overridden = 1;
2655 if (index < 0 || index >= oc->nb_chapters) {
2656 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2659 m = &oc->chapters[index]->metadata;
2662 if (index < 0 || index >= oc->nb_programs) {
2663 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2666 m = &oc->programs[index]->metadata;
2669 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2672 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2679 static int opt_target(void *optctx, const char *opt, const char *arg)
2681 OptionsContext *o = optctx;
2682 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2683 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2685 if (!strncmp(arg, "pal-", 4)) {
2688 } else if (!strncmp(arg, "ntsc-", 5)) {
2691 } else if (!strncmp(arg, "film-", 5)) {
2695 /* Try to determine PAL/NTSC by peeking in the input files */
2696 if (nb_input_files) {
2698 for (j = 0; j < nb_input_files; j++) {
2699 for (i = 0; i < input_files[j]->nb_streams; i++) {
2700 AVStream *st = input_files[j]->ctx->streams[i];
2701 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2703 fr = st->time_base.den * 1000 / st->time_base.num;
2707 } else if ((fr == 29970) || (fr == 23976)) {
2712 if (norm != UNKNOWN)
2716 if (norm != UNKNOWN)
2717 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2720 if (norm == UNKNOWN) {
2721 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2722 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2723 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2727 if (!strcmp(arg, "vcd")) {
2728 opt_video_codec(o, "c:v", "mpeg1video");
2729 opt_audio_codec(o, "c:a", "mp2");
2730 parse_option(o, "f", "vcd", options);
2732 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2733 parse_option(o, "r", frame_rates[norm], options);
2734 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2736 opt_default(NULL, "b:v", "1150000");
2737 opt_default(NULL, "maxrate:v", "1150000");
2738 opt_default(NULL, "minrate:v", "1150000");
2739 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2741 opt_default(NULL, "b:a", "224000");
2742 parse_option(o, "ar", "44100", options);
2743 parse_option(o, "ac", "2", options);
2745 opt_default(NULL, "packetsize", "2324");
2746 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2748 /* We have to offset the PTS, so that it is consistent with the SCR.
2749 SCR starts at 36000, but the first two packs contain only padding
2750 and the first pack from the other stream, respectively, may also have
2751 been written before.
2752 So the real data starts at SCR 36000+3*1200. */
2753 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2754 } else if (!strcmp(arg, "svcd")) {
2756 opt_video_codec(o, "c:v", "mpeg2video");
2757 opt_audio_codec(o, "c:a", "mp2");
2758 parse_option(o, "f", "svcd", options);
2760 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2761 parse_option(o, "r", frame_rates[norm], options);
2762 parse_option(o, "pix_fmt", "yuv420p", options);
2763 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2765 opt_default(NULL, "b:v", "2040000");
2766 opt_default(NULL, "maxrate:v", "2516000");
2767 opt_default(NULL, "minrate:v", "0"); // 1145000;
2768 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2769 opt_default(NULL, "scan_offset", "1");
2771 opt_default(NULL, "b:a", "224000");
2772 parse_option(o, "ar", "44100", options);
2774 opt_default(NULL, "packetsize", "2324");
2776 } else if (!strcmp(arg, "dvd")) {
2778 opt_video_codec(o, "c:v", "mpeg2video");
2779 opt_audio_codec(o, "c:a", "ac3");
2780 parse_option(o, "f", "dvd", options);
2782 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2783 parse_option(o, "r", frame_rates[norm], options);
2784 parse_option(o, "pix_fmt", "yuv420p", options);
2785 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2787 opt_default(NULL, "b:v", "6000000");
2788 opt_default(NULL, "maxrate:v", "9000000");
2789 opt_default(NULL, "minrate:v", "0"); // 1500000;
2790 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2792 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2793 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2795 opt_default(NULL, "b:a", "448000");
2796 parse_option(o, "ar", "48000", options);
2798 } else if (!strncmp(arg, "dv", 2)) {
2800 parse_option(o, "f", "dv", options);
2802 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2803 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2804 norm == PAL ? "yuv420p" : "yuv411p", options);
2805 parse_option(o, "r", frame_rates[norm], options);
2807 parse_option(o, "ar", "48000", options);
2808 parse_option(o, "ac", "2", options);
2811 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2812 return AVERROR(EINVAL);
2815 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2816 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2821 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2823 av_free (vstats_filename);
2824 vstats_filename = av_strdup (arg);
2828 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2831 time_t today2 = time(NULL);
2832 struct tm *today = localtime(&today2);
2834 if (!today) { // maybe tomorrow
2835 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2839 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2841 return opt_vstats_file(NULL, opt, filename);
2844 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2846 OptionsContext *o = optctx;
2847 return parse_option(o, "frames:v", arg, options);
2850 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2852 OptionsContext *o = optctx;
2853 return parse_option(o, "frames:a", arg, options);
2856 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2858 OptionsContext *o = optctx;
2859 return parse_option(o, "frames:d", arg, options);
2862 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2865 AVDictionary *cbak = codec_opts;
2866 AVDictionary *fbak = format_opts;
2870 ret = opt_default(NULL, opt, arg);
2872 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2873 av_dict_copy(&o->g->format_opts, format_opts, 0);
2874 av_dict_free(&codec_opts);
2875 av_dict_free(&format_opts);
2882 static int opt_preset(void *optctx, const char *opt, const char *arg)
2884 OptionsContext *o = optctx;
2886 char filename[1000], line[1000], tmp_line[1000];
2887 const char *codec_name = NULL;
2891 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2893 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2894 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2895 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2897 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2901 while (fgets(line, sizeof(line), f)) {
2902 char *key = tmp_line, *value, *endptr;
2904 if (strcspn(line, "#\n\r") == 0)
2906 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2907 if (!av_strtok(key, "=", &value) ||
2908 !av_strtok(value, "\r\n", &endptr)) {
2909 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2912 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2914 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2915 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2916 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2917 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2918 else if (opt_default_new(o, key, value) < 0) {
2919 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2920 filename, line, key, value);
2930 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2932 OptionsContext *o = optctx;
2933 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2934 int ret = parse_option(o, s, arg, options);
2939 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2941 OptionsContext *o = optctx;
2943 if(!strcmp(opt, "ab")){
2944 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2946 } else if(!strcmp(opt, "b")){
2947 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2948 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2951 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2955 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2957 OptionsContext *o = optctx;
2960 if(!strcmp(opt, "qscale")){
2961 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2962 return parse_option(o, "q:v", arg, options);
2964 s = av_asprintf("q%s", opt + 6);
2965 ret = parse_option(o, s, arg, options);
2970 static int opt_profile(void *optctx, const char *opt, const char *arg)
2972 OptionsContext *o = optctx;
2973 if(!strcmp(opt, "profile")){
2974 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2975 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2978 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2982 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2984 OptionsContext *o = optctx;
2985 return parse_option(o, "filter:v", arg, options);
2988 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2990 OptionsContext *o = optctx;
2991 return parse_option(o, "filter:a", arg, options);
2994 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2996 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2997 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2998 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2999 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3001 if (video_sync_method == VSYNC_AUTO)
3002 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3006 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3008 OptionsContext *o = optctx;
3009 char *tcr = av_asprintf("timecode=%s", arg);
3010 int ret = parse_option(o, "metadata:g", tcr, options);
3012 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3017 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3019 OptionsContext *o = optctx;
3020 char layout_str[32];
3023 int ret, channels, ac_str_size;
3026 layout = av_get_channel_layout(arg);
3028 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3029 return AVERROR(EINVAL);
3031 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3032 ret = opt_default_new(o, opt, layout_str);
3036 /* set 'ac' option based on channel layout */
3037 channels = av_get_channel_layout_nb_channels(layout);
3038 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3039 stream_str = strchr(opt, ':');
3040 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3041 ac_str = av_mallocz(ac_str_size);
3043 return AVERROR(ENOMEM);
3044 av_strlcpy(ac_str, "ac", 3);
3046 av_strlcat(ac_str, stream_str, ac_str_size);
3047 ret = parse_option(o, ac_str, layout_str, options);
3053 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3055 OptionsContext *o = optctx;
3056 return parse_option(o, "q:a", arg, options);
3059 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3061 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3062 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3063 return AVERROR(ENOMEM);
3064 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3065 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3066 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3067 return AVERROR(ENOMEM);
3069 input_stream_potentially_available = 1;
3074 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3076 uint8_t *graph_desc = read_file(arg);
3078 return AVERROR(EINVAL);
3080 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3081 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3082 return AVERROR(ENOMEM);
3083 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3084 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3086 input_stream_potentially_available = 1;
3091 void show_help_default(const char *opt, const char *arg)
3093 /* per-file options have at least one of those set */
3094 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3095 int show_advanced = 0, show_avoptions = 0;
3098 if (!strcmp(opt, "long"))
3100 else if (!strcmp(opt, "full"))
3101 show_advanced = show_avoptions = 1;
3103 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3108 printf("Getting help:\n"
3109 " -h -- print basic options\n"
3110 " -h long -- print more options\n"
3111 " -h full -- print all options (including all format and codec specific options, very long)\n"
3112 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3113 " See man %s for detailed description of the options.\n"
3114 "\n", program_name);
3116 show_help_options(options, "Print help / information / capabilities:",
3119 show_help_options(options, "Global options (affect whole program "
3120 "instead of just one file:",
3121 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3123 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3124 per_file | OPT_EXIT, 0);
3126 show_help_options(options, "Per-file main options:", 0,
3127 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3128 OPT_EXIT, per_file);
3130 show_help_options(options, "Advanced per-file options:",
3131 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3133 show_help_options(options, "Video options:",
3134 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3136 show_help_options(options, "Advanced Video options:",
3137 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3139 show_help_options(options, "Audio options:",
3140 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3142 show_help_options(options, "Advanced Audio options:",
3143 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3144 show_help_options(options, "Subtitle options:",
3145 OPT_SUBTITLE, 0, 0);
3148 if (show_avoptions) {
3149 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3150 show_help_children(avcodec_get_class(), flags);
3151 show_help_children(avformat_get_class(), flags);
3153 show_help_children(sws_get_class(), flags);
3155 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3156 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3160 void show_usage(void)
3162 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3163 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3164 av_log(NULL, AV_LOG_INFO, "\n");
3172 static const OptionGroupDef groups[] = {
3173 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3174 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3177 static int open_files(OptionGroupList *l, const char *inout,
3178 int (*open_file)(OptionsContext*, const char*))
3182 for (i = 0; i < l->nb_groups; i++) {
3183 OptionGroup *g = &l->groups[i];
3189 ret = parse_optgroup(&o, g);
3191 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3192 "%s.\n", inout, g->arg);
3196 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3197 ret = open_file(&o, g->arg);
3200 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3204 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3210 int ffmpeg_parse_options(int argc, char **argv)
3212 OptionParseContext octx;
3216 memset(&octx, 0, sizeof(octx));
3218 /* split the commandline into an internal representation */
3219 ret = split_commandline(&octx, argc, argv, options, groups,
3220 FF_ARRAY_ELEMS(groups));
3222 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3226 /* apply global options */
3227 ret = parse_optgroup(NULL, &octx.global_opts);
3229 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3233 /* configure terminal and setup signal handlers */
3236 /* open input files */
3237 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3239 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3243 /* create the complex filtergraphs */
3244 ret = init_complex_filters();
3246 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3250 /* open output files */
3251 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3253 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3258 uninit_parse_context(&octx);
3260 av_strerror(ret, error, sizeof(error));
3261 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3266 static int opt_progress(void *optctx, const char *opt, const char *arg)
3268 AVIOContext *avio = NULL;
3271 if (!strcmp(arg, "-"))
3273 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3275 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3276 arg, av_err2str(ret));
3279 progress_avio = avio;
3283 #define OFFSET(x) offsetof(OptionsContext, x)
3284 const OptionDef options[] = {
3286 #include "cmdutils_common_opts.h"
3287 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3288 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3289 "force format", "fmt" },
3290 { "y", OPT_BOOL, { &file_overwrite },
3291 "overwrite output files" },
3292 { "n", OPT_BOOL, { &no_file_overwrite },
3293 "never overwrite output files" },
3294 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3295 "Ignore unknown stream types" },
3296 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3297 "Copy unknown stream types" },
3298 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3299 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3300 "codec name", "codec" },
3301 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3302 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3303 "codec name", "codec" },
3304 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3305 OPT_OUTPUT, { .off = OFFSET(presets) },
3306 "preset name", "preset" },
3307 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3308 OPT_OUTPUT, { .func_arg = opt_map },
3309 "set input stream mapping",
3310 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3311 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3312 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3313 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3314 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3315 "set metadata information of outfile from infile",
3316 "outfile[,metadata]:infile[,metadata]" },
3317 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3318 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3319 "set chapters mapping", "input_file_index" },
3320 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3321 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3322 "record or transcode \"duration\" seconds of audio/video",
3324 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3325 "record or transcode stop time", "time_stop" },
3326 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3327 "set the limit file size in bytes", "limit_size" },
3328 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3329 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3330 "set the start time offset", "time_off" },
3331 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3332 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3333 "set the start time offset relative to EOF", "time_off" },
3334 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3335 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3336 "enable/disable seeking by timestamp with -ss" },
3337 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3338 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3339 "enable/disable accurate seeking with -ss" },
3340 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3341 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3342 "set the input ts offset", "time_off" },
3343 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3344 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3345 "set the input ts scale", "scale" },
3346 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3347 "set the recording timestamp ('now' to set the current time)", "time" },
3348 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3349 "add metadata", "string=string" },
3350 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3351 "add program with specified streams", "title=string:st=number..." },
3352 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3353 OPT_OUTPUT, { .func_arg = opt_data_frames },
3354 "set the number of data frames to output", "number" },
3355 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3356 "add timings for benchmarking" },
3357 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3358 "add timings for each task" },
3359 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3360 "write program-readable progress information", "url" },
3361 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3362 "enable or disable interaction on standard input" },
3363 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3364 "set max runtime in seconds", "limit" },
3365 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3366 "dump each input packet" },
3367 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3368 "when dumping packets, also dump the payload" },
3369 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3370 OPT_INPUT, { .off = OFFSET(rate_emu) },
3371 "read input at native frame rate", "" },
3372 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3373 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3374 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3375 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3376 "video sync method", "" },
3377 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3378 "frame drop threshold", "" },
3379 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3380 "audio sync method", "" },
3381 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3382 "audio drift threshold", "threshold" },
3383 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3384 "copy timestamps" },
3385 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3386 "shift input timestamps to start at 0 when using copyts" },
3387 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3388 "copy input stream time base when stream copying", "mode" },
3389 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3390 OPT_OUTPUT, { .off = OFFSET(shortest) },
3391 "finish encoding within shortest input" },
3392 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3393 OPT_OUTPUT, { .off = OFFSET(apad) },
3395 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3396 "timestamp discontinuity delta threshold", "threshold" },
3397 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3398 "timestamp error delta threshold", "threshold" },
3399 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3400 "exit on error", "error" },
3401 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3402 "abort on the specified condition flags", "flags" },
3403 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3404 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3405 "copy initial non-keyframes" },
3406 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3407 "copy or discard frames before start time" },
3408 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3409 "set the number of frames to output", "number" },
3410 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3411 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3412 "force codec tag/fourcc", "fourcc/tag" },
3413 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3414 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3415 "use fixed quality scale (VBR)", "q" },
3416 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3417 OPT_OUTPUT, { .func_arg = opt_qscale },
3418 "use fixed quality scale (VBR)", "q" },
3419 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3420 "set profile", "profile" },
3421 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3422 "set stream filtergraph", "filter_graph" },
3423 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3424 "number of non-complex filter threads" },
3425 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3426 "read stream filtergraph description from a file", "filename" },
3427 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3428 "reinit filtergraph on input parameter changes", "" },
3429 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3430 "create a complex filtergraph", "graph_description" },
3431 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3432 "number of threads for -filter_complex" },
3433 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3434 "create a complex filtergraph", "graph_description" },
3435 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3436 "read complex filtergraph description from a file", "filename" },
3437 { "stats", OPT_BOOL, { &print_stats },
3438 "print progress report during encoding", },
3439 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3440 OPT_OUTPUT, { .func_arg = opt_attach },
3441 "add an attachment to the output file", "filename" },
3442 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3443 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3444 "extract an attachment into a file", "filename" },
3445 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3446 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3447 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3448 "print timestamp debugging info" },
3449 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3450 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3451 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3452 OPT_INPUT, { .off = OFFSET(discard) },
3454 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3455 OPT_OUTPUT, { .off = OFFSET(disposition) },
3456 "disposition", "" },
3457 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3458 { .off = OFFSET(thread_queue_size) },
3459 "set the maximum number of queued packets from the demuxer" },
3462 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3463 "set the number of video frames to output", "number" },
3464 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3465 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3466 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3467 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3468 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3469 "set frame size (WxH or abbreviation)", "size" },
3470 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3471 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3472 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3473 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3474 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3475 "set pixel format", "format" },
3476 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3477 "set the number of bits per raw sample", "number" },
3478 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3479 "deprecated use -g 1" },
3480 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3482 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3483 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3484 "rate control override for specific intervals", "override" },
3485 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3486 OPT_OUTPUT, { .func_arg = opt_video_codec },
3487 "force video codec ('copy' to copy stream)", "codec" },
3488 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3490 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3492 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3493 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3494 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3495 "select the pass number (1 to 3)", "n" },
3496 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3497 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3498 "select two pass log file name prefix", "prefix" },
3499 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3500 "this option is deprecated, use the yadif filter instead" },
3501 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3502 "calculate PSNR of compressed frames" },
3503 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3504 "dump video coding statistics to file" },
3505 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3506 "dump video coding statistics to file", "file" },
3507 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3508 "Version of the vstats format to use."},
3509 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3510 "set video filters", "filter_graph" },
3511 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3512 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3513 "specify intra matrix coeffs", "matrix" },
3514 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3515 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3516 "specify inter matrix coeffs", "matrix" },
3517 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3518 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3519 "specify intra matrix coeffs", "matrix" },
3520 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3521 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3522 "top=1/bottom=0/auto=-1 field first", "" },
3523 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3524 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3525 "force video tag/fourcc", "fourcc/tag" },
3526 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3527 "show QP histogram" },
3528 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3529 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3530 "force the selected framerate, disable the best supported framerate selection" },
3531 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3532 OPT_OUTPUT, { .func_arg = opt_streamid },
3533 "set the value of an outfile streamid", "streamIndex:value" },
3534 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3535 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3536 "force key frames at specified timestamps", "timestamps" },
3537 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3538 "audio bitrate (please use -b:a)", "bitrate" },
3539 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3540 "video bitrate (please use -b:v)", "bitrate" },
3541 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3542 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3543 "use HW accelerated decoding", "hwaccel name" },
3544 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3545 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3546 "select a device for HW acceleration", "devicename" },
3547 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3548 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3549 "select output format used with HW accelerated decoding", "format" },
3550 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3551 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3553 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3554 "show available HW acceleration methods" },
3555 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3556 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3557 "automatically insert correct rotate filters" },
3558 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3559 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3562 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3563 "set the number of audio frames to output", "number" },
3564 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3565 "set audio quality (codec-specific)", "quality", },
3566 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3567 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3568 "set audio sampling rate (in Hz)", "rate" },
3569 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3570 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3571 "set number of audio channels", "channels" },
3572 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3574 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3575 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3576 "force audio codec ('copy' to copy stream)", "codec" },
3577 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3578 OPT_OUTPUT, { .func_arg = opt_old2new },
3579 "force audio tag/fourcc", "fourcc/tag" },
3580 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3581 "change audio volume (256=normal)" , "volume" },
3582 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3583 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3584 "set sample format", "format" },
3585 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3586 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3587 "set channel layout", "layout" },
3588 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3589 "set audio filters", "filter_graph" },
3590 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3591 "set the maximum number of channels to try to guess the channel layout" },
3593 /* subtitle options */
3594 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3595 "disable subtitle" },
3596 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3597 "force subtitle codec ('copy' to copy stream)", "codec" },
3598 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3599 , "force subtitle tag/fourcc", "fourcc/tag" },
3600 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3601 "fix subtitles duration" },
3602 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3603 "set canvas size (WxH or abbreviation)", "size" },
3606 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3607 "deprecated, use -channel", "channel" },
3608 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3609 "deprecated, use -standard", "standard" },
3610 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3613 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3614 "set the maximum demux-decode delay", "seconds" },
3615 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3616 "set the initial demux-decode delay", "seconds" },
3617 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3618 "override the options from ffserver", "" },
3619 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3620 "specify a file in which to print sdp information", "file" },
3622 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3623 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3625 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3626 "A comma-separated list of bitstream filters", "bitstream_filters" },
3627 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3628 "deprecated", "audio bitstream_filters" },
3629 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3630 "deprecated", "video bitstream_filters" },
3632 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3633 "set the audio options to the indicated preset", "preset" },
3634 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3635 "set the video options to the indicated preset", "preset" },
3636 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3637 "set the subtitle options to the indicated preset", "preset" },
3638 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3639 "set options from indicated preset file", "filename" },
3641 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3642 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3644 /* data codec support */
3645 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3646 "force data codec ('copy' to copy stream)", "codec" },
3647 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3651 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3652 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3656 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3657 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},