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", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
71 AV_HWDEVICE_TYPE_VDPAU },
74 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
75 AV_HWDEVICE_TYPE_NONE },
78 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA,
79 AV_HWDEVICE_TYPE_NONE },
81 #if CONFIG_VIDEOTOOLBOX
82 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX,
83 AV_HWDEVICE_TYPE_NONE },
86 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV,
87 AV_HWDEVICE_TYPE_NONE },
90 { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
91 AV_HWDEVICE_TYPE_VAAPI },
94 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
95 AV_HWDEVICE_TYPE_NONE },
99 int hwaccel_lax_profile_check = 0;
100 AVBufferRef *hw_device_ctx;
101 HWDevice *filter_hw_device;
103 char *vstats_filename;
106 float audio_drift_threshold = 0.1;
107 float dts_delta_threshold = 10;
108 float dts_error_threshold = 3600*30;
110 int audio_volume = 256;
111 int audio_sync_method = 0;
112 int video_sync_method = VSYNC_AUTO;
113 float frame_drop_threshold = 0;
114 int do_deinterlace = 0;
115 int do_benchmark = 0;
116 int do_benchmark_all = 0;
120 int start_at_zero = 0;
123 int exit_on_error = 0;
124 int abort_on_flags = 0;
125 int print_stats = -1;
127 int stdin_interaction = 1;
128 int frame_bits_per_raw_sample = 0;
129 float max_error_rate = 2.0/3;
130 int filter_nbthreads = 0;
131 int filter_complex_nbthreads = 0;
132 int vstats_version = 2;
135 static int intra_only = 0;
136 static int file_overwrite = 0;
137 static int no_file_overwrite = 0;
138 static int do_psnr = 0;
139 static int input_sync;
140 static int override_ffserver = 0;
141 static int input_stream_potentially_available = 0;
142 static int ignore_unknown_streams = 0;
143 static int copy_unknown_streams = 0;
145 static void uninit_options(OptionsContext *o)
147 const OptionDef *po = options;
150 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
152 void *dst = (uint8_t*)o + po->u.off;
154 if (po->flags & OPT_SPEC) {
155 SpecifierOpt **so = dst;
156 int i, *count = (int*)(so + 1);
157 for (i = 0; i < *count; i++) {
158 av_freep(&(*so)[i].specifier);
159 if (po->flags & OPT_STRING)
160 av_freep(&(*so)[i].u.str);
164 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
169 for (i = 0; i < o->nb_stream_maps; i++)
170 av_freep(&o->stream_maps[i].linklabel);
171 av_freep(&o->stream_maps);
172 av_freep(&o->audio_channel_maps);
173 av_freep(&o->streamid_map);
174 av_freep(&o->attachments);
177 static void init_options(OptionsContext *o)
179 memset(o, 0, sizeof(*o));
181 o->stop_time = INT64_MAX;
182 o->mux_max_delay = 0.7;
183 o->start_time = AV_NOPTS_VALUE;
184 o->start_time_eof = AV_NOPTS_VALUE;
185 o->recording_time = INT64_MAX;
186 o->limit_filesize = UINT64_MAX;
187 o->chapters_input_file = INT_MAX;
188 o->accurate_seek = 1;
191 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
195 printf("Hardware acceleration methods:\n");
196 for (i = 0; hwaccels[i].name; i++) {
197 printf("%s\n", hwaccels[i].name);
203 /* return a copy of the input with the stream specifiers removed from the keys */
204 static AVDictionary *strip_specifiers(AVDictionary *dict)
206 AVDictionaryEntry *e = NULL;
207 AVDictionary *ret = NULL;
209 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
210 char *p = strchr(e->key, ':');
214 av_dict_set(&ret, e->key, e->value, 0);
221 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
223 static const AVOption opts[] = {
224 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
225 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
228 static const AVClass class = {
230 .item_name = av_default_item_name,
232 .version = LIBAVUTIL_VERSION_INT,
234 const AVClass *pclass = &class;
236 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
239 static int opt_sameq(void *optctx, const char *opt, const char *arg)
241 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
242 "If you are looking for an option to preserve the quality (which is not "
243 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
245 return AVERROR(EINVAL);
248 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
250 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
251 return opt_default(optctx, "channel", arg);
254 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
256 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
257 return opt_default(optctx, "standard", arg);
260 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
262 OptionsContext *o = optctx;
263 return parse_option(o, "codec:a", arg, options);
266 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
268 OptionsContext *o = optctx;
269 return parse_option(o, "codec:v", arg, options);
272 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
274 OptionsContext *o = optctx;
275 return parse_option(o, "codec:s", arg, options);
278 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
280 OptionsContext *o = optctx;
281 return parse_option(o, "codec:d", arg, options);
284 static int opt_map(void *optctx, const char *opt, const char *arg)
286 OptionsContext *o = optctx;
288 int i, negative = 0, file_idx;
289 int sync_file_idx = -1, sync_stream_idx = 0;
298 map = av_strdup(arg);
300 return AVERROR(ENOMEM);
302 /* parse sync stream first, just pick first matching stream */
303 if (sync = strchr(map, ',')) {
305 sync_file_idx = strtol(sync + 1, &sync, 0);
306 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
307 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
312 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
313 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
314 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
318 if (i == input_files[sync_file_idx]->nb_streams) {
319 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
320 "match any streams.\n", arg);
327 /* this mapping refers to lavfi output */
328 const char *c = map + 1;
329 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
330 m = &o->stream_maps[o->nb_stream_maps - 1];
331 m->linklabel = av_get_token(&c, "]");
333 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
337 if (allow_unused = strchr(map, '?'))
339 file_idx = strtol(map, &p, 0);
340 if (file_idx >= nb_input_files || file_idx < 0) {
341 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
345 /* disable some already defined maps */
346 for (i = 0; i < o->nb_stream_maps; i++) {
347 m = &o->stream_maps[i];
348 if (file_idx == m->file_index &&
349 check_stream_specifier(input_files[m->file_index]->ctx,
350 input_files[m->file_index]->ctx->streams[m->stream_index],
351 *p == ':' ? p + 1 : p) > 0)
355 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
356 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
357 *p == ':' ? p + 1 : p) <= 0)
359 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
360 m = &o->stream_maps[o->nb_stream_maps - 1];
362 m->file_index = file_idx;
365 if (sync_file_idx >= 0) {
366 m->sync_file_index = sync_file_idx;
367 m->sync_stream_index = sync_stream_idx;
369 m->sync_file_index = file_idx;
370 m->sync_stream_index = i;
377 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
379 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
380 "To ignore this, add a trailing '?' to the map.\n", arg);
389 static int opt_attach(void *optctx, const char *opt, const char *arg)
391 OptionsContext *o = optctx;
392 GROW_ARRAY(o->attachments, o->nb_attachments);
393 o->attachments[o->nb_attachments - 1] = arg;
397 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
399 OptionsContext *o = optctx;
404 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
405 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
407 /* muted channel syntax */
408 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
409 if ((n == 1 || n == 3) && m->channel_idx == -1) {
410 m->file_idx = m->stream_idx = -1;
412 m->ofile_idx = m->ostream_idx = -1;
417 n = sscanf(arg, "%d.%d.%d:%d.%d",
418 &m->file_idx, &m->stream_idx, &m->channel_idx,
419 &m->ofile_idx, &m->ostream_idx);
421 if (n != 3 && n != 5) {
422 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
423 "[file.stream.channel|-1][:syncfile:syncstream]\n");
427 if (n != 5) // only file.stream.channel specified
428 m->ofile_idx = m->ostream_idx = -1;
431 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
432 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
436 if (m->stream_idx < 0 ||
437 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
438 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
439 m->file_idx, m->stream_idx);
442 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
443 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
444 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
445 m->file_idx, m->stream_idx);
448 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
449 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
450 m->file_idx, m->stream_idx, m->channel_idx);
456 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
458 av_free(sdp_filename);
459 sdp_filename = av_strdup(arg);
464 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
467 const char *prefix = "vaapi:";
470 tmp = av_asprintf("%s%s", prefix, arg);
472 return AVERROR(ENOMEM);
473 err = hw_device_init_from_string(tmp, &dev);
477 hw_device_ctx = av_buffer_ref(dev->device_ref);
479 return AVERROR(ENOMEM);
484 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
486 if (!strcmp(arg, "list")) {
487 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
488 printf("Supported hardware device types:\n");
489 while ((type = av_hwdevice_iterate_types(type)) !=
490 AV_HWDEVICE_TYPE_NONE)
491 printf("%s\n", av_hwdevice_get_type_name(type));
495 return hw_device_init_from_string(arg, NULL);
499 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
501 if (filter_hw_device) {
502 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
503 return AVERROR(EINVAL);
505 filter_hw_device = hw_device_get_by_name(arg);
506 if (!filter_hw_device) {
507 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
508 return AVERROR(EINVAL);
514 * Parse a metadata specifier passed as 'arg' parameter.
515 * @param arg metadata string to parse
516 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
517 * @param index for type c/p, chapter/program index is written here
518 * @param stream_spec for type s, the stream specifier is written here
520 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
528 if (*(++arg) && *arg != ':') {
529 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
532 *stream_spec = *arg == ':' ? arg + 1 : "";
537 *index = strtol(++arg, NULL, 0);
540 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
547 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
549 AVDictionary **meta_in = NULL;
550 AVDictionary **meta_out = NULL;
552 char type_in, type_out;
553 const char *istream_spec = NULL, *ostream_spec = NULL;
554 int idx_in = 0, idx_out = 0;
556 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
557 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
560 if (type_out == 'g' || !*outspec)
561 o->metadata_global_manual = 1;
562 if (type_out == 's' || !*outspec)
563 o->metadata_streams_manual = 1;
564 if (type_out == 'c' || !*outspec)
565 o->metadata_chapters_manual = 1;
569 if (type_in == 'g' || type_out == 'g')
570 o->metadata_global_manual = 1;
571 if (type_in == 's' || type_out == 's')
572 o->metadata_streams_manual = 1;
573 if (type_in == 'c' || type_out == 'c')
574 o->metadata_chapters_manual = 1;
576 /* ic is NULL when just disabling automatic mappings */
580 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
581 if ((index) < 0 || (index) >= (nb_elems)) {\
582 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
587 #define SET_DICT(type, meta, context, index)\
590 meta = &context->metadata;\
593 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
594 meta = &context->chapters[index]->metadata;\
597 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
598 meta = &context->programs[index]->metadata;\
601 break; /* handled separately below */ \
602 default: av_assert0(0);\
605 SET_DICT(type_in, meta_in, ic, idx_in);
606 SET_DICT(type_out, meta_out, oc, idx_out);
608 /* for input streams choose first matching stream */
609 if (type_in == 's') {
610 for (i = 0; i < ic->nb_streams; i++) {
611 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
612 meta_in = &ic->streams[i]->metadata;
618 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
623 if (type_out == 's') {
624 for (i = 0; i < oc->nb_streams; i++) {
625 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
626 meta_out = &oc->streams[i]->metadata;
627 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
632 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
637 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
639 OptionsContext *o = optctx;
641 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
642 struct tm time = *gmtime((time_t*)&recording_timestamp);
643 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
645 parse_option(o, "metadata", buf, options);
647 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
648 "tag instead.\n", opt);
652 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
654 const AVCodecDescriptor *desc;
655 const char *codec_string = encoder ? "encoder" : "decoder";
659 avcodec_find_encoder_by_name(name) :
660 avcodec_find_decoder_by_name(name);
662 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
663 codec = encoder ? avcodec_find_encoder(desc->id) :
664 avcodec_find_decoder(desc->id);
666 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
667 codec_string, codec->name, desc->name);
671 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
674 if (codec->type != type) {
675 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
681 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
683 char *codec_name = NULL;
685 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
687 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
688 st->codecpar->codec_id = codec->id;
691 return avcodec_find_decoder(st->codecpar->codec_id);
694 /* Add all the streams from the given input file to the global
695 * list of input streams. */
696 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
700 for (i = 0; i < ic->nb_streams; i++) {
701 AVStream *st = ic->streams[i];
702 AVCodecParameters *par = st->codecpar;
703 InputStream *ist = av_mallocz(sizeof(*ist));
704 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
705 char *hwaccel_output_format = NULL;
706 char *codec_tag = NULL;
708 char *discard_str = NULL;
709 const AVClass *cc = avcodec_get_class();
710 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
715 GROW_ARRAY(input_streams, nb_input_streams);
716 input_streams[nb_input_streams - 1] = ist;
719 ist->file_index = nb_input_files;
721 st->discard = AVDISCARD_ALL;
723 ist->min_pts = INT64_MAX;
724 ist->max_pts = INT64_MIN;
727 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
730 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
732 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
734 uint32_t tag = strtol(codec_tag, &next, 0);
736 tag = AV_RL32(codec_tag);
737 st->codecpar->codec_tag = tag;
740 ist->dec = choose_decoder(o, ic, st);
741 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
743 ist->reinit_filters = -1;
744 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
746 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
747 ist->user_set_discard = AVDISCARD_NONE;
748 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
749 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
754 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
756 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
758 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
762 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
764 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
768 switch (par->codec_type) {
769 case AVMEDIA_TYPE_VIDEO:
771 ist->dec = avcodec_find_decoder(par->codec_id);
773 if (av_codec_get_lowres(st->codec)) {
774 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
775 ist->dec_ctx->width = st->codec->width;
776 ist->dec_ctx->height = st->codec->height;
777 ist->dec_ctx->coded_width = st->codec->coded_width;
778 ist->dec_ctx->coded_height = st->codec->coded_height;
779 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
783 // avformat_find_stream_info() doesn't set this for us anymore.
784 ist->dec_ctx->framerate = st->avg_frame_rate;
786 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
787 if (framerate && av_parse_video_rate(&ist->framerate,
789 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
794 ist->top_field_first = -1;
795 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
797 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
799 if (!strcmp(hwaccel, "none"))
800 ist->hwaccel_id = HWACCEL_NONE;
801 else if (!strcmp(hwaccel, "auto"))
802 ist->hwaccel_id = HWACCEL_AUTO;
805 for (i = 0; hwaccels[i].name; i++) {
806 if (!strcmp(hwaccels[i].name, hwaccel)) {
807 ist->hwaccel_id = hwaccels[i].id;
812 if (!ist->hwaccel_id) {
813 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
815 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
816 for (i = 0; hwaccels[i].name; i++)
817 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
818 av_log(NULL, AV_LOG_FATAL, "\n");
824 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
825 if (hwaccel_device) {
826 ist->hwaccel_device = av_strdup(hwaccel_device);
827 if (!ist->hwaccel_device)
831 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
832 hwaccel_output_format, ic, st);
833 if (hwaccel_output_format) {
834 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
835 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
836 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
837 "format: %s", hwaccel_output_format);
840 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
843 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
846 case AVMEDIA_TYPE_AUDIO:
847 ist->guess_layout_max = INT_MAX;
848 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
849 guess_input_channel_layout(ist);
851 case AVMEDIA_TYPE_DATA:
852 case AVMEDIA_TYPE_SUBTITLE: {
853 char *canvas_size = NULL;
855 ist->dec = avcodec_find_decoder(par->codec_id);
856 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
857 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
859 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
860 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
865 case AVMEDIA_TYPE_ATTACHMENT:
866 case AVMEDIA_TYPE_UNKNOWN:
872 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
874 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
880 static void assert_file_overwrite(const char *filename)
882 if (file_overwrite && no_file_overwrite) {
883 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
887 if (!file_overwrite) {
888 const char *proto_name = avio_find_protocol_name(filename);
889 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
890 if (stdin_interaction && !no_file_overwrite) {
891 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
894 signal(SIGINT, SIG_DFL);
896 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
902 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
909 static void dump_attachment(AVStream *st, const char *filename)
912 AVIOContext *out = NULL;
913 AVDictionaryEntry *e;
915 if (!st->codecpar->extradata_size) {
916 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
917 nb_input_files - 1, st->index);
920 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
923 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
924 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
928 assert_file_overwrite(filename);
930 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
931 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
936 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
941 static int open_input_file(OptionsContext *o, const char *filename)
945 AVInputFormat *file_iformat = NULL;
949 AVDictionary *unused_opts = NULL;
950 AVDictionaryEntry *e = NULL;
951 int orig_nb_streams; // number of streams before avformat_find_stream_info
952 char * video_codec_name = NULL;
953 char * audio_codec_name = NULL;
954 char *subtitle_codec_name = NULL;
955 char * data_codec_name = NULL;
956 int scan_all_pmts_set = 0;
959 if (!(file_iformat = av_find_input_format(o->format))) {
960 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
965 if (!strcmp(filename, "-"))
968 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
969 strcmp(filename, "/dev/stdin");
971 /* get default parameters from command line */
972 ic = avformat_alloc_context();
974 print_error(filename, AVERROR(ENOMEM));
977 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
978 if (o->nb_audio_sample_rate) {
979 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
981 if (o->nb_audio_channels) {
982 /* because we set audio_channels based on both the "ac" and
983 * "channel_layout" options, we need to check that the specified
984 * demuxer actually has the "channels" option before setting it */
985 if (file_iformat && file_iformat->priv_class &&
986 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
987 AV_OPT_SEARCH_FAKE_OBJ)) {
988 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
991 if (o->nb_frame_rates) {
992 /* set the format-level framerate option;
993 * this is important for video grabbers, e.g. x11 */
994 if (file_iformat && file_iformat->priv_class &&
995 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
996 AV_OPT_SEARCH_FAKE_OBJ)) {
997 av_dict_set(&o->g->format_opts, "framerate",
998 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1001 if (o->nb_frame_sizes) {
1002 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1004 if (o->nb_frame_pix_fmts)
1005 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1007 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1008 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1009 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1010 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1012 ic->video_codec_id = video_codec_name ?
1013 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
1014 ic->audio_codec_id = audio_codec_name ?
1015 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
1016 ic->subtitle_codec_id= subtitle_codec_name ?
1017 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
1018 ic->data_codec_id = data_codec_name ?
1019 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
1021 if (video_codec_name)
1022 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
1023 if (audio_codec_name)
1024 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
1025 if (subtitle_codec_name)
1026 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
1027 if (data_codec_name)
1028 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
1030 ic->flags |= AVFMT_FLAG_NONBLOCK;
1031 ic->interrupt_callback = int_cb;
1033 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1034 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1035 scan_all_pmts_set = 1;
1037 /* open the input file with generic avformat function */
1038 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1040 print_error(filename, err);
1041 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1042 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1045 if (scan_all_pmts_set)
1046 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1047 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1048 assert_avoptions(o->g->format_opts);
1050 /* apply forced codec ids */
1051 for (i = 0; i < ic->nb_streams; i++)
1052 choose_decoder(o, ic, ic->streams[i]);
1054 /* Set AVCodecContext options for avformat_find_stream_info */
1055 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1056 orig_nb_streams = ic->nb_streams;
1058 /* If not enough info to get the stream parameters, we decode the
1059 first frames to get it. (used in mpeg case for example) */
1060 ret = avformat_find_stream_info(ic, opts);
1062 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1063 if (ic->nb_streams == 0) {
1064 avformat_close_input(&ic);
1069 if (o->start_time_eof != AV_NOPTS_VALUE) {
1070 if (ic->duration>0) {
1071 o->start_time = o->start_time_eof + ic->duration;
1073 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1075 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1076 /* add the stream start time */
1077 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1078 timestamp += ic->start_time;
1080 /* if seeking requested, we execute it */
1081 if (o->start_time != AV_NOPTS_VALUE) {
1082 int64_t seek_timestamp = timestamp;
1084 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1085 int dts_heuristic = 0;
1086 for (i=0; i<ic->nb_streams; i++) {
1087 const AVCodecParameters *par = ic->streams[i]->codecpar;
1088 if (par->video_delay)
1091 if (dts_heuristic) {
1092 seek_timestamp -= 3*AV_TIME_BASE / 23;
1095 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1097 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1098 filename, (double)timestamp / AV_TIME_BASE);
1102 /* update the current parameters so that they match the one of the input stream */
1103 add_input_streams(o, ic);
1105 /* dump the file content */
1106 av_dump_format(ic, nb_input_files, filename, 0);
1108 GROW_ARRAY(input_files, nb_input_files);
1109 f = av_mallocz(sizeof(*f));
1112 input_files[nb_input_files - 1] = f;
1115 f->ist_index = nb_input_streams - ic->nb_streams;
1116 f->start_time = o->start_time;
1117 f->recording_time = o->recording_time;
1118 f->input_ts_offset = o->input_ts_offset;
1119 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1120 f->nb_streams = ic->nb_streams;
1121 f->rate_emu = o->rate_emu;
1122 f->accurate_seek = o->accurate_seek;
1125 f->time_base = (AVRational){ 1, 1 };
1127 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1130 /* check if all codec options have been used */
1131 unused_opts = strip_specifiers(o->g->codec_opts);
1132 for (i = f->ist_index; i < nb_input_streams; i++) {
1134 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1135 AV_DICT_IGNORE_SUFFIX)))
1136 av_dict_set(&unused_opts, e->key, NULL, 0);
1140 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1141 const AVClass *class = avcodec_get_class();
1142 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1143 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1144 const AVClass *fclass = avformat_get_class();
1145 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1146 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1147 if (!option || foption)
1151 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1152 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1153 "input file #%d (%s) is not a decoding option.\n", e->key,
1154 option->help ? option->help : "", nb_input_files - 1,
1159 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1160 "input file #%d (%s) has not been used for any stream. The most "
1161 "likely reason is either wrong type (e.g. a video option with "
1162 "no video streams) or that it is a private option of some decoder "
1163 "which was not actually used for any stream.\n", e->key,
1164 option->help ? option->help : "", nb_input_files - 1, filename);
1166 av_dict_free(&unused_opts);
1168 for (i = 0; i < o->nb_dump_attachment; i++) {
1171 for (j = 0; j < ic->nb_streams; j++) {
1172 AVStream *st = ic->streams[j];
1174 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1175 dump_attachment(st, o->dump_attachment[i].u.str);
1179 for (i = 0; i < orig_nb_streams; i++)
1180 av_dict_free(&opts[i]);
1183 input_stream_potentially_available = 1;
1188 static uint8_t *get_line(AVIOContext *s)
1194 if (avio_open_dyn_buf(&line) < 0) {
1195 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1199 while ((c = avio_r8(s)) && c != '\n')
1202 avio_close_dyn_buf(line, &buf);
1207 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1210 char filename[1000];
1211 const char *base[3] = { getenv("AVCONV_DATADIR"),
1216 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1220 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1221 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1222 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1225 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1226 i != 1 ? "" : "/.avconv", preset_name);
1227 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1233 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1235 enum AVMediaType type = ost->st->codecpar->codec_type;
1236 char *codec_name = NULL;
1238 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1239 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1241 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1242 NULL, ost->st->codecpar->codec_type);
1243 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1245 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1246 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1247 "probably disabled. Please choose an encoder manually.\n",
1248 ost->file_index, ost->index, s->oformat->name,
1249 avcodec_get_name(ost->st->codecpar->codec_id));
1250 return AVERROR_ENCODER_NOT_FOUND;
1252 } else if (!strcmp(codec_name, "copy"))
1253 ost->stream_copy = 1;
1255 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1256 ost->st->codecpar->codec_id = ost->enc->id;
1258 ost->encoding_needed = !ost->stream_copy;
1260 /* no encoding supported for other media types */
1261 ost->stream_copy = 1;
1262 ost->encoding_needed = 0;
1268 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1271 AVStream *st = avformat_new_stream(oc, NULL);
1272 int idx = oc->nb_streams - 1, ret = 0;
1273 const char *bsfs = NULL, *time_base = NULL;
1274 char *next, *codec_tag = NULL;
1279 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1283 if (oc->nb_streams - 1 < o->nb_streamid_map)
1284 st->id = o->streamid_map[oc->nb_streams - 1];
1286 GROW_ARRAY(output_streams, nb_output_streams);
1287 if (!(ost = av_mallocz(sizeof(*ost))))
1289 output_streams[nb_output_streams - 1] = ost;
1291 ost->file_index = nb_output_files - 1;
1294 st->codecpar->codec_type = type;
1296 ret = choose_encoder(o, oc, ost);
1298 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1299 "%d:%d\n", ost->file_index, ost->index);
1303 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1304 if (!ost->enc_ctx) {
1305 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1308 ost->enc_ctx->codec_type = type;
1310 ost->ref_par = avcodec_parameters_alloc();
1311 if (!ost->ref_par) {
1312 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1317 AVIOContext *s = NULL;
1318 char *buf = NULL, *arg = NULL, *preset = NULL;
1320 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1322 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1323 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1326 if (!buf[0] || buf[0] == '#') {
1330 if (!(arg = strchr(buf, '='))) {
1331 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1335 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1337 } while (!s->eof_reached);
1341 av_log(NULL, AV_LOG_FATAL,
1342 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1343 preset, ost->file_index, ost->index);
1347 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1350 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1353 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1354 q.num <= 0 || q.den <= 0) {
1355 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1361 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1364 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1366 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1369 ost->enc_timebase = q;
1372 ost->max_frames = INT64_MAX;
1373 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1374 for (i = 0; i<o->nb_max_frames; i++) {
1375 char *p = o->max_frames[i].specifier;
1376 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1377 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1382 ost->copy_prior_start = -1;
1383 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1385 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1386 while (bsfs && *bsfs) {
1387 const AVBitStreamFilter *filter;
1388 char *bsf, *bsf_options_str, *bsf_name;
1390 bsf = av_get_token(&bsfs, ",");
1393 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1397 filter = av_bsf_get_by_name(bsf_name);
1399 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1403 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1404 ost->nb_bitstream_filters + 1,
1405 sizeof(*ost->bsf_ctx));
1409 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1411 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1415 ost->nb_bitstream_filters++;
1417 if (bsf_options_str && filter->priv_class) {
1418 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1419 const char * shorthand[2] = {NULL};
1422 shorthand[0] = opt->name;
1424 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1426 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1436 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1438 uint32_t tag = strtol(codec_tag, &next, 0);
1440 tag = AV_RL32(codec_tag);
1441 ost->st->codecpar->codec_tag =
1442 ost->enc_ctx->codec_tag = tag;
1445 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1447 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1448 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1451 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1452 ost->disposition = av_strdup(ost->disposition);
1454 ost->max_muxing_queue_size = 128;
1455 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1456 ost->max_muxing_queue_size *= sizeof(AVPacket);
1458 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1459 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1461 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1463 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1464 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1465 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1467 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1469 ost->source_index = source_index;
1470 if (source_index >= 0) {
1471 ost->sync_ist = input_streams[source_index];
1472 input_streams[source_index]->discard = 0;
1473 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1475 ost->last_mux_dts = AV_NOPTS_VALUE;
1477 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1478 if (!ost->muxing_queue)
1484 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1487 const char *p = str;
1494 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1501 /* read file contents into a string */
1502 static uint8_t *read_file(const char *filename)
1504 AVIOContext *pb = NULL;
1505 AVIOContext *dyn_buf = NULL;
1506 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1507 uint8_t buf[1024], *str;
1510 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1514 ret = avio_open_dyn_buf(&dyn_buf);
1519 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1520 avio_write(dyn_buf, buf, ret);
1521 avio_w8(dyn_buf, 0);
1524 ret = avio_close_dyn_buf(dyn_buf, &str);
1530 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1533 AVStream *st = ost->st;
1535 if (ost->filters_script && ost->filters) {
1536 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1537 "output stream #%d:%d.\n", nb_output_files, st->index);
1541 if (ost->filters_script)
1542 return read_file(ost->filters_script);
1543 else if (ost->filters)
1544 return av_strdup(ost->filters);
1546 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1550 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1551 const OutputStream *ost, enum AVMediaType type)
1553 if (ost->filters_script || ost->filters) {
1554 av_log(NULL, AV_LOG_ERROR,
1555 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1556 "Filtering and streamcopy cannot be used together.\n",
1557 ost->filters ? "Filtergraph" : "Filtergraph script",
1558 ost->filters ? ost->filters : ost->filters_script,
1559 av_get_media_type_string(type), ost->file_index, ost->index);
1564 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1568 AVCodecContext *video_enc;
1569 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1571 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1573 video_enc = ost->enc_ctx;
1575 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1576 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1577 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1580 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1581 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1583 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1584 if (frame_aspect_ratio) {
1586 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1587 q.num <= 0 || q.den <= 0) {
1588 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1591 ost->frame_aspect_ratio = q;
1594 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1595 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1597 if (!ost->stream_copy) {
1598 const char *p = NULL;
1599 char *frame_size = NULL;
1600 char *frame_pix_fmt = NULL;
1601 char *intra_matrix = NULL, *inter_matrix = NULL;
1602 char *chroma_intra_matrix = NULL;
1606 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1607 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1608 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1612 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1613 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1614 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1615 ost->keep_pix_fmt = 1;
1616 if (!*++frame_pix_fmt)
1617 frame_pix_fmt = NULL;
1619 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1620 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1623 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1626 video_enc->gop_size = 0;
1627 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1629 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1630 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1633 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1635 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1636 if (chroma_intra_matrix) {
1637 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1639 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1642 av_codec_set_chroma_intra_matrix(video_enc, p);
1643 parse_matrix_coeffs(p, chroma_intra_matrix);
1645 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1647 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1648 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1651 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1654 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1655 for (i = 0; p; i++) {
1657 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1659 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1662 video_enc->rc_override =
1663 av_realloc_array(video_enc->rc_override,
1664 i + 1, sizeof(RcOverride));
1665 if (!video_enc->rc_override) {
1666 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1669 video_enc->rc_override[i].start_frame = start;
1670 video_enc->rc_override[i].end_frame = end;
1672 video_enc->rc_override[i].qscale = q;
1673 video_enc->rc_override[i].quality_factor = 1.0;
1676 video_enc->rc_override[i].qscale = 0;
1677 video_enc->rc_override[i].quality_factor = -q/100.0;
1682 video_enc->rc_override_count = i;
1685 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1688 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1691 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1692 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1695 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1696 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1700 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1701 if (ost->logfile_prefix &&
1702 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1706 char logfilename[1024];
1709 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1710 ost->logfile_prefix ? ost->logfile_prefix :
1711 DEFAULT_PASS_LOGFILENAME_PREFIX,
1713 if (!strcmp(ost->enc->name, "libx264")) {
1714 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1716 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1717 char *logbuffer = read_file(logfilename);
1720 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1724 video_enc->stats_in = logbuffer;
1726 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1727 f = av_fopen_utf8(logfilename, "wb");
1729 av_log(NULL, AV_LOG_FATAL,
1730 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1731 logfilename, strerror(errno));
1739 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1740 if (ost->forced_keyframes)
1741 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1743 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1745 ost->top_field_first = -1;
1746 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1749 ost->avfilter = get_ost_filters(o, oc, ost);
1753 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1756 if (ost->stream_copy)
1757 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1762 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1767 AVCodecContext *audio_enc;
1769 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1772 audio_enc = ost->enc_ctx;
1773 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1775 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1776 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1778 if (!ost->stream_copy) {
1779 char *sample_fmt = NULL;
1781 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1783 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1785 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1786 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1790 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1792 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1793 ost->apad = av_strdup(ost->apad);
1795 ost->avfilter = get_ost_filters(o, oc, ost);
1799 /* check for channel mapping for this audio stream */
1800 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1801 AudioChannelMap *map = &o->audio_channel_maps[n];
1802 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1803 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1806 if (map->channel_idx == -1) {
1808 } else if (ost->source_index < 0) {
1809 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1810 ost->file_index, ost->st->index);
1813 ist = input_streams[ost->source_index];
1816 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1817 if (av_reallocp_array(&ost->audio_channels_map,
1818 ost->audio_channels_mapped + 1,
1819 sizeof(*ost->audio_channels_map)
1823 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1829 if (ost->stream_copy)
1830 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1835 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1839 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1840 if (!ost->stream_copy) {
1841 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1848 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1852 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1853 if (!ost->stream_copy) {
1854 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1861 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1863 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1864 ost->stream_copy = 1;
1869 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1873 AVCodecContext *subtitle_enc;
1875 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1877 subtitle_enc = ost->enc_ctx;
1879 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1881 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1883 if (!ost->stream_copy) {
1884 char *frame_size = NULL;
1886 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1887 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1888 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1896 /* arg format is "output-stream-index:streamid-value". */
1897 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1899 OptionsContext *o = optctx;
1904 av_strlcpy(idx_str, arg, sizeof(idx_str));
1905 p = strchr(idx_str, ':');
1907 av_log(NULL, AV_LOG_FATAL,
1908 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1913 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1914 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1915 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1919 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1921 AVFormatContext *is = ifile->ctx;
1922 AVFormatContext *os = ofile->ctx;
1926 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1928 return AVERROR(ENOMEM);
1931 for (i = 0; i < is->nb_chapters; i++) {
1932 AVChapter *in_ch = is->chapters[i], *out_ch;
1933 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1934 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1935 AV_TIME_BASE_Q, in_ch->time_base);
1936 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1937 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1940 if (in_ch->end < ts_off)
1942 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1945 out_ch = av_mallocz(sizeof(AVChapter));
1947 return AVERROR(ENOMEM);
1949 out_ch->id = in_ch->id;
1950 out_ch->time_base = in_ch->time_base;
1951 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1952 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1955 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1957 os->chapters[os->nb_chapters++] = out_ch;
1962 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1965 AVFormatContext *ic = avformat_alloc_context();
1967 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1968 ic->interrupt_callback = int_cb;
1969 err = avformat_open_input(&ic, filename, NULL, NULL);
1972 /* copy stream format */
1973 for(i=0;i<ic->nb_streams;i++) {
1977 const char *enc_config;
1979 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1981 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1982 return AVERROR(EINVAL);
1984 if (codec->type == AVMEDIA_TYPE_AUDIO)
1985 opt_audio_codec(o, "c:a", codec->name);
1986 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1987 opt_video_codec(o, "c:v", codec->name);
1988 ost = new_output_stream(o, s, codec->type, -1);
1991 avcodec_get_context_defaults3(st->codec, codec);
1992 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1994 AVDictionary *opts = NULL;
1995 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1996 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1997 av_dict_free(&opts);
2000 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2001 choose_sample_fmt(st, codec);
2002 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2003 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2004 avcodec_copy_context(ost->enc_ctx, st->codec);
2006 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2009 avformat_close_input(&ic);
2013 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2014 AVFormatContext *oc)
2018 switch (ofilter->type) {
2019 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2020 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2022 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2027 ost->source_index = -1;
2028 ost->filter = ofilter;
2031 ofilter->format = -1;
2033 if (ost->stream_copy) {
2034 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2035 "which is fed from a complex filtergraph. Filtering and streamcopy "
2036 "cannot be used together.\n", ost->file_index, ost->index);
2040 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2041 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2042 av_log(NULL, AV_LOG_ERROR,
2043 "%s '%s' was specified through the %s option "
2044 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2045 "%s and -filter_complex cannot be used together for the same stream.\n",
2046 ost->filters ? "Filtergraph" : "Filtergraph script",
2047 ost->filters ? ost->filters : ost->filters_script,
2048 opt, ost->file_index, ost->index, opt);
2052 avfilter_inout_free(&ofilter->out_tmp);
2055 static int init_complex_filters(void)
2059 for (i = 0; i < nb_filtergraphs; i++) {
2060 ret = init_complex_filtergraph(filtergraphs[i]);
2067 static int open_output_file(OptionsContext *o, const char *filename)
2069 AVFormatContext *oc;
2071 AVOutputFormat *file_oformat;
2075 AVDictionary *unused_opts = NULL;
2076 AVDictionaryEntry *e = NULL;
2077 int format_flags = 0;
2079 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2080 o->stop_time = INT64_MAX;
2081 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2084 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2085 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2086 if (o->stop_time <= start_time) {
2087 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2090 o->recording_time = o->stop_time - start_time;
2094 GROW_ARRAY(output_files, nb_output_files);
2095 of = av_mallocz(sizeof(*of));
2098 output_files[nb_output_files - 1] = of;
2100 of->ost_index = nb_output_streams;
2101 of->recording_time = o->recording_time;
2102 of->start_time = o->start_time;
2103 of->limit_filesize = o->limit_filesize;
2104 of->shortest = o->shortest;
2105 av_dict_copy(&of->opts, o->g->format_opts, 0);
2107 if (!strcmp(filename, "-"))
2110 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2112 print_error(filename, err);
2117 if (o->recording_time != INT64_MAX)
2118 oc->duration = o->recording_time;
2120 file_oformat= oc->oformat;
2121 oc->interrupt_callback = int_cb;
2123 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2125 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2126 av_opt_eval_flags(oc, o, e->value, &format_flags);
2129 /* create streams for all unlabeled output pads */
2130 for (i = 0; i < nb_filtergraphs; i++) {
2131 FilterGraph *fg = filtergraphs[i];
2132 for (j = 0; j < fg->nb_outputs; j++) {
2133 OutputFilter *ofilter = fg->outputs[j];
2135 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2138 switch (ofilter->type) {
2139 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2140 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2141 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2143 init_output_filter(ofilter, o, oc);
2147 /* ffserver seeking with date=... needs a date reference */
2148 if (!strcmp(file_oformat->name, "ffm") &&
2149 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2150 av_strstart(filename, "http:", NULL)) {
2151 int err = parse_option(o, "metadata", "creation_time=now", options);
2153 print_error(filename, err);
2158 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2159 av_strstart(filename, "http:", NULL)) {
2161 /* special case for files sent to ffserver: we get the stream
2162 parameters from ffserver */
2163 int err = read_ffserver_streams(o, oc, filename);
2165 print_error(filename, err);
2168 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2169 ost = output_streams[j];
2170 for (i = 0; i < nb_input_streams; i++) {
2171 ist = input_streams[i];
2172 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2174 ost->source_index= i;
2175 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2176 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2178 ist->st->discard = ist->user_set_discard;
2183 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));
2187 } else if (!o->nb_stream_maps) {
2188 char *subtitle_codec_name = NULL;
2189 /* pick the "best" stream of each type */
2191 /* video: highest resolution */
2192 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2193 int area = 0, idx = -1;
2194 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2195 for (i = 0; i < nb_input_streams; i++) {
2197 ist = input_streams[i];
2198 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2199 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2201 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2203 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2210 new_video_stream(o, oc, idx);
2213 /* audio: most channels */
2214 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2215 int best_score = 0, idx = -1;
2216 for (i = 0; i < nb_input_streams; i++) {
2218 ist = input_streams[i];
2219 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2220 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2221 score > best_score) {
2227 new_audio_stream(o, oc, idx);
2230 /* subtitles: pick first */
2231 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2232 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2233 for (i = 0; i < nb_input_streams; i++)
2234 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2235 AVCodecDescriptor const *input_descriptor =
2236 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2237 AVCodecDescriptor const *output_descriptor = NULL;
2238 AVCodec const *output_codec =
2239 avcodec_find_encoder(oc->oformat->subtitle_codec);
2240 int input_props = 0, output_props = 0;
2242 output_descriptor = avcodec_descriptor_get(output_codec->id);
2243 if (input_descriptor)
2244 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2245 if (output_descriptor)
2246 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2247 if (subtitle_codec_name ||
2248 input_props & output_props ||
2249 // Map dvb teletext which has neither property to any output subtitle encoder
2250 input_descriptor && output_descriptor &&
2251 (!input_descriptor->props ||
2252 !output_descriptor->props)) {
2253 new_subtitle_stream(o, oc, i);
2258 /* Data only if codec id match */
2259 if (!o->data_disable ) {
2260 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2261 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2262 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2263 && input_streams[i]->st->codecpar->codec_id == codec_id )
2264 new_data_stream(o, oc, i);
2268 for (i = 0; i < o->nb_stream_maps; i++) {
2269 StreamMap *map = &o->stream_maps[i];
2274 if (map->linklabel) {
2276 OutputFilter *ofilter = NULL;
2279 for (j = 0; j < nb_filtergraphs; j++) {
2280 fg = filtergraphs[j];
2281 for (k = 0; k < fg->nb_outputs; k++) {
2282 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2283 if (out && !strcmp(out->name, map->linklabel)) {
2284 ofilter = fg->outputs[k];
2291 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2292 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2295 init_output_filter(ofilter, o, oc);
2297 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2299 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2300 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2302 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2304 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2306 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2310 switch (ist->st->codecpar->codec_type) {
2311 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2312 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2313 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2314 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2315 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2316 case AVMEDIA_TYPE_UNKNOWN:
2317 if (copy_unknown_streams) {
2318 ost = new_unknown_stream (o, oc, src_idx);
2322 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2323 "Cannot map stream #%d:%d - unsupported type.\n",
2324 map->file_index, map->stream_index);
2325 if (!ignore_unknown_streams) {
2326 av_log(NULL, AV_LOG_FATAL,
2327 "If you want unsupported types ignored instead "
2328 "of failing, please use the -ignore_unknown option\n"
2329 "If you want them copied, please use -copy_unknown\n");
2334 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2335 + map->sync_stream_index];
2340 /* handle attached files */
2341 for (i = 0; i < o->nb_attachments; i++) {
2343 uint8_t *attachment;
2347 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2348 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2352 if ((len = avio_size(pb)) <= 0) {
2353 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2357 if (!(attachment = av_malloc(len))) {
2358 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2362 avio_read(pb, attachment, len);
2364 ost = new_attachment_stream(o, oc, -1);
2365 ost->stream_copy = 0;
2366 ost->attachment_filename = o->attachments[i];
2367 ost->st->codecpar->extradata = attachment;
2368 ost->st->codecpar->extradata_size = len;
2370 p = strrchr(o->attachments[i], '/');
2371 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2375 #if FF_API_LAVF_AVCTX
2376 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2377 AVDictionaryEntry *e;
2378 ost = output_streams[i];
2380 if ((ost->stream_copy || ost->attachment_filename)
2381 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2382 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2383 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2388 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2389 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2390 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2394 /* check if all codec options have been used */
2395 unused_opts = strip_specifiers(o->g->codec_opts);
2396 for (i = of->ost_index; i < nb_output_streams; i++) {
2398 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2399 AV_DICT_IGNORE_SUFFIX)))
2400 av_dict_set(&unused_opts, e->key, NULL, 0);
2404 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2405 const AVClass *class = avcodec_get_class();
2406 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2407 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2408 const AVClass *fclass = avformat_get_class();
2409 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2410 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2411 if (!option || foption)
2415 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2416 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2417 "output file #%d (%s) is not an encoding option.\n", e->key,
2418 option->help ? option->help : "", nb_output_files - 1,
2423 // gop_timecode is injected by generic code but not always used
2424 if (!strcmp(e->key, "gop_timecode"))
2427 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2428 "output file #%d (%s) has not been used for any stream. The most "
2429 "likely reason is either wrong type (e.g. a video option with "
2430 "no video streams) or that it is a private option of some encoder "
2431 "which was not actually used for any stream.\n", e->key,
2432 option->help ? option->help : "", nb_output_files - 1, filename);
2434 av_dict_free(&unused_opts);
2436 /* set the decoding_needed flags and create simple filtergraphs */
2437 for (i = of->ost_index; i < nb_output_streams; i++) {
2438 OutputStream *ost = output_streams[i];
2440 if (ost->encoding_needed && ost->source_index >= 0) {
2441 InputStream *ist = input_streams[ost->source_index];
2442 ist->decoding_needed |= DECODING_FOR_OST;
2444 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2445 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2446 err = init_simple_filtergraph(ist, ost);
2448 av_log(NULL, AV_LOG_ERROR,
2449 "Error initializing a simple filtergraph between streams "
2450 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2451 nb_output_files - 1, ost->st->index);
2457 /* set the filter output constraints */
2459 OutputFilter *f = ost->filter;
2461 switch (ost->enc_ctx->codec_type) {
2462 case AVMEDIA_TYPE_VIDEO:
2463 f->frame_rate = ost->frame_rate;
2464 f->width = ost->enc_ctx->width;
2465 f->height = ost->enc_ctx->height;
2466 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2467 f->format = ost->enc_ctx->pix_fmt;
2468 } else if (ost->enc->pix_fmts) {
2470 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2472 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2475 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2478 case AVMEDIA_TYPE_AUDIO:
2479 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2480 f->format = ost->enc_ctx->sample_fmt;
2481 } else if (ost->enc->sample_fmts) {
2483 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2485 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2488 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2490 if (ost->enc_ctx->sample_rate) {
2491 f->sample_rate = ost->enc_ctx->sample_rate;
2492 } else if (ost->enc->supported_samplerates) {
2494 while (ost->enc->supported_samplerates[count])
2496 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2497 if (!f->sample_rates)
2499 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2500 (count + 1) * sizeof(*f->sample_rates));
2502 if (ost->enc_ctx->channels) {
2503 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2504 } else if (ost->enc->channel_layouts) {
2506 while (ost->enc->channel_layouts[count])
2508 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2509 if (!f->channel_layouts)
2511 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2512 (count + 1) * sizeof(*f->channel_layouts));
2519 /* check filename in case of an image number is expected */
2520 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2521 if (!av_filename_number_test(oc->filename)) {
2522 print_error(oc->filename, AVERROR(EINVAL));
2527 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2528 av_log(NULL, AV_LOG_ERROR,
2529 "No input streams but output needs an input stream\n");
2533 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2534 /* test if it already exists to avoid losing precious files */
2535 assert_file_overwrite(filename);
2538 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2539 &oc->interrupt_callback,
2541 print_error(filename, err);
2544 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2545 assert_file_overwrite(filename);
2547 if (o->mux_preload) {
2548 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2550 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2553 for (i = 0; i < o->nb_metadata_map; i++) {
2555 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2557 if (in_file_index >= nb_input_files) {
2558 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2561 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2562 in_file_index >= 0 ?
2563 input_files[in_file_index]->ctx : NULL, o);
2567 if (o->chapters_input_file >= nb_input_files) {
2568 if (o->chapters_input_file == INT_MAX) {
2569 /* copy chapters from the first input file that has them*/
2570 o->chapters_input_file = -1;
2571 for (i = 0; i < nb_input_files; i++)
2572 if (input_files[i]->ctx->nb_chapters) {
2573 o->chapters_input_file = i;
2577 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2578 o->chapters_input_file);
2582 if (o->chapters_input_file >= 0)
2583 copy_chapters(input_files[o->chapters_input_file], of,
2584 !o->metadata_chapters_manual);
2586 /* copy global metadata by default */
2587 if (!o->metadata_global_manual && nb_input_files){
2588 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2589 AV_DICT_DONT_OVERWRITE);
2590 if(o->recording_time != INT64_MAX)
2591 av_dict_set(&oc->metadata, "duration", NULL, 0);
2592 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2594 if (!o->metadata_streams_manual)
2595 for (i = of->ost_index; i < nb_output_streams; i++) {
2597 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2599 ist = input_streams[output_streams[i]->source_index];
2600 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2601 if (!output_streams[i]->stream_copy) {
2602 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2606 /* process manually set programs */
2607 for (i = 0; i < o->nb_program; i++) {
2608 const char *p = o->program[i].u.str;
2613 const char *p2 = av_get_token(&p, ":");
2614 const char *to_dealloc = p2;
2621 key = av_get_token(&p2, "=");
2623 av_freep(&to_dealloc);
2629 if (!strcmp(key, "program_num"))
2630 progid = strtol(p2, NULL, 0);
2631 av_freep(&to_dealloc);
2635 program = av_new_program(oc, progid);
2637 p = o->program[i].u.str;
2639 const char *p2 = av_get_token(&p, ":");
2640 const char *to_dealloc = p2;
2646 key = av_get_token(&p2, "=");
2648 av_log(NULL, AV_LOG_FATAL,
2649 "No '=' character in program string %s.\n",
2657 if (!strcmp(key, "title")) {
2658 av_dict_set(&program->metadata, "title", p2, 0);
2659 } else if (!strcmp(key, "program_num")) {
2660 } else if (!strcmp(key, "st")) {
2661 int st_num = strtol(p2, NULL, 0);
2662 av_program_add_stream_index(oc, progid, st_num);
2664 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2667 av_freep(&to_dealloc);
2672 /* process manually set metadata */
2673 for (i = 0; i < o->nb_metadata; i++) {
2676 const char *stream_spec;
2677 int index = 0, j, ret = 0;
2679 val = strchr(o->metadata[i].u.str, '=');
2681 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2682 o->metadata[i].u.str);
2687 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2689 for (j = 0; j < oc->nb_streams; j++) {
2690 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2691 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2692 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2694 double theta = av_strtod(val, &tail);
2696 ost->rotate_overridden = 1;
2697 ost->rotate_override_value = theta;
2700 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2712 if (index < 0 || index >= oc->nb_chapters) {
2713 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2716 m = &oc->chapters[index]->metadata;
2719 if (index < 0 || index >= oc->nb_programs) {
2720 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2723 m = &oc->programs[index]->metadata;
2726 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2729 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2736 static int opt_target(void *optctx, const char *opt, const char *arg)
2738 OptionsContext *o = optctx;
2739 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2740 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2742 if (!strncmp(arg, "pal-", 4)) {
2745 } else if (!strncmp(arg, "ntsc-", 5)) {
2748 } else if (!strncmp(arg, "film-", 5)) {
2752 /* Try to determine PAL/NTSC by peeking in the input files */
2753 if (nb_input_files) {
2755 for (j = 0; j < nb_input_files; j++) {
2756 for (i = 0; i < input_files[j]->nb_streams; i++) {
2757 AVStream *st = input_files[j]->ctx->streams[i];
2758 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2760 fr = st->time_base.den * 1000 / st->time_base.num;
2764 } else if ((fr == 29970) || (fr == 23976)) {
2769 if (norm != UNKNOWN)
2773 if (norm != UNKNOWN)
2774 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2777 if (norm == UNKNOWN) {
2778 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2779 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2780 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2784 if (!strcmp(arg, "vcd")) {
2785 opt_video_codec(o, "c:v", "mpeg1video");
2786 opt_audio_codec(o, "c:a", "mp2");
2787 parse_option(o, "f", "vcd", options);
2789 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2790 parse_option(o, "r", frame_rates[norm], options);
2791 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2793 opt_default(NULL, "b:v", "1150000");
2794 opt_default(NULL, "maxrate:v", "1150000");
2795 opt_default(NULL, "minrate:v", "1150000");
2796 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2798 opt_default(NULL, "b:a", "224000");
2799 parse_option(o, "ar", "44100", options);
2800 parse_option(o, "ac", "2", options);
2802 opt_default(NULL, "packetsize", "2324");
2803 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2805 /* We have to offset the PTS, so that it is consistent with the SCR.
2806 SCR starts at 36000, but the first two packs contain only padding
2807 and the first pack from the other stream, respectively, may also have
2808 been written before.
2809 So the real data starts at SCR 36000+3*1200. */
2810 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2811 } else if (!strcmp(arg, "svcd")) {
2813 opt_video_codec(o, "c:v", "mpeg2video");
2814 opt_audio_codec(o, "c:a", "mp2");
2815 parse_option(o, "f", "svcd", options);
2817 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2818 parse_option(o, "r", frame_rates[norm], options);
2819 parse_option(o, "pix_fmt", "yuv420p", options);
2820 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2822 opt_default(NULL, "b:v", "2040000");
2823 opt_default(NULL, "maxrate:v", "2516000");
2824 opt_default(NULL, "minrate:v", "0"); // 1145000;
2825 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2826 opt_default(NULL, "scan_offset", "1");
2828 opt_default(NULL, "b:a", "224000");
2829 parse_option(o, "ar", "44100", options);
2831 opt_default(NULL, "packetsize", "2324");
2833 } else if (!strcmp(arg, "dvd")) {
2835 opt_video_codec(o, "c:v", "mpeg2video");
2836 opt_audio_codec(o, "c:a", "ac3");
2837 parse_option(o, "f", "dvd", options);
2839 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2840 parse_option(o, "r", frame_rates[norm], options);
2841 parse_option(o, "pix_fmt", "yuv420p", options);
2842 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2844 opt_default(NULL, "b:v", "6000000");
2845 opt_default(NULL, "maxrate:v", "9000000");
2846 opt_default(NULL, "minrate:v", "0"); // 1500000;
2847 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2849 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2850 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2852 opt_default(NULL, "b:a", "448000");
2853 parse_option(o, "ar", "48000", options);
2855 } else if (!strncmp(arg, "dv", 2)) {
2857 parse_option(o, "f", "dv", options);
2859 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2860 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2861 norm == PAL ? "yuv420p" : "yuv411p", options);
2862 parse_option(o, "r", frame_rates[norm], options);
2864 parse_option(o, "ar", "48000", options);
2865 parse_option(o, "ac", "2", options);
2868 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2869 return AVERROR(EINVAL);
2872 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2873 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2878 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2880 av_free (vstats_filename);
2881 vstats_filename = av_strdup (arg);
2885 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2888 time_t today2 = time(NULL);
2889 struct tm *today = localtime(&today2);
2891 if (!today) { // maybe tomorrow
2892 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2896 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2898 return opt_vstats_file(NULL, opt, filename);
2901 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2903 OptionsContext *o = optctx;
2904 return parse_option(o, "frames:v", arg, options);
2907 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2909 OptionsContext *o = optctx;
2910 return parse_option(o, "frames:a", arg, options);
2913 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2915 OptionsContext *o = optctx;
2916 return parse_option(o, "frames:d", arg, options);
2919 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2922 AVDictionary *cbak = codec_opts;
2923 AVDictionary *fbak = format_opts;
2927 ret = opt_default(NULL, opt, arg);
2929 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2930 av_dict_copy(&o->g->format_opts, format_opts, 0);
2931 av_dict_free(&codec_opts);
2932 av_dict_free(&format_opts);
2939 static int opt_preset(void *optctx, const char *opt, const char *arg)
2941 OptionsContext *o = optctx;
2943 char filename[1000], line[1000], tmp_line[1000];
2944 const char *codec_name = NULL;
2948 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2950 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2951 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2952 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2954 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2958 while (fgets(line, sizeof(line), f)) {
2959 char *key = tmp_line, *value, *endptr;
2961 if (strcspn(line, "#\n\r") == 0)
2963 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2964 if (!av_strtok(key, "=", &value) ||
2965 !av_strtok(value, "\r\n", &endptr)) {
2966 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2969 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2971 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2972 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2973 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2974 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2975 else if (opt_default_new(o, key, value) < 0) {
2976 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2977 filename, line, key, value);
2987 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2989 OptionsContext *o = optctx;
2990 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2991 int ret = parse_option(o, s, arg, options);
2996 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2998 OptionsContext *o = optctx;
3000 if(!strcmp(opt, "ab")){
3001 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3003 } else if(!strcmp(opt, "b")){
3004 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3005 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3008 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3012 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3014 OptionsContext *o = optctx;
3017 if(!strcmp(opt, "qscale")){
3018 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3019 return parse_option(o, "q:v", arg, options);
3021 s = av_asprintf("q%s", opt + 6);
3022 ret = parse_option(o, s, arg, options);
3027 static int opt_profile(void *optctx, const char *opt, const char *arg)
3029 OptionsContext *o = optctx;
3030 if(!strcmp(opt, "profile")){
3031 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3032 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3035 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3039 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3041 OptionsContext *o = optctx;
3042 return parse_option(o, "filter:v", arg, options);
3045 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3047 OptionsContext *o = optctx;
3048 return parse_option(o, "filter:a", arg, options);
3051 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3053 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3054 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3055 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3056 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3058 if (video_sync_method == VSYNC_AUTO)
3059 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3063 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3065 OptionsContext *o = optctx;
3066 char *tcr = av_asprintf("timecode=%s", arg);
3067 int ret = parse_option(o, "metadata:g", tcr, options);
3069 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3074 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3076 OptionsContext *o = optctx;
3077 char layout_str[32];
3080 int ret, channels, ac_str_size;
3083 layout = av_get_channel_layout(arg);
3085 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3086 return AVERROR(EINVAL);
3088 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3089 ret = opt_default_new(o, opt, layout_str);
3093 /* set 'ac' option based on channel layout */
3094 channels = av_get_channel_layout_nb_channels(layout);
3095 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3096 stream_str = strchr(opt, ':');
3097 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3098 ac_str = av_mallocz(ac_str_size);
3100 return AVERROR(ENOMEM);
3101 av_strlcpy(ac_str, "ac", 3);
3103 av_strlcat(ac_str, stream_str, ac_str_size);
3104 ret = parse_option(o, ac_str, layout_str, options);
3110 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3112 OptionsContext *o = optctx;
3113 return parse_option(o, "q:a", arg, options);
3116 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3118 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3119 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3120 return AVERROR(ENOMEM);
3121 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3122 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3123 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3124 return AVERROR(ENOMEM);
3126 input_stream_potentially_available = 1;
3131 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3133 uint8_t *graph_desc = read_file(arg);
3135 return AVERROR(EINVAL);
3137 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3138 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3139 return AVERROR(ENOMEM);
3140 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3141 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3143 input_stream_potentially_available = 1;
3148 void show_help_default(const char *opt, const char *arg)
3150 /* per-file options have at least one of those set */
3151 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3152 int show_advanced = 0, show_avoptions = 0;
3155 if (!strcmp(opt, "long"))
3157 else if (!strcmp(opt, "full"))
3158 show_advanced = show_avoptions = 1;
3160 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3165 printf("Getting help:\n"
3166 " -h -- print basic options\n"
3167 " -h long -- print more options\n"
3168 " -h full -- print all options (including all format and codec specific options, very long)\n"
3169 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3170 " See man %s for detailed description of the options.\n"
3171 "\n", program_name);
3173 show_help_options(options, "Print help / information / capabilities:",
3176 show_help_options(options, "Global options (affect whole program "
3177 "instead of just one file:",
3178 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3180 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3181 per_file | OPT_EXIT, 0);
3183 show_help_options(options, "Per-file main options:", 0,
3184 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3185 OPT_EXIT, per_file);
3187 show_help_options(options, "Advanced per-file options:",
3188 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3190 show_help_options(options, "Video options:",
3191 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3193 show_help_options(options, "Advanced Video options:",
3194 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3196 show_help_options(options, "Audio options:",
3197 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3199 show_help_options(options, "Advanced Audio options:",
3200 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3201 show_help_options(options, "Subtitle options:",
3202 OPT_SUBTITLE, 0, 0);
3205 if (show_avoptions) {
3206 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3207 show_help_children(avcodec_get_class(), flags);
3208 show_help_children(avformat_get_class(), flags);
3210 show_help_children(sws_get_class(), flags);
3212 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3213 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3217 void show_usage(void)
3219 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3220 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3221 av_log(NULL, AV_LOG_INFO, "\n");
3229 static const OptionGroupDef groups[] = {
3230 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3231 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3234 static int open_files(OptionGroupList *l, const char *inout,
3235 int (*open_file)(OptionsContext*, const char*))
3239 for (i = 0; i < l->nb_groups; i++) {
3240 OptionGroup *g = &l->groups[i];
3246 ret = parse_optgroup(&o, g);
3248 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3249 "%s.\n", inout, g->arg);
3253 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3254 ret = open_file(&o, g->arg);
3257 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3261 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3267 int ffmpeg_parse_options(int argc, char **argv)
3269 OptionParseContext octx;
3273 memset(&octx, 0, sizeof(octx));
3275 /* split the commandline into an internal representation */
3276 ret = split_commandline(&octx, argc, argv, options, groups,
3277 FF_ARRAY_ELEMS(groups));
3279 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3283 /* apply global options */
3284 ret = parse_optgroup(NULL, &octx.global_opts);
3286 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3290 /* configure terminal and setup signal handlers */
3293 /* open input files */
3294 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3296 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3300 /* create the complex filtergraphs */
3301 ret = init_complex_filters();
3303 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3307 /* open output files */
3308 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3310 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3314 check_filter_outputs();
3317 uninit_parse_context(&octx);
3319 av_strerror(ret, error, sizeof(error));
3320 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3325 static int opt_progress(void *optctx, const char *opt, const char *arg)
3327 AVIOContext *avio = NULL;
3330 if (!strcmp(arg, "-"))
3332 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3334 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3335 arg, av_err2str(ret));
3338 progress_avio = avio;
3342 #define OFFSET(x) offsetof(OptionsContext, x)
3343 const OptionDef options[] = {
3345 CMDUTILS_COMMON_OPTIONS
3346 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3347 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3348 "force format", "fmt" },
3349 { "y", OPT_BOOL, { &file_overwrite },
3350 "overwrite output files" },
3351 { "n", OPT_BOOL, { &no_file_overwrite },
3352 "never overwrite output files" },
3353 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3354 "Ignore unknown stream types" },
3355 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3356 "Copy unknown stream types" },
3357 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3358 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3359 "codec name", "codec" },
3360 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3361 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3362 "codec name", "codec" },
3363 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3364 OPT_OUTPUT, { .off = OFFSET(presets) },
3365 "preset name", "preset" },
3366 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3367 OPT_OUTPUT, { .func_arg = opt_map },
3368 "set input stream mapping",
3369 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3370 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3371 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3372 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3373 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3374 "set metadata information of outfile from infile",
3375 "outfile[,metadata]:infile[,metadata]" },
3376 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3377 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3378 "set chapters mapping", "input_file_index" },
3379 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3380 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3381 "record or transcode \"duration\" seconds of audio/video",
3383 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3384 "record or transcode stop time", "time_stop" },
3385 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3386 "set the limit file size in bytes", "limit_size" },
3387 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3388 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3389 "set the start time offset", "time_off" },
3390 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3391 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3392 "set the start time offset relative to EOF", "time_off" },
3393 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3394 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3395 "enable/disable seeking by timestamp with -ss" },
3396 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3397 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3398 "enable/disable accurate seeking with -ss" },
3399 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3400 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3401 "set the input ts offset", "time_off" },
3402 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3403 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3404 "set the input ts scale", "scale" },
3405 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3406 "set the recording timestamp ('now' to set the current time)", "time" },
3407 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3408 "add metadata", "string=string" },
3409 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3410 "add program with specified streams", "title=string:st=number..." },
3411 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3412 OPT_OUTPUT, { .func_arg = opt_data_frames },
3413 "set the number of data frames to output", "number" },
3414 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3415 "add timings for benchmarking" },
3416 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3417 "add timings for each task" },
3418 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3419 "write program-readable progress information", "url" },
3420 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3421 "enable or disable interaction on standard input" },
3422 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3423 "set max runtime in seconds", "limit" },
3424 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3425 "dump each input packet" },
3426 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3427 "when dumping packets, also dump the payload" },
3428 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3429 OPT_INPUT, { .off = OFFSET(rate_emu) },
3430 "read input at native frame rate", "" },
3431 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3432 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3433 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3434 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3435 "video sync method", "" },
3436 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3437 "frame drop threshold", "" },
3438 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3439 "audio sync method", "" },
3440 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3441 "audio drift threshold", "threshold" },
3442 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3443 "copy timestamps" },
3444 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3445 "shift input timestamps to start at 0 when using copyts" },
3446 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3447 "copy input stream time base when stream copying", "mode" },
3448 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3449 OPT_OUTPUT, { .off = OFFSET(shortest) },
3450 "finish encoding within shortest input" },
3451 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3452 OPT_OUTPUT, { .off = OFFSET(apad) },
3454 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3455 "timestamp discontinuity delta threshold", "threshold" },
3456 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3457 "timestamp error delta threshold", "threshold" },
3458 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3459 "exit on error", "error" },
3460 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3461 "abort on the specified condition flags", "flags" },
3462 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3463 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3464 "copy initial non-keyframes" },
3465 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3466 "copy or discard frames before start time" },
3467 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3468 "set the number of frames to output", "number" },
3469 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3470 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3471 "force codec tag/fourcc", "fourcc/tag" },
3472 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3473 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3474 "use fixed quality scale (VBR)", "q" },
3475 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3476 OPT_OUTPUT, { .func_arg = opt_qscale },
3477 "use fixed quality scale (VBR)", "q" },
3478 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3479 "set profile", "profile" },
3480 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3481 "set stream filtergraph", "filter_graph" },
3482 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3483 "number of non-complex filter threads" },
3484 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3485 "read stream filtergraph description from a file", "filename" },
3486 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3487 "reinit filtergraph on input parameter changes", "" },
3488 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3489 "create a complex filtergraph", "graph_description" },
3490 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3491 "number of threads for -filter_complex" },
3492 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3493 "create a complex filtergraph", "graph_description" },
3494 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3495 "read complex filtergraph description from a file", "filename" },
3496 { "stats", OPT_BOOL, { &print_stats },
3497 "print progress report during encoding", },
3498 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3499 OPT_OUTPUT, { .func_arg = opt_attach },
3500 "add an attachment to the output file", "filename" },
3501 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3502 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3503 "extract an attachment into a file", "filename" },
3504 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3505 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3506 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3507 "print timestamp debugging info" },
3508 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3509 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3510 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3511 OPT_INPUT, { .off = OFFSET(discard) },
3513 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3514 OPT_OUTPUT, { .off = OFFSET(disposition) },
3515 "disposition", "" },
3516 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3517 { .off = OFFSET(thread_queue_size) },
3518 "set the maximum number of queued packets from the demuxer" },
3521 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3522 "set the number of video frames to output", "number" },
3523 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3524 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3525 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3526 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3527 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3528 "set frame size (WxH or abbreviation)", "size" },
3529 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3530 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3531 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3532 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3533 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3534 "set pixel format", "format" },
3535 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3536 "set the number of bits per raw sample", "number" },
3537 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3538 "deprecated use -g 1" },
3539 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3541 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3542 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3543 "rate control override for specific intervals", "override" },
3544 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3545 OPT_OUTPUT, { .func_arg = opt_video_codec },
3546 "force video codec ('copy' to copy stream)", "codec" },
3547 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3549 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3551 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3552 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3553 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3554 "select the pass number (1 to 3)", "n" },
3555 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3556 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3557 "select two pass log file name prefix", "prefix" },
3558 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3559 "this option is deprecated, use the yadif filter instead" },
3560 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3561 "calculate PSNR of compressed frames" },
3562 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3563 "dump video coding statistics to file" },
3564 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3565 "dump video coding statistics to file", "file" },
3566 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3567 "Version of the vstats format to use."},
3568 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3569 "set video filters", "filter_graph" },
3570 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3571 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3572 "specify intra matrix coeffs", "matrix" },
3573 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3574 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3575 "specify inter matrix coeffs", "matrix" },
3576 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3577 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3578 "specify intra matrix coeffs", "matrix" },
3579 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3580 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3581 "top=1/bottom=0/auto=-1 field first", "" },
3582 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3583 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3584 "force video tag/fourcc", "fourcc/tag" },
3585 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3586 "show QP histogram" },
3587 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3588 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3589 "force the selected framerate, disable the best supported framerate selection" },
3590 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3591 OPT_OUTPUT, { .func_arg = opt_streamid },
3592 "set the value of an outfile streamid", "streamIndex:value" },
3593 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3594 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3595 "force key frames at specified timestamps", "timestamps" },
3596 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3597 "audio bitrate (please use -b:a)", "bitrate" },
3598 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3599 "video bitrate (please use -b:v)", "bitrate" },
3600 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3601 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3602 "use HW accelerated decoding", "hwaccel name" },
3603 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3604 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3605 "select a device for HW acceleration", "devicename" },
3606 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3607 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3608 "select output format used with HW accelerated decoding", "format" },
3609 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3610 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3612 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3613 "show available HW acceleration methods" },
3614 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3615 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3616 "automatically insert correct rotate filters" },
3617 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3618 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3621 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3622 "set the number of audio frames to output", "number" },
3623 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3624 "set audio quality (codec-specific)", "quality", },
3625 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3626 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3627 "set audio sampling rate (in Hz)", "rate" },
3628 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3629 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3630 "set number of audio channels", "channels" },
3631 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3633 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3634 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3635 "force audio codec ('copy' to copy stream)", "codec" },
3636 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3637 OPT_OUTPUT, { .func_arg = opt_old2new },
3638 "force audio tag/fourcc", "fourcc/tag" },
3639 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3640 "change audio volume (256=normal)" , "volume" },
3641 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3642 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3643 "set sample format", "format" },
3644 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3645 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3646 "set channel layout", "layout" },
3647 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3648 "set audio filters", "filter_graph" },
3649 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3650 "set the maximum number of channels to try to guess the channel layout" },
3652 /* subtitle options */
3653 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3654 "disable subtitle" },
3655 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3656 "force subtitle codec ('copy' to copy stream)", "codec" },
3657 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3658 , "force subtitle tag/fourcc", "fourcc/tag" },
3659 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3660 "fix subtitles duration" },
3661 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3662 "set canvas size (WxH or abbreviation)", "size" },
3665 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3666 "deprecated, use -channel", "channel" },
3667 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3668 "deprecated, use -standard", "standard" },
3669 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3672 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3673 "set the maximum demux-decode delay", "seconds" },
3674 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3675 "set the initial demux-decode delay", "seconds" },
3676 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3677 "override the options from ffserver", "" },
3678 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3679 "specify a file in which to print sdp information", "file" },
3681 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3682 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3683 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3684 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3685 "two special values are defined - "
3686 "0 = use frame rate (video) or sample rate (audio),"
3687 "-1 = match source time base", "ratio" },
3689 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3690 "A comma-separated list of bitstream filters", "bitstream_filters" },
3691 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3692 "deprecated", "audio bitstream_filters" },
3693 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3694 "deprecated", "video bitstream_filters" },
3696 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3697 "set the audio options to the indicated preset", "preset" },
3698 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3699 "set the video options to the indicated preset", "preset" },
3700 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3701 "set the subtitle options to the indicated preset", "preset" },
3702 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3703 "set options from indicated preset file", "filename" },
3705 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3706 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3708 /* data codec support */
3709 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3710 "force data codec ('copy' to copy stream)", "codec" },
3711 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3715 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3716 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3720 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3721 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3724 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3725 "initialise hardware device", "args" },
3726 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3727 "set hardware device used when filtering", "device" },