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 { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
75 AV_HWDEVICE_TYPE_D3D11VA },
78 { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
79 AV_HWDEVICE_TYPE_DXVA2 },
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 { "nvdec", hwaccel_decode_init, HWACCEL_NVDEC, AV_PIX_FMT_CUDA,
95 AV_HWDEVICE_TYPE_CUDA },
98 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
99 AV_HWDEVICE_TYPE_NONE },
103 AVBufferRef *hw_device_ctx;
104 HWDevice *filter_hw_device;
106 char *vstats_filename;
109 float audio_drift_threshold = 0.1;
110 float dts_delta_threshold = 10;
111 float dts_error_threshold = 3600*30;
113 int audio_volume = 256;
114 int audio_sync_method = 0;
115 int video_sync_method = VSYNC_AUTO;
116 float frame_drop_threshold = 0;
117 int do_deinterlace = 0;
118 int do_benchmark = 0;
119 int do_benchmark_all = 0;
123 int start_at_zero = 0;
126 int exit_on_error = 0;
127 int abort_on_flags = 0;
128 int print_stats = -1;
130 int stdin_interaction = 1;
131 int frame_bits_per_raw_sample = 0;
132 float max_error_rate = 2.0/3;
133 int filter_nbthreads = 0;
134 int filter_complex_nbthreads = 0;
135 int vstats_version = 2;
138 static int intra_only = 0;
139 static int file_overwrite = 0;
140 static int no_file_overwrite = 0;
141 static int do_psnr = 0;
142 static int input_sync;
143 static int override_ffserver = 0;
144 static int input_stream_potentially_available = 0;
145 static int ignore_unknown_streams = 0;
146 static int copy_unknown_streams = 0;
147 static int find_stream_info = 1;
149 static void uninit_options(OptionsContext *o)
151 const OptionDef *po = options;
154 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
156 void *dst = (uint8_t*)o + po->u.off;
158 if (po->flags & OPT_SPEC) {
159 SpecifierOpt **so = dst;
160 int i, *count = (int*)(so + 1);
161 for (i = 0; i < *count; i++) {
162 av_freep(&(*so)[i].specifier);
163 if (po->flags & OPT_STRING)
164 av_freep(&(*so)[i].u.str);
168 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
173 for (i = 0; i < o->nb_stream_maps; i++)
174 av_freep(&o->stream_maps[i].linklabel);
175 av_freep(&o->stream_maps);
176 av_freep(&o->audio_channel_maps);
177 av_freep(&o->streamid_map);
178 av_freep(&o->attachments);
181 static void init_options(OptionsContext *o)
183 memset(o, 0, sizeof(*o));
185 o->stop_time = INT64_MAX;
186 o->mux_max_delay = 0.7;
187 o->start_time = AV_NOPTS_VALUE;
188 o->start_time_eof = AV_NOPTS_VALUE;
189 o->recording_time = INT64_MAX;
190 o->limit_filesize = UINT64_MAX;
191 o->chapters_input_file = INT_MAX;
192 o->accurate_seek = 1;
195 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
199 printf("Hardware acceleration methods:\n");
200 for (i = 0; hwaccels[i].name; i++) {
201 printf("%s\n", hwaccels[i].name);
207 /* return a copy of the input with the stream specifiers removed from the keys */
208 static AVDictionary *strip_specifiers(AVDictionary *dict)
210 AVDictionaryEntry *e = NULL;
211 AVDictionary *ret = NULL;
213 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
214 char *p = strchr(e->key, ':');
218 av_dict_set(&ret, e->key, e->value, 0);
225 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
227 static const AVOption opts[] = {
228 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
229 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
232 static const AVClass class = {
234 .item_name = av_default_item_name,
236 .version = LIBAVUTIL_VERSION_INT,
238 const AVClass *pclass = &class;
240 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
243 static int opt_sameq(void *optctx, const char *opt, const char *arg)
245 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
246 "If you are looking for an option to preserve the quality (which is not "
247 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
249 return AVERROR(EINVAL);
252 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
254 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
255 return opt_default(optctx, "channel", arg);
258 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
260 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
261 return opt_default(optctx, "standard", arg);
264 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
266 OptionsContext *o = optctx;
267 return parse_option(o, "codec:a", arg, options);
270 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
272 OptionsContext *o = optctx;
273 return parse_option(o, "codec:v", arg, options);
276 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
278 OptionsContext *o = optctx;
279 return parse_option(o, "codec:s", arg, options);
282 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
284 OptionsContext *o = optctx;
285 return parse_option(o, "codec:d", arg, options);
288 static int opt_map(void *optctx, const char *opt, const char *arg)
290 OptionsContext *o = optctx;
292 int i, negative = 0, file_idx;
293 int sync_file_idx = -1, sync_stream_idx = 0;
302 map = av_strdup(arg);
304 return AVERROR(ENOMEM);
306 /* parse sync stream first, just pick first matching stream */
307 if (sync = strchr(map, ',')) {
309 sync_file_idx = strtol(sync + 1, &sync, 0);
310 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
311 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
316 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
317 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
318 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
322 if (i == input_files[sync_file_idx]->nb_streams) {
323 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
324 "match any streams.\n", arg);
331 /* this mapping refers to lavfi output */
332 const char *c = map + 1;
333 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
334 m = &o->stream_maps[o->nb_stream_maps - 1];
335 m->linklabel = av_get_token(&c, "]");
337 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
341 if (allow_unused = strchr(map, '?'))
343 file_idx = strtol(map, &p, 0);
344 if (file_idx >= nb_input_files || file_idx < 0) {
345 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
349 /* disable some already defined maps */
350 for (i = 0; i < o->nb_stream_maps; i++) {
351 m = &o->stream_maps[i];
352 if (file_idx == m->file_index &&
353 check_stream_specifier(input_files[m->file_index]->ctx,
354 input_files[m->file_index]->ctx->streams[m->stream_index],
355 *p == ':' ? p + 1 : p) > 0)
359 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
360 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
361 *p == ':' ? p + 1 : p) <= 0)
363 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
364 m = &o->stream_maps[o->nb_stream_maps - 1];
366 m->file_index = file_idx;
369 if (sync_file_idx >= 0) {
370 m->sync_file_index = sync_file_idx;
371 m->sync_stream_index = sync_stream_idx;
373 m->sync_file_index = file_idx;
374 m->sync_stream_index = i;
381 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
383 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
384 "To ignore this, add a trailing '?' to the map.\n", arg);
393 static int opt_attach(void *optctx, const char *opt, const char *arg)
395 OptionsContext *o = optctx;
396 GROW_ARRAY(o->attachments, o->nb_attachments);
397 o->attachments[o->nb_attachments - 1] = arg;
401 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
403 OptionsContext *o = optctx;
409 mapchan = av_strdup(arg);
411 return AVERROR(ENOMEM);
413 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
414 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
416 /* muted channel syntax */
417 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
418 if ((n == 1 || n == 3) && m->channel_idx == -1) {
419 m->file_idx = m->stream_idx = -1;
421 m->ofile_idx = m->ostream_idx = -1;
427 n = sscanf(arg, "%d.%d.%d:%d.%d",
428 &m->file_idx, &m->stream_idx, &m->channel_idx,
429 &m->ofile_idx, &m->ostream_idx);
431 if (n != 3 && n != 5) {
432 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
433 "[file.stream.channel|-1][:syncfile:syncstream]\n");
437 if (n != 5) // only file.stream.channel specified
438 m->ofile_idx = m->ostream_idx = -1;
441 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
442 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
446 if (m->stream_idx < 0 ||
447 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
448 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
449 m->file_idx, m->stream_idx);
452 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
453 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
454 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
455 m->file_idx, m->stream_idx);
458 /* allow trailing ? to map_channel */
459 if (allow_unused = strchr(mapchan, '?'))
461 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
463 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
464 m->file_idx, m->stream_idx, m->channel_idx);
466 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
467 "To ignore this, add a trailing '?' to the map_channel.\n",
468 m->file_idx, m->stream_idx, m->channel_idx);
477 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
479 av_free(sdp_filename);
480 sdp_filename = av_strdup(arg);
485 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
488 const char *prefix = "vaapi:";
491 tmp = av_asprintf("%s%s", prefix, arg);
493 return AVERROR(ENOMEM);
494 err = hw_device_init_from_string(tmp, &dev);
498 hw_device_ctx = av_buffer_ref(dev->device_ref);
500 return AVERROR(ENOMEM);
505 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
507 if (!strcmp(arg, "list")) {
508 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
509 printf("Supported hardware device types:\n");
510 while ((type = av_hwdevice_iterate_types(type)) !=
511 AV_HWDEVICE_TYPE_NONE)
512 printf("%s\n", av_hwdevice_get_type_name(type));
516 return hw_device_init_from_string(arg, NULL);
520 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
522 if (filter_hw_device) {
523 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
524 return AVERROR(EINVAL);
526 filter_hw_device = hw_device_get_by_name(arg);
527 if (!filter_hw_device) {
528 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
529 return AVERROR(EINVAL);
535 * Parse a metadata specifier passed as 'arg' parameter.
536 * @param arg metadata string to parse
537 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
538 * @param index for type c/p, chapter/program index is written here
539 * @param stream_spec for type s, the stream specifier is written here
541 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
549 if (*(++arg) && *arg != ':') {
550 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
553 *stream_spec = *arg == ':' ? arg + 1 : "";
558 *index = strtol(++arg, NULL, 0);
561 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
568 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
570 AVDictionary **meta_in = NULL;
571 AVDictionary **meta_out = NULL;
573 char type_in, type_out;
574 const char *istream_spec = NULL, *ostream_spec = NULL;
575 int idx_in = 0, idx_out = 0;
577 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
578 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
581 if (type_out == 'g' || !*outspec)
582 o->metadata_global_manual = 1;
583 if (type_out == 's' || !*outspec)
584 o->metadata_streams_manual = 1;
585 if (type_out == 'c' || !*outspec)
586 o->metadata_chapters_manual = 1;
590 if (type_in == 'g' || type_out == 'g')
591 o->metadata_global_manual = 1;
592 if (type_in == 's' || type_out == 's')
593 o->metadata_streams_manual = 1;
594 if (type_in == 'c' || type_out == 'c')
595 o->metadata_chapters_manual = 1;
597 /* ic is NULL when just disabling automatic mappings */
601 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
602 if ((index) < 0 || (index) >= (nb_elems)) {\
603 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
608 #define SET_DICT(type, meta, context, index)\
611 meta = &context->metadata;\
614 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
615 meta = &context->chapters[index]->metadata;\
618 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
619 meta = &context->programs[index]->metadata;\
622 break; /* handled separately below */ \
623 default: av_assert0(0);\
626 SET_DICT(type_in, meta_in, ic, idx_in);
627 SET_DICT(type_out, meta_out, oc, idx_out);
629 /* for input streams choose first matching stream */
630 if (type_in == 's') {
631 for (i = 0; i < ic->nb_streams; i++) {
632 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
633 meta_in = &ic->streams[i]->metadata;
639 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
644 if (type_out == 's') {
645 for (i = 0; i < oc->nb_streams; i++) {
646 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
647 meta_out = &oc->streams[i]->metadata;
648 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
653 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
658 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
660 OptionsContext *o = optctx;
662 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
663 struct tm time = *gmtime((time_t*)&recording_timestamp);
664 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
666 parse_option(o, "metadata", buf, options);
668 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
669 "tag instead.\n", opt);
673 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
675 const AVCodecDescriptor *desc;
676 const char *codec_string = encoder ? "encoder" : "decoder";
680 avcodec_find_encoder_by_name(name) :
681 avcodec_find_decoder_by_name(name);
683 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
684 codec = encoder ? avcodec_find_encoder(desc->id) :
685 avcodec_find_decoder(desc->id);
687 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
688 codec_string, codec->name, desc->name);
692 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
695 if (codec->type != type) {
696 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
702 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
704 char *codec_name = NULL;
706 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
708 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
709 st->codecpar->codec_id = codec->id;
712 return avcodec_find_decoder(st->codecpar->codec_id);
715 /* Add all the streams from the given input file to the global
716 * list of input streams. */
717 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
721 for (i = 0; i < ic->nb_streams; i++) {
722 AVStream *st = ic->streams[i];
723 AVCodecParameters *par = st->codecpar;
724 InputStream *ist = av_mallocz(sizeof(*ist));
725 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
726 char *hwaccel_output_format = NULL;
727 char *codec_tag = NULL;
729 char *discard_str = NULL;
730 const AVClass *cc = avcodec_get_class();
731 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
736 GROW_ARRAY(input_streams, nb_input_streams);
737 input_streams[nb_input_streams - 1] = ist;
740 ist->file_index = nb_input_files;
742 st->discard = AVDISCARD_ALL;
744 ist->min_pts = INT64_MAX;
745 ist->max_pts = INT64_MIN;
748 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
751 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
753 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
755 uint32_t tag = strtol(codec_tag, &next, 0);
757 tag = AV_RL32(codec_tag);
758 st->codecpar->codec_tag = tag;
761 ist->dec = choose_decoder(o, ic, st);
762 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
764 ist->reinit_filters = -1;
765 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
767 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
768 ist->user_set_discard = AVDISCARD_NONE;
769 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
770 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
775 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
777 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
779 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
783 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
785 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
790 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
792 switch (par->codec_type) {
793 case AVMEDIA_TYPE_VIDEO:
795 ist->dec = avcodec_find_decoder(par->codec_id);
797 if (av_codec_get_lowres(st->codec)) {
798 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
799 ist->dec_ctx->width = st->codec->width;
800 ist->dec_ctx->height = st->codec->height;
801 ist->dec_ctx->coded_width = st->codec->coded_width;
802 ist->dec_ctx->coded_height = st->codec->coded_height;
806 // avformat_find_stream_info() doesn't set this for us anymore.
807 ist->dec_ctx->framerate = st->avg_frame_rate;
809 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
810 if (framerate && av_parse_video_rate(&ist->framerate,
812 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
817 ist->top_field_first = -1;
818 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
820 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
822 if (!strcmp(hwaccel, "none"))
823 ist->hwaccel_id = HWACCEL_NONE;
824 else if (!strcmp(hwaccel, "auto"))
825 ist->hwaccel_id = HWACCEL_AUTO;
828 for (i = 0; hwaccels[i].name; i++) {
829 if (!strcmp(hwaccels[i].name, hwaccel)) {
830 ist->hwaccel_id = hwaccels[i].id;
835 if (!ist->hwaccel_id) {
836 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
838 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
839 for (i = 0; hwaccels[i].name; i++)
840 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
841 av_log(NULL, AV_LOG_FATAL, "\n");
847 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
848 if (hwaccel_device) {
849 ist->hwaccel_device = av_strdup(hwaccel_device);
850 if (!ist->hwaccel_device)
854 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
855 hwaccel_output_format, ic, st);
856 if (hwaccel_output_format) {
857 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
858 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
859 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
860 "format: %s", hwaccel_output_format);
863 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
866 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
869 case AVMEDIA_TYPE_AUDIO:
870 ist->guess_layout_max = INT_MAX;
871 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
872 guess_input_channel_layout(ist);
874 case AVMEDIA_TYPE_DATA:
875 case AVMEDIA_TYPE_SUBTITLE: {
876 char *canvas_size = NULL;
878 ist->dec = avcodec_find_decoder(par->codec_id);
879 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
880 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
882 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
883 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
888 case AVMEDIA_TYPE_ATTACHMENT:
889 case AVMEDIA_TYPE_UNKNOWN:
895 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
897 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
903 static void assert_file_overwrite(const char *filename)
905 if (file_overwrite && no_file_overwrite) {
906 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
910 if (!file_overwrite) {
911 const char *proto_name = avio_find_protocol_name(filename);
912 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
913 if (stdin_interaction && !no_file_overwrite) {
914 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
917 signal(SIGINT, SIG_DFL);
919 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
925 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
932 static void dump_attachment(AVStream *st, const char *filename)
935 AVIOContext *out = NULL;
936 AVDictionaryEntry *e;
938 if (!st->codecpar->extradata_size) {
939 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
940 nb_input_files - 1, st->index);
943 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
946 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
947 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
951 assert_file_overwrite(filename);
953 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
954 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
959 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
964 static int open_input_file(OptionsContext *o, const char *filename)
968 AVInputFormat *file_iformat = NULL;
971 AVDictionary *unused_opts = NULL;
972 AVDictionaryEntry *e = NULL;
973 char * video_codec_name = NULL;
974 char * audio_codec_name = NULL;
975 char *subtitle_codec_name = NULL;
976 char * data_codec_name = NULL;
977 int scan_all_pmts_set = 0;
980 if (!(file_iformat = av_find_input_format(o->format))) {
981 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
986 if (!strcmp(filename, "-"))
989 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
990 strcmp(filename, "/dev/stdin");
992 /* get default parameters from command line */
993 ic = avformat_alloc_context();
995 print_error(filename, AVERROR(ENOMEM));
998 if (o->nb_audio_sample_rate) {
999 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1001 if (o->nb_audio_channels) {
1002 /* because we set audio_channels based on both the "ac" and
1003 * "channel_layout" options, we need to check that the specified
1004 * demuxer actually has the "channels" option before setting it */
1005 if (file_iformat && file_iformat->priv_class &&
1006 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1007 AV_OPT_SEARCH_FAKE_OBJ)) {
1008 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1011 if (o->nb_frame_rates) {
1012 /* set the format-level framerate option;
1013 * this is important for video grabbers, e.g. x11 */
1014 if (file_iformat && file_iformat->priv_class &&
1015 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1016 AV_OPT_SEARCH_FAKE_OBJ)) {
1017 av_dict_set(&o->g->format_opts, "framerate",
1018 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1021 if (o->nb_frame_sizes) {
1022 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1024 if (o->nb_frame_pix_fmts)
1025 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1027 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1028 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1029 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1030 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1032 if (video_codec_name)
1033 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1034 if (audio_codec_name)
1035 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1036 if (subtitle_codec_name)
1037 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1038 if (data_codec_name)
1039 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1041 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1042 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1043 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1044 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1046 ic->flags |= AVFMT_FLAG_NONBLOCK;
1048 ic->flags |= AVFMT_FLAG_BITEXACT;
1049 ic->interrupt_callback = int_cb;
1051 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1052 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1053 scan_all_pmts_set = 1;
1055 /* open the input file with generic avformat function */
1056 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1058 print_error(filename, err);
1059 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1060 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1063 if (scan_all_pmts_set)
1064 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1065 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1066 assert_avoptions(o->g->format_opts);
1068 /* apply forced codec ids */
1069 for (i = 0; i < ic->nb_streams; i++)
1070 choose_decoder(o, ic, ic->streams[i]);
1072 if (find_stream_info) {
1073 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1074 int orig_nb_streams = ic->nb_streams;
1076 /* If not enough info to get the stream parameters, we decode the
1077 first frames to get it. (used in mpeg case for example) */
1078 ret = avformat_find_stream_info(ic, opts);
1080 for (i = 0; i < orig_nb_streams; i++)
1081 av_dict_free(&opts[i]);
1085 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1086 if (ic->nb_streams == 0) {
1087 avformat_close_input(&ic);
1093 if (o->start_time_eof != AV_NOPTS_VALUE) {
1094 if (ic->duration>0) {
1095 o->start_time = o->start_time_eof + ic->duration;
1097 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1099 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1100 /* add the stream start time */
1101 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1102 timestamp += ic->start_time;
1104 /* if seeking requested, we execute it */
1105 if (o->start_time != AV_NOPTS_VALUE) {
1106 int64_t seek_timestamp = timestamp;
1108 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1109 int dts_heuristic = 0;
1110 for (i=0; i<ic->nb_streams; i++) {
1111 const AVCodecParameters *par = ic->streams[i]->codecpar;
1112 if (par->video_delay)
1115 if (dts_heuristic) {
1116 seek_timestamp -= 3*AV_TIME_BASE / 23;
1119 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1121 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1122 filename, (double)timestamp / AV_TIME_BASE);
1126 /* update the current parameters so that they match the one of the input stream */
1127 add_input_streams(o, ic);
1129 /* dump the file content */
1130 av_dump_format(ic, nb_input_files, filename, 0);
1132 GROW_ARRAY(input_files, nb_input_files);
1133 f = av_mallocz(sizeof(*f));
1136 input_files[nb_input_files - 1] = f;
1139 f->ist_index = nb_input_streams - ic->nb_streams;
1140 f->start_time = o->start_time;
1141 f->recording_time = o->recording_time;
1142 f->input_ts_offset = o->input_ts_offset;
1143 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1144 f->nb_streams = ic->nb_streams;
1145 f->rate_emu = o->rate_emu;
1146 f->accurate_seek = o->accurate_seek;
1149 f->time_base = (AVRational){ 1, 1 };
1151 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1154 /* check if all codec options have been used */
1155 unused_opts = strip_specifiers(o->g->codec_opts);
1156 for (i = f->ist_index; i < nb_input_streams; i++) {
1158 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1159 AV_DICT_IGNORE_SUFFIX)))
1160 av_dict_set(&unused_opts, e->key, NULL, 0);
1164 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1165 const AVClass *class = avcodec_get_class();
1166 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1167 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1168 const AVClass *fclass = avformat_get_class();
1169 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1170 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1171 if (!option || foption)
1175 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1176 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1177 "input file #%d (%s) is not a decoding option.\n", e->key,
1178 option->help ? option->help : "", nb_input_files - 1,
1183 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1184 "input file #%d (%s) has not been used for any stream. The most "
1185 "likely reason is either wrong type (e.g. a video option with "
1186 "no video streams) or that it is a private option of some decoder "
1187 "which was not actually used for any stream.\n", e->key,
1188 option->help ? option->help : "", nb_input_files - 1, filename);
1190 av_dict_free(&unused_opts);
1192 for (i = 0; i < o->nb_dump_attachment; i++) {
1195 for (j = 0; j < ic->nb_streams; j++) {
1196 AVStream *st = ic->streams[j];
1198 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1199 dump_attachment(st, o->dump_attachment[i].u.str);
1203 input_stream_potentially_available = 1;
1208 static uint8_t *get_line(AVIOContext *s)
1214 if (avio_open_dyn_buf(&line) < 0) {
1215 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1219 while ((c = avio_r8(s)) && c != '\n')
1222 avio_close_dyn_buf(line, &buf);
1227 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1230 char filename[1000];
1231 const char *base[3] = { getenv("AVCONV_DATADIR"),
1236 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1240 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1241 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1242 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1245 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1246 i != 1 ? "" : "/.avconv", preset_name);
1247 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1253 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1255 enum AVMediaType type = ost->st->codecpar->codec_type;
1256 char *codec_name = NULL;
1258 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1259 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1261 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1262 NULL, ost->st->codecpar->codec_type);
1263 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1265 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1266 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1267 "probably disabled. Please choose an encoder manually.\n",
1268 ost->file_index, ost->index, s->oformat->name,
1269 avcodec_get_name(ost->st->codecpar->codec_id));
1270 return AVERROR_ENCODER_NOT_FOUND;
1272 } else if (!strcmp(codec_name, "copy"))
1273 ost->stream_copy = 1;
1275 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1276 ost->st->codecpar->codec_id = ost->enc->id;
1278 ost->encoding_needed = !ost->stream_copy;
1280 /* no encoding supported for other media types */
1281 ost->stream_copy = 1;
1282 ost->encoding_needed = 0;
1288 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1291 AVStream *st = avformat_new_stream(oc, NULL);
1292 int idx = oc->nb_streams - 1, ret = 0;
1293 const char *bsfs = NULL, *time_base = NULL;
1294 char *next, *codec_tag = NULL;
1299 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1303 if (oc->nb_streams - 1 < o->nb_streamid_map)
1304 st->id = o->streamid_map[oc->nb_streams - 1];
1306 GROW_ARRAY(output_streams, nb_output_streams);
1307 if (!(ost = av_mallocz(sizeof(*ost))))
1309 output_streams[nb_output_streams - 1] = ost;
1311 ost->file_index = nb_output_files - 1;
1314 st->codecpar->codec_type = type;
1316 ret = choose_encoder(o, oc, ost);
1318 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1319 "%d:%d\n", ost->file_index, ost->index);
1323 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1324 if (!ost->enc_ctx) {
1325 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1328 ost->enc_ctx->codec_type = type;
1330 ost->ref_par = avcodec_parameters_alloc();
1331 if (!ost->ref_par) {
1332 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1337 AVIOContext *s = NULL;
1338 char *buf = NULL, *arg = NULL, *preset = NULL;
1340 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1342 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1343 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1346 if (!buf[0] || buf[0] == '#') {
1350 if (!(arg = strchr(buf, '='))) {
1351 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1355 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1357 } while (!s->eof_reached);
1361 av_log(NULL, AV_LOG_FATAL,
1362 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1363 preset, ost->file_index, ost->index);
1367 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1372 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1374 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1377 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1378 q.num <= 0 || q.den <= 0) {
1379 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1385 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1388 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1390 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1393 ost->enc_timebase = q;
1396 ost->max_frames = INT64_MAX;
1397 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1398 for (i = 0; i<o->nb_max_frames; i++) {
1399 char *p = o->max_frames[i].specifier;
1400 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1401 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1406 ost->copy_prior_start = -1;
1407 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1409 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1410 while (bsfs && *bsfs) {
1411 const AVBitStreamFilter *filter;
1412 char *bsf, *bsf_options_str, *bsf_name;
1414 bsf = av_get_token(&bsfs, ",");
1417 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1421 filter = av_bsf_get_by_name(bsf_name);
1423 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1427 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1428 ost->nb_bitstream_filters + 1,
1429 sizeof(*ost->bsf_ctx));
1433 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1435 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1439 ost->nb_bitstream_filters++;
1441 if (bsf_options_str && filter->priv_class) {
1442 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1443 const char * shorthand[2] = {NULL};
1446 shorthand[0] = opt->name;
1448 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1450 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1460 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1462 uint32_t tag = strtol(codec_tag, &next, 0);
1464 tag = AV_RL32(codec_tag);
1465 ost->st->codecpar->codec_tag =
1466 ost->enc_ctx->codec_tag = tag;
1469 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1471 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1472 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1475 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1476 ost->disposition = av_strdup(ost->disposition);
1478 ost->max_muxing_queue_size = 128;
1479 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1480 ost->max_muxing_queue_size *= sizeof(AVPacket);
1482 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1483 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1485 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1487 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1488 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1489 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1491 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1493 ost->source_index = source_index;
1494 if (source_index >= 0) {
1495 ost->sync_ist = input_streams[source_index];
1496 input_streams[source_index]->discard = 0;
1497 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1499 ost->last_mux_dts = AV_NOPTS_VALUE;
1501 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1502 if (!ost->muxing_queue)
1508 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1511 const char *p = str;
1518 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1525 /* read file contents into a string */
1526 static uint8_t *read_file(const char *filename)
1528 AVIOContext *pb = NULL;
1529 AVIOContext *dyn_buf = NULL;
1530 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1531 uint8_t buf[1024], *str;
1534 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1538 ret = avio_open_dyn_buf(&dyn_buf);
1543 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1544 avio_write(dyn_buf, buf, ret);
1545 avio_w8(dyn_buf, 0);
1548 ret = avio_close_dyn_buf(dyn_buf, &str);
1554 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1557 AVStream *st = ost->st;
1559 if (ost->filters_script && ost->filters) {
1560 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1561 "output stream #%d:%d.\n", nb_output_files, st->index);
1565 if (ost->filters_script)
1566 return read_file(ost->filters_script);
1567 else if (ost->filters)
1568 return av_strdup(ost->filters);
1570 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1574 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1575 const OutputStream *ost, enum AVMediaType type)
1577 if (ost->filters_script || ost->filters) {
1578 av_log(NULL, AV_LOG_ERROR,
1579 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1580 "Filtering and streamcopy cannot be used together.\n",
1581 ost->filters ? "Filtergraph" : "Filtergraph script",
1582 ost->filters ? ost->filters : ost->filters_script,
1583 av_get_media_type_string(type), ost->file_index, ost->index);
1588 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1592 AVCodecContext *video_enc;
1593 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1595 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1597 video_enc = ost->enc_ctx;
1599 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1600 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1601 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1604 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1605 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1607 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1608 if (frame_aspect_ratio) {
1610 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1611 q.num <= 0 || q.den <= 0) {
1612 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1615 ost->frame_aspect_ratio = q;
1618 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1619 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1621 if (!ost->stream_copy) {
1622 const char *p = NULL;
1623 char *frame_size = NULL;
1624 char *frame_pix_fmt = NULL;
1625 char *intra_matrix = NULL, *inter_matrix = NULL;
1626 char *chroma_intra_matrix = NULL;
1630 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1631 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1632 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1636 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1637 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1638 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1639 ost->keep_pix_fmt = 1;
1640 if (!*++frame_pix_fmt)
1641 frame_pix_fmt = NULL;
1643 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1644 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1647 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1650 video_enc->gop_size = 0;
1651 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1653 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1654 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1657 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1659 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1660 if (chroma_intra_matrix) {
1661 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1663 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1666 av_codec_set_chroma_intra_matrix(video_enc, p);
1667 parse_matrix_coeffs(p, chroma_intra_matrix);
1669 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1671 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1672 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1675 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1678 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1679 for (i = 0; p; i++) {
1681 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1683 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1686 video_enc->rc_override =
1687 av_realloc_array(video_enc->rc_override,
1688 i + 1, sizeof(RcOverride));
1689 if (!video_enc->rc_override) {
1690 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1693 video_enc->rc_override[i].start_frame = start;
1694 video_enc->rc_override[i].end_frame = end;
1696 video_enc->rc_override[i].qscale = q;
1697 video_enc->rc_override[i].quality_factor = 1.0;
1700 video_enc->rc_override[i].qscale = 0;
1701 video_enc->rc_override[i].quality_factor = -q/100.0;
1706 video_enc->rc_override_count = i;
1709 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1712 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1715 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1716 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1719 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1720 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1724 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1725 if (ost->logfile_prefix &&
1726 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1730 char logfilename[1024];
1733 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1734 ost->logfile_prefix ? ost->logfile_prefix :
1735 DEFAULT_PASS_LOGFILENAME_PREFIX,
1737 if (!strcmp(ost->enc->name, "libx264")) {
1738 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1740 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1741 char *logbuffer = read_file(logfilename);
1744 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1748 video_enc->stats_in = logbuffer;
1750 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1751 f = av_fopen_utf8(logfilename, "wb");
1753 av_log(NULL, AV_LOG_FATAL,
1754 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1755 logfilename, strerror(errno));
1763 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1764 if (ost->forced_keyframes)
1765 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1767 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1769 ost->top_field_first = -1;
1770 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1773 ost->avfilter = get_ost_filters(o, oc, ost);
1777 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1780 if (ost->stream_copy)
1781 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1786 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1791 AVCodecContext *audio_enc;
1793 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1796 audio_enc = ost->enc_ctx;
1797 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1799 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1800 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1802 if (!ost->stream_copy) {
1803 char *sample_fmt = NULL;
1805 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1807 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1809 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1810 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1814 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1816 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1817 ost->apad = av_strdup(ost->apad);
1819 ost->avfilter = get_ost_filters(o, oc, ost);
1823 /* check for channel mapping for this audio stream */
1824 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1825 AudioChannelMap *map = &o->audio_channel_maps[n];
1826 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1827 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1830 if (map->channel_idx == -1) {
1832 } else if (ost->source_index < 0) {
1833 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1834 ost->file_index, ost->st->index);
1837 ist = input_streams[ost->source_index];
1840 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1841 if (av_reallocp_array(&ost->audio_channels_map,
1842 ost->audio_channels_mapped + 1,
1843 sizeof(*ost->audio_channels_map)
1847 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1853 if (ost->stream_copy)
1854 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1859 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1863 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1864 if (!ost->stream_copy) {
1865 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1872 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1876 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1877 if (!ost->stream_copy) {
1878 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1885 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1887 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1888 ost->stream_copy = 1;
1893 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1897 AVCodecContext *subtitle_enc;
1899 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1901 subtitle_enc = ost->enc_ctx;
1903 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1905 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1907 if (!ost->stream_copy) {
1908 char *frame_size = NULL;
1910 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1911 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1912 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1920 /* arg format is "output-stream-index:streamid-value". */
1921 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1923 OptionsContext *o = optctx;
1928 av_strlcpy(idx_str, arg, sizeof(idx_str));
1929 p = strchr(idx_str, ':');
1931 av_log(NULL, AV_LOG_FATAL,
1932 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1937 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1938 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1939 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1943 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1945 AVFormatContext *is = ifile->ctx;
1946 AVFormatContext *os = ofile->ctx;
1950 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1952 return AVERROR(ENOMEM);
1955 for (i = 0; i < is->nb_chapters; i++) {
1956 AVChapter *in_ch = is->chapters[i], *out_ch;
1957 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1958 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1959 AV_TIME_BASE_Q, in_ch->time_base);
1960 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1961 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1964 if (in_ch->end < ts_off)
1966 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1969 out_ch = av_mallocz(sizeof(AVChapter));
1971 return AVERROR(ENOMEM);
1973 out_ch->id = in_ch->id;
1974 out_ch->time_base = in_ch->time_base;
1975 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1976 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1979 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1981 os->chapters[os->nb_chapters++] = out_ch;
1986 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1989 AVFormatContext *ic = avformat_alloc_context();
1991 ic->interrupt_callback = int_cb;
1992 err = avformat_open_input(&ic, filename, NULL, NULL);
1995 /* copy stream format */
1996 for(i=0;i<ic->nb_streams;i++) {
2000 const char *enc_config;
2002 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2004 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2005 return AVERROR(EINVAL);
2007 if (codec->type == AVMEDIA_TYPE_AUDIO)
2008 opt_audio_codec(o, "c:a", codec->name);
2009 else if (codec->type == AVMEDIA_TYPE_VIDEO)
2010 opt_video_codec(o, "c:v", codec->name);
2011 ost = new_output_stream(o, s, codec->type, -1);
2014 avcodec_get_context_defaults3(st->codec, codec);
2015 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
2017 AVDictionary *opts = NULL;
2018 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2019 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2020 av_dict_free(&opts);
2023 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2024 choose_sample_fmt(st, codec);
2025 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2026 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2027 avcodec_copy_context(ost->enc_ctx, st->codec);
2029 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2032 avformat_close_input(&ic);
2036 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2037 AVFormatContext *oc)
2041 switch (ofilter->type) {
2042 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2043 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2045 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2050 ost->source_index = -1;
2051 ost->filter = ofilter;
2054 ofilter->format = -1;
2056 if (ost->stream_copy) {
2057 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2058 "which is fed from a complex filtergraph. Filtering and streamcopy "
2059 "cannot be used together.\n", ost->file_index, ost->index);
2063 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2064 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2065 av_log(NULL, AV_LOG_ERROR,
2066 "%s '%s' was specified through the %s option "
2067 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2068 "%s and -filter_complex cannot be used together for the same stream.\n",
2069 ost->filters ? "Filtergraph" : "Filtergraph script",
2070 ost->filters ? ost->filters : ost->filters_script,
2071 opt, ost->file_index, ost->index, opt);
2075 avfilter_inout_free(&ofilter->out_tmp);
2078 static int init_complex_filters(void)
2082 for (i = 0; i < nb_filtergraphs; i++) {
2083 ret = init_complex_filtergraph(filtergraphs[i]);
2090 static int open_output_file(OptionsContext *o, const char *filename)
2092 AVFormatContext *oc;
2094 AVOutputFormat *file_oformat;
2098 AVDictionary *unused_opts = NULL;
2099 AVDictionaryEntry *e = NULL;
2100 int format_flags = 0;
2102 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2103 o->stop_time = INT64_MAX;
2104 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2107 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2108 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2109 if (o->stop_time <= start_time) {
2110 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2113 o->recording_time = o->stop_time - start_time;
2117 GROW_ARRAY(output_files, nb_output_files);
2118 of = av_mallocz(sizeof(*of));
2121 output_files[nb_output_files - 1] = of;
2123 of->ost_index = nb_output_streams;
2124 of->recording_time = o->recording_time;
2125 of->start_time = o->start_time;
2126 of->limit_filesize = o->limit_filesize;
2127 of->shortest = o->shortest;
2128 av_dict_copy(&of->opts, o->g->format_opts, 0);
2130 if (!strcmp(filename, "-"))
2133 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2135 print_error(filename, err);
2140 if (o->recording_time != INT64_MAX)
2141 oc->duration = o->recording_time;
2143 file_oformat= oc->oformat;
2144 oc->interrupt_callback = int_cb;
2146 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2148 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2149 av_opt_eval_flags(oc, o, e->value, &format_flags);
2152 format_flags |= AVFMT_FLAG_BITEXACT;
2153 oc->flags |= AVFMT_FLAG_BITEXACT;
2156 /* create streams for all unlabeled output pads */
2157 for (i = 0; i < nb_filtergraphs; i++) {
2158 FilterGraph *fg = filtergraphs[i];
2159 for (j = 0; j < fg->nb_outputs; j++) {
2160 OutputFilter *ofilter = fg->outputs[j];
2162 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2165 switch (ofilter->type) {
2166 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2167 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2168 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2170 init_output_filter(ofilter, o, oc);
2174 /* ffserver seeking with date=... needs a date reference */
2175 if (!strcmp(file_oformat->name, "ffm") &&
2176 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2177 av_strstart(filename, "http:", NULL)) {
2178 int err = parse_option(o, "metadata", "creation_time=now", options);
2180 print_error(filename, err);
2185 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2186 av_strstart(filename, "http:", NULL)) {
2188 /* special case for files sent to ffserver: we get the stream
2189 parameters from ffserver */
2190 int err = read_ffserver_streams(o, oc, filename);
2192 print_error(filename, err);
2195 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2196 ost = output_streams[j];
2197 for (i = 0; i < nb_input_streams; i++) {
2198 ist = input_streams[i];
2199 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2201 ost->source_index= i;
2202 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2203 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2205 ist->st->discard = ist->user_set_discard;
2210 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));
2214 } else if (!o->nb_stream_maps) {
2215 char *subtitle_codec_name = NULL;
2216 /* pick the "best" stream of each type */
2218 /* video: highest resolution */
2219 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2220 int area = 0, idx = -1;
2221 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2222 for (i = 0; i < nb_input_streams; i++) {
2224 ist = input_streams[i];
2225 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2226 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2228 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2230 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2237 new_video_stream(o, oc, idx);
2240 /* audio: most channels */
2241 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2242 int best_score = 0, idx = -1;
2243 for (i = 0; i < nb_input_streams; i++) {
2245 ist = input_streams[i];
2246 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2247 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2248 score > best_score) {
2254 new_audio_stream(o, oc, idx);
2257 /* subtitles: pick first */
2258 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2259 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2260 for (i = 0; i < nb_input_streams; i++)
2261 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2262 AVCodecDescriptor const *input_descriptor =
2263 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2264 AVCodecDescriptor const *output_descriptor = NULL;
2265 AVCodec const *output_codec =
2266 avcodec_find_encoder(oc->oformat->subtitle_codec);
2267 int input_props = 0, output_props = 0;
2269 output_descriptor = avcodec_descriptor_get(output_codec->id);
2270 if (input_descriptor)
2271 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2272 if (output_descriptor)
2273 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2274 if (subtitle_codec_name ||
2275 input_props & output_props ||
2276 // Map dvb teletext which has neither property to any output subtitle encoder
2277 input_descriptor && output_descriptor &&
2278 (!input_descriptor->props ||
2279 !output_descriptor->props)) {
2280 new_subtitle_stream(o, oc, i);
2285 /* Data only if codec id match */
2286 if (!o->data_disable ) {
2287 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2288 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2289 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2290 && input_streams[i]->st->codecpar->codec_id == codec_id )
2291 new_data_stream(o, oc, i);
2295 for (i = 0; i < o->nb_stream_maps; i++) {
2296 StreamMap *map = &o->stream_maps[i];
2301 if (map->linklabel) {
2303 OutputFilter *ofilter = NULL;
2306 for (j = 0; j < nb_filtergraphs; j++) {
2307 fg = filtergraphs[j];
2308 for (k = 0; k < fg->nb_outputs; k++) {
2309 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2310 if (out && !strcmp(out->name, map->linklabel)) {
2311 ofilter = fg->outputs[k];
2318 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2319 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2322 init_output_filter(ofilter, o, oc);
2324 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2326 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2327 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2329 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2331 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2333 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2337 switch (ist->st->codecpar->codec_type) {
2338 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2339 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2340 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2341 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2342 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2343 case AVMEDIA_TYPE_UNKNOWN:
2344 if (copy_unknown_streams) {
2345 ost = new_unknown_stream (o, oc, src_idx);
2349 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2350 "Cannot map stream #%d:%d - unsupported type.\n",
2351 map->file_index, map->stream_index);
2352 if (!ignore_unknown_streams) {
2353 av_log(NULL, AV_LOG_FATAL,
2354 "If you want unsupported types ignored instead "
2355 "of failing, please use the -ignore_unknown option\n"
2356 "If you want them copied, please use -copy_unknown\n");
2361 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2362 + map->sync_stream_index];
2367 /* handle attached files */
2368 for (i = 0; i < o->nb_attachments; i++) {
2370 uint8_t *attachment;
2374 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2375 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2379 if ((len = avio_size(pb)) <= 0) {
2380 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2384 if (!(attachment = av_malloc(len))) {
2385 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2389 avio_read(pb, attachment, len);
2391 ost = new_attachment_stream(o, oc, -1);
2392 ost->stream_copy = 0;
2393 ost->attachment_filename = o->attachments[i];
2394 ost->st->codecpar->extradata = attachment;
2395 ost->st->codecpar->extradata_size = len;
2397 p = strrchr(o->attachments[i], '/');
2398 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2402 #if FF_API_LAVF_AVCTX
2403 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2404 AVDictionaryEntry *e;
2405 ost = output_streams[i];
2407 if ((ost->stream_copy || ost->attachment_filename)
2408 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2409 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2410 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2415 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2416 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2417 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2421 /* check if all codec options have been used */
2422 unused_opts = strip_specifiers(o->g->codec_opts);
2423 for (i = of->ost_index; i < nb_output_streams; i++) {
2425 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2426 AV_DICT_IGNORE_SUFFIX)))
2427 av_dict_set(&unused_opts, e->key, NULL, 0);
2431 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2432 const AVClass *class = avcodec_get_class();
2433 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2434 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2435 const AVClass *fclass = avformat_get_class();
2436 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2437 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2438 if (!option || foption)
2442 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2443 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2444 "output file #%d (%s) is not an encoding option.\n", e->key,
2445 option->help ? option->help : "", nb_output_files - 1,
2450 // gop_timecode is injected by generic code but not always used
2451 if (!strcmp(e->key, "gop_timecode"))
2454 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2455 "output file #%d (%s) has not been used for any stream. The most "
2456 "likely reason is either wrong type (e.g. a video option with "
2457 "no video streams) or that it is a private option of some encoder "
2458 "which was not actually used for any stream.\n", e->key,
2459 option->help ? option->help : "", nb_output_files - 1, filename);
2461 av_dict_free(&unused_opts);
2463 /* set the decoding_needed flags and create simple filtergraphs */
2464 for (i = of->ost_index; i < nb_output_streams; i++) {
2465 OutputStream *ost = output_streams[i];
2467 if (ost->encoding_needed && ost->source_index >= 0) {
2468 InputStream *ist = input_streams[ost->source_index];
2469 ist->decoding_needed |= DECODING_FOR_OST;
2471 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2472 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2473 err = init_simple_filtergraph(ist, ost);
2475 av_log(NULL, AV_LOG_ERROR,
2476 "Error initializing a simple filtergraph between streams "
2477 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2478 nb_output_files - 1, ost->st->index);
2484 /* set the filter output constraints */
2486 OutputFilter *f = ost->filter;
2488 switch (ost->enc_ctx->codec_type) {
2489 case AVMEDIA_TYPE_VIDEO:
2490 f->frame_rate = ost->frame_rate;
2491 f->width = ost->enc_ctx->width;
2492 f->height = ost->enc_ctx->height;
2493 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2494 f->format = ost->enc_ctx->pix_fmt;
2495 } else if (ost->enc->pix_fmts) {
2497 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2499 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2502 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2505 case AVMEDIA_TYPE_AUDIO:
2506 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2507 f->format = ost->enc_ctx->sample_fmt;
2508 } else if (ost->enc->sample_fmts) {
2510 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2512 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2515 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2517 if (ost->enc_ctx->sample_rate) {
2518 f->sample_rate = ost->enc_ctx->sample_rate;
2519 } else if (ost->enc->supported_samplerates) {
2521 while (ost->enc->supported_samplerates[count])
2523 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2524 if (!f->sample_rates)
2526 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2527 (count + 1) * sizeof(*f->sample_rates));
2529 if (ost->enc_ctx->channels) {
2530 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2531 } else if (ost->enc->channel_layouts) {
2533 while (ost->enc->channel_layouts[count])
2535 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2536 if (!f->channel_layouts)
2538 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2539 (count + 1) * sizeof(*f->channel_layouts));
2546 /* check filename in case of an image number is expected */
2547 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2548 if (!av_filename_number_test(oc->filename)) {
2549 print_error(oc->filename, AVERROR(EINVAL));
2554 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2555 av_log(NULL, AV_LOG_ERROR,
2556 "No input streams but output needs an input stream\n");
2560 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2561 /* test if it already exists to avoid losing precious files */
2562 assert_file_overwrite(filename);
2565 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2566 &oc->interrupt_callback,
2568 print_error(filename, err);
2571 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2572 assert_file_overwrite(filename);
2574 if (o->mux_preload) {
2575 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2577 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2580 for (i = 0; i < o->nb_metadata_map; i++) {
2582 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2584 if (in_file_index >= nb_input_files) {
2585 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2588 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2589 in_file_index >= 0 ?
2590 input_files[in_file_index]->ctx : NULL, o);
2594 if (o->chapters_input_file >= nb_input_files) {
2595 if (o->chapters_input_file == INT_MAX) {
2596 /* copy chapters from the first input file that has them*/
2597 o->chapters_input_file = -1;
2598 for (i = 0; i < nb_input_files; i++)
2599 if (input_files[i]->ctx->nb_chapters) {
2600 o->chapters_input_file = i;
2604 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2605 o->chapters_input_file);
2609 if (o->chapters_input_file >= 0)
2610 copy_chapters(input_files[o->chapters_input_file], of,
2611 !o->metadata_chapters_manual);
2613 /* copy global metadata by default */
2614 if (!o->metadata_global_manual && nb_input_files){
2615 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2616 AV_DICT_DONT_OVERWRITE);
2617 if(o->recording_time != INT64_MAX)
2618 av_dict_set(&oc->metadata, "duration", NULL, 0);
2619 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2621 if (!o->metadata_streams_manual)
2622 for (i = of->ost_index; i < nb_output_streams; i++) {
2624 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2626 ist = input_streams[output_streams[i]->source_index];
2627 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2628 if (!output_streams[i]->stream_copy) {
2629 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2633 /* process manually set programs */
2634 for (i = 0; i < o->nb_program; i++) {
2635 const char *p = o->program[i].u.str;
2640 const char *p2 = av_get_token(&p, ":");
2641 const char *to_dealloc = p2;
2648 key = av_get_token(&p2, "=");
2650 av_freep(&to_dealloc);
2656 if (!strcmp(key, "program_num"))
2657 progid = strtol(p2, NULL, 0);
2658 av_freep(&to_dealloc);
2662 program = av_new_program(oc, progid);
2664 p = o->program[i].u.str;
2666 const char *p2 = av_get_token(&p, ":");
2667 const char *to_dealloc = p2;
2673 key = av_get_token(&p2, "=");
2675 av_log(NULL, AV_LOG_FATAL,
2676 "No '=' character in program string %s.\n",
2684 if (!strcmp(key, "title")) {
2685 av_dict_set(&program->metadata, "title", p2, 0);
2686 } else if (!strcmp(key, "program_num")) {
2687 } else if (!strcmp(key, "st")) {
2688 int st_num = strtol(p2, NULL, 0);
2689 av_program_add_stream_index(oc, progid, st_num);
2691 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2694 av_freep(&to_dealloc);
2699 /* process manually set metadata */
2700 for (i = 0; i < o->nb_metadata; i++) {
2703 const char *stream_spec;
2704 int index = 0, j, ret = 0;
2706 val = strchr(o->metadata[i].u.str, '=');
2708 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2709 o->metadata[i].u.str);
2714 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2716 for (j = 0; j < oc->nb_streams; j++) {
2717 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2718 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2719 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2721 double theta = av_strtod(val, &tail);
2723 ost->rotate_overridden = 1;
2724 ost->rotate_override_value = theta;
2727 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2739 if (index < 0 || index >= oc->nb_chapters) {
2740 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2743 m = &oc->chapters[index]->metadata;
2746 if (index < 0 || index >= oc->nb_programs) {
2747 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2750 m = &oc->programs[index]->metadata;
2753 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2756 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2763 static int opt_target(void *optctx, const char *opt, const char *arg)
2765 OptionsContext *o = optctx;
2766 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2767 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2769 if (!strncmp(arg, "pal-", 4)) {
2772 } else if (!strncmp(arg, "ntsc-", 5)) {
2775 } else if (!strncmp(arg, "film-", 5)) {
2779 /* Try to determine PAL/NTSC by peeking in the input files */
2780 if (nb_input_files) {
2782 for (j = 0; j < nb_input_files; j++) {
2783 for (i = 0; i < input_files[j]->nb_streams; i++) {
2784 AVStream *st = input_files[j]->ctx->streams[i];
2785 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2787 fr = st->time_base.den * 1000 / st->time_base.num;
2791 } else if ((fr == 29970) || (fr == 23976)) {
2796 if (norm != UNKNOWN)
2800 if (norm != UNKNOWN)
2801 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2804 if (norm == UNKNOWN) {
2805 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2806 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2807 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2811 if (!strcmp(arg, "vcd")) {
2812 opt_video_codec(o, "c:v", "mpeg1video");
2813 opt_audio_codec(o, "c:a", "mp2");
2814 parse_option(o, "f", "vcd", options);
2816 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2817 parse_option(o, "r", frame_rates[norm], options);
2818 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2820 opt_default(NULL, "b:v", "1150000");
2821 opt_default(NULL, "maxrate:v", "1150000");
2822 opt_default(NULL, "minrate:v", "1150000");
2823 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2825 opt_default(NULL, "b:a", "224000");
2826 parse_option(o, "ar", "44100", options);
2827 parse_option(o, "ac", "2", options);
2829 opt_default(NULL, "packetsize", "2324");
2830 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2832 /* We have to offset the PTS, so that it is consistent with the SCR.
2833 SCR starts at 36000, but the first two packs contain only padding
2834 and the first pack from the other stream, respectively, may also have
2835 been written before.
2836 So the real data starts at SCR 36000+3*1200. */
2837 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2838 } else if (!strcmp(arg, "svcd")) {
2840 opt_video_codec(o, "c:v", "mpeg2video");
2841 opt_audio_codec(o, "c:a", "mp2");
2842 parse_option(o, "f", "svcd", options);
2844 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2845 parse_option(o, "r", frame_rates[norm], options);
2846 parse_option(o, "pix_fmt", "yuv420p", options);
2847 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2849 opt_default(NULL, "b:v", "2040000");
2850 opt_default(NULL, "maxrate:v", "2516000");
2851 opt_default(NULL, "minrate:v", "0"); // 1145000;
2852 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2853 opt_default(NULL, "scan_offset", "1");
2855 opt_default(NULL, "b:a", "224000");
2856 parse_option(o, "ar", "44100", options);
2858 opt_default(NULL, "packetsize", "2324");
2860 } else if (!strcmp(arg, "dvd")) {
2862 opt_video_codec(o, "c:v", "mpeg2video");
2863 opt_audio_codec(o, "c:a", "ac3");
2864 parse_option(o, "f", "dvd", options);
2866 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2867 parse_option(o, "r", frame_rates[norm], options);
2868 parse_option(o, "pix_fmt", "yuv420p", options);
2869 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2871 opt_default(NULL, "b:v", "6000000");
2872 opt_default(NULL, "maxrate:v", "9000000");
2873 opt_default(NULL, "minrate:v", "0"); // 1500000;
2874 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2876 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2877 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2879 opt_default(NULL, "b:a", "448000");
2880 parse_option(o, "ar", "48000", options);
2882 } else if (!strncmp(arg, "dv", 2)) {
2884 parse_option(o, "f", "dv", options);
2886 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2887 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2888 norm == PAL ? "yuv420p" : "yuv411p", options);
2889 parse_option(o, "r", frame_rates[norm], options);
2891 parse_option(o, "ar", "48000", options);
2892 parse_option(o, "ac", "2", options);
2895 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2896 return AVERROR(EINVAL);
2899 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2900 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2905 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2907 av_free (vstats_filename);
2908 vstats_filename = av_strdup (arg);
2912 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2915 time_t today2 = time(NULL);
2916 struct tm *today = localtime(&today2);
2918 if (!today) { // maybe tomorrow
2919 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2923 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2925 return opt_vstats_file(NULL, opt, filename);
2928 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2930 OptionsContext *o = optctx;
2931 return parse_option(o, "frames:v", arg, options);
2934 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2936 OptionsContext *o = optctx;
2937 return parse_option(o, "frames:a", arg, options);
2940 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2942 OptionsContext *o = optctx;
2943 return parse_option(o, "frames:d", arg, options);
2946 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2949 AVDictionary *cbak = codec_opts;
2950 AVDictionary *fbak = format_opts;
2954 ret = opt_default(NULL, opt, arg);
2956 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2957 av_dict_copy(&o->g->format_opts, format_opts, 0);
2958 av_dict_free(&codec_opts);
2959 av_dict_free(&format_opts);
2966 static int opt_preset(void *optctx, const char *opt, const char *arg)
2968 OptionsContext *o = optctx;
2970 char filename[1000], line[1000], tmp_line[1000];
2971 const char *codec_name = NULL;
2975 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2977 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2978 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2979 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2981 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2985 while (fgets(line, sizeof(line), f)) {
2986 char *key = tmp_line, *value, *endptr;
2988 if (strcspn(line, "#\n\r") == 0)
2990 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2991 if (!av_strtok(key, "=", &value) ||
2992 !av_strtok(value, "\r\n", &endptr)) {
2993 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2996 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2998 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2999 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3000 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3001 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3002 else if (opt_default_new(o, key, value) < 0) {
3003 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3004 filename, line, key, value);
3014 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3016 OptionsContext *o = optctx;
3017 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3018 int ret = parse_option(o, s, arg, options);
3023 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3025 OptionsContext *o = optctx;
3027 if(!strcmp(opt, "ab")){
3028 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3030 } else if(!strcmp(opt, "b")){
3031 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3032 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3035 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3039 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3041 OptionsContext *o = optctx;
3044 if(!strcmp(opt, "qscale")){
3045 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3046 return parse_option(o, "q:v", arg, options);
3048 s = av_asprintf("q%s", opt + 6);
3049 ret = parse_option(o, s, arg, options);
3054 static int opt_profile(void *optctx, const char *opt, const char *arg)
3056 OptionsContext *o = optctx;
3057 if(!strcmp(opt, "profile")){
3058 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3059 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3062 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3066 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3068 OptionsContext *o = optctx;
3069 return parse_option(o, "filter:v", arg, options);
3072 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3074 OptionsContext *o = optctx;
3075 return parse_option(o, "filter:a", arg, options);
3078 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3080 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3081 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3082 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3083 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3085 if (video_sync_method == VSYNC_AUTO)
3086 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3090 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3092 OptionsContext *o = optctx;
3093 char *tcr = av_asprintf("timecode=%s", arg);
3094 int ret = parse_option(o, "metadata:g", tcr, options);
3096 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3101 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3103 OptionsContext *o = optctx;
3104 char layout_str[32];
3107 int ret, channels, ac_str_size;
3110 layout = av_get_channel_layout(arg);
3112 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3113 return AVERROR(EINVAL);
3115 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3116 ret = opt_default_new(o, opt, layout_str);
3120 /* set 'ac' option based on channel layout */
3121 channels = av_get_channel_layout_nb_channels(layout);
3122 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3123 stream_str = strchr(opt, ':');
3124 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3125 ac_str = av_mallocz(ac_str_size);
3127 return AVERROR(ENOMEM);
3128 av_strlcpy(ac_str, "ac", 3);
3130 av_strlcat(ac_str, stream_str, ac_str_size);
3131 ret = parse_option(o, ac_str, layout_str, options);
3137 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3139 OptionsContext *o = optctx;
3140 return parse_option(o, "q:a", arg, options);
3143 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3145 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3146 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3147 return AVERROR(ENOMEM);
3148 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3149 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3150 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3151 return AVERROR(ENOMEM);
3153 input_stream_potentially_available = 1;
3158 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3160 uint8_t *graph_desc = read_file(arg);
3162 return AVERROR(EINVAL);
3164 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3165 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3166 return AVERROR(ENOMEM);
3167 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3168 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3170 input_stream_potentially_available = 1;
3175 void show_help_default(const char *opt, const char *arg)
3177 /* per-file options have at least one of those set */
3178 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3179 int show_advanced = 0, show_avoptions = 0;
3182 if (!strcmp(opt, "long"))
3184 else if (!strcmp(opt, "full"))
3185 show_advanced = show_avoptions = 1;
3187 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3192 printf("Getting help:\n"
3193 " -h -- print basic options\n"
3194 " -h long -- print more options\n"
3195 " -h full -- print all options (including all format and codec specific options, very long)\n"
3196 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3197 " See man %s for detailed description of the options.\n"
3198 "\n", program_name);
3200 show_help_options(options, "Print help / information / capabilities:",
3203 show_help_options(options, "Global options (affect whole program "
3204 "instead of just one file:",
3205 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3207 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3208 per_file | OPT_EXIT, 0);
3210 show_help_options(options, "Per-file main options:", 0,
3211 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3212 OPT_EXIT, per_file);
3214 show_help_options(options, "Advanced per-file options:",
3215 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3217 show_help_options(options, "Video options:",
3218 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3220 show_help_options(options, "Advanced Video options:",
3221 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3223 show_help_options(options, "Audio options:",
3224 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3226 show_help_options(options, "Advanced Audio options:",
3227 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3228 show_help_options(options, "Subtitle options:",
3229 OPT_SUBTITLE, 0, 0);
3232 if (show_avoptions) {
3233 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3234 show_help_children(avcodec_get_class(), flags);
3235 show_help_children(avformat_get_class(), flags);
3237 show_help_children(sws_get_class(), flags);
3239 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3240 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3244 void show_usage(void)
3246 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3247 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3248 av_log(NULL, AV_LOG_INFO, "\n");
3256 static const OptionGroupDef groups[] = {
3257 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3258 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3261 static int open_files(OptionGroupList *l, const char *inout,
3262 int (*open_file)(OptionsContext*, const char*))
3266 for (i = 0; i < l->nb_groups; i++) {
3267 OptionGroup *g = &l->groups[i];
3273 ret = parse_optgroup(&o, g);
3275 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3276 "%s.\n", inout, g->arg);
3280 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3281 ret = open_file(&o, g->arg);
3284 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3288 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3294 int ffmpeg_parse_options(int argc, char **argv)
3296 OptionParseContext octx;
3300 memset(&octx, 0, sizeof(octx));
3302 /* split the commandline into an internal representation */
3303 ret = split_commandline(&octx, argc, argv, options, groups,
3304 FF_ARRAY_ELEMS(groups));
3306 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3310 /* apply global options */
3311 ret = parse_optgroup(NULL, &octx.global_opts);
3313 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3317 /* configure terminal and setup signal handlers */
3320 /* open input files */
3321 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3323 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3327 /* create the complex filtergraphs */
3328 ret = init_complex_filters();
3330 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3334 /* open output files */
3335 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3337 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3341 check_filter_outputs();
3344 uninit_parse_context(&octx);
3346 av_strerror(ret, error, sizeof(error));
3347 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3352 static int opt_progress(void *optctx, const char *opt, const char *arg)
3354 AVIOContext *avio = NULL;
3357 if (!strcmp(arg, "-"))
3359 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3361 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3362 arg, av_err2str(ret));
3365 progress_avio = avio;
3369 #define OFFSET(x) offsetof(OptionsContext, x)
3370 const OptionDef options[] = {
3372 CMDUTILS_COMMON_OPTIONS
3373 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3374 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3375 "force format", "fmt" },
3376 { "y", OPT_BOOL, { &file_overwrite },
3377 "overwrite output files" },
3378 { "n", OPT_BOOL, { &no_file_overwrite },
3379 "never overwrite output files" },
3380 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3381 "Ignore unknown stream types" },
3382 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3383 "Copy unknown stream types" },
3384 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3385 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3386 "codec name", "codec" },
3387 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3388 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3389 "codec name", "codec" },
3390 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3391 OPT_OUTPUT, { .off = OFFSET(presets) },
3392 "preset name", "preset" },
3393 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3394 OPT_OUTPUT, { .func_arg = opt_map },
3395 "set input stream mapping",
3396 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3397 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3398 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3399 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3400 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3401 "set metadata information of outfile from infile",
3402 "outfile[,metadata]:infile[,metadata]" },
3403 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3404 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3405 "set chapters mapping", "input_file_index" },
3406 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3407 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3408 "record or transcode \"duration\" seconds of audio/video",
3410 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3411 "record or transcode stop time", "time_stop" },
3412 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3413 "set the limit file size in bytes", "limit_size" },
3414 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3415 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3416 "set the start time offset", "time_off" },
3417 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3418 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3419 "set the start time offset relative to EOF", "time_off" },
3420 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3421 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3422 "enable/disable seeking by timestamp with -ss" },
3423 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3424 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3425 "enable/disable accurate seeking with -ss" },
3426 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3427 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3428 "set the input ts offset", "time_off" },
3429 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3430 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3431 "set the input ts scale", "scale" },
3432 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3433 "set the recording timestamp ('now' to set the current time)", "time" },
3434 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3435 "add metadata", "string=string" },
3436 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3437 "add program with specified streams", "title=string:st=number..." },
3438 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3439 OPT_OUTPUT, { .func_arg = opt_data_frames },
3440 "set the number of data frames to output", "number" },
3441 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3442 "add timings for benchmarking" },
3443 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3444 "add timings for each task" },
3445 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3446 "write program-readable progress information", "url" },
3447 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3448 "enable or disable interaction on standard input" },
3449 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3450 "set max runtime in seconds", "limit" },
3451 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3452 "dump each input packet" },
3453 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3454 "when dumping packets, also dump the payload" },
3455 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3456 OPT_INPUT, { .off = OFFSET(rate_emu) },
3457 "read input at native frame rate", "" },
3458 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3459 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3460 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3461 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3462 "video sync method", "" },
3463 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3464 "frame drop threshold", "" },
3465 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3466 "audio sync method", "" },
3467 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3468 "audio drift threshold", "threshold" },
3469 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3470 "copy timestamps" },
3471 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3472 "shift input timestamps to start at 0 when using copyts" },
3473 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3474 "copy input stream time base when stream copying", "mode" },
3475 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3476 OPT_OUTPUT, { .off = OFFSET(shortest) },
3477 "finish encoding within shortest input" },
3478 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3479 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3481 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3482 OPT_OUTPUT, { .off = OFFSET(apad) },
3484 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3485 "timestamp discontinuity delta threshold", "threshold" },
3486 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3487 "timestamp error delta threshold", "threshold" },
3488 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3489 "exit on error", "error" },
3490 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3491 "abort on the specified condition flags", "flags" },
3492 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3493 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3494 "copy initial non-keyframes" },
3495 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3496 "copy or discard frames before start time" },
3497 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3498 "set the number of frames to output", "number" },
3499 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3500 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3501 "force codec tag/fourcc", "fourcc/tag" },
3502 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3503 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3504 "use fixed quality scale (VBR)", "q" },
3505 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3506 OPT_OUTPUT, { .func_arg = opt_qscale },
3507 "use fixed quality scale (VBR)", "q" },
3508 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3509 "set profile", "profile" },
3510 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3511 "set stream filtergraph", "filter_graph" },
3512 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3513 "number of non-complex filter threads" },
3514 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3515 "read stream filtergraph description from a file", "filename" },
3516 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3517 "reinit filtergraph on input parameter changes", "" },
3518 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3519 "create a complex filtergraph", "graph_description" },
3520 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3521 "number of threads for -filter_complex" },
3522 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3523 "create a complex filtergraph", "graph_description" },
3524 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3525 "read complex filtergraph description from a file", "filename" },
3526 { "stats", OPT_BOOL, { &print_stats },
3527 "print progress report during encoding", },
3528 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3529 OPT_OUTPUT, { .func_arg = opt_attach },
3530 "add an attachment to the output file", "filename" },
3531 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3532 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3533 "extract an attachment into a file", "filename" },
3534 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3535 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3536 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3537 "print timestamp debugging info" },
3538 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3539 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3540 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3541 OPT_INPUT, { .off = OFFSET(discard) },
3543 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3544 OPT_OUTPUT, { .off = OFFSET(disposition) },
3545 "disposition", "" },
3546 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3547 { .off = OFFSET(thread_queue_size) },
3548 "set the maximum number of queued packets from the demuxer" },
3549 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3550 "read and decode the streams to fill missing information with heuristics" },
3553 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3554 "set the number of video frames to output", "number" },
3555 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3556 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3557 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3558 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3559 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3560 "set frame size (WxH or abbreviation)", "size" },
3561 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3562 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3563 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3564 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3565 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3566 "set pixel format", "format" },
3567 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3568 "set the number of bits per raw sample", "number" },
3569 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3570 "deprecated use -g 1" },
3571 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3573 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3574 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3575 "rate control override for specific intervals", "override" },
3576 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3577 OPT_OUTPUT, { .func_arg = opt_video_codec },
3578 "force video codec ('copy' to copy stream)", "codec" },
3579 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3581 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3583 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3584 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3585 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3586 "select the pass number (1 to 3)", "n" },
3587 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3588 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3589 "select two pass log file name prefix", "prefix" },
3590 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3591 "this option is deprecated, use the yadif filter instead" },
3592 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3593 "calculate PSNR of compressed frames" },
3594 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3595 "dump video coding statistics to file" },
3596 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3597 "dump video coding statistics to file", "file" },
3598 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3599 "Version of the vstats format to use."},
3600 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3601 "set video filters", "filter_graph" },
3602 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3603 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3604 "specify intra matrix coeffs", "matrix" },
3605 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3606 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3607 "specify inter matrix coeffs", "matrix" },
3608 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3609 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3610 "specify intra matrix coeffs", "matrix" },
3611 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3612 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3613 "top=1/bottom=0/auto=-1 field first", "" },
3614 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3615 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3616 "force video tag/fourcc", "fourcc/tag" },
3617 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3618 "show QP histogram" },
3619 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3620 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3621 "force the selected framerate, disable the best supported framerate selection" },
3622 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3623 OPT_OUTPUT, { .func_arg = opt_streamid },
3624 "set the value of an outfile streamid", "streamIndex:value" },
3625 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3626 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3627 "force key frames at specified timestamps", "timestamps" },
3628 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3629 "audio bitrate (please use -b:a)", "bitrate" },
3630 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3631 "video bitrate (please use -b:v)", "bitrate" },
3632 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3633 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3634 "use HW accelerated decoding", "hwaccel name" },
3635 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3636 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3637 "select a device for HW acceleration", "devicename" },
3638 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3639 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3640 "select output format used with HW accelerated decoding", "format" },
3641 #if CONFIG_VIDEOTOOLBOX
3642 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3644 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3645 "show available HW acceleration methods" },
3646 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3647 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3648 "automatically insert correct rotate filters" },
3651 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3652 "set the number of audio frames to output", "number" },
3653 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3654 "set audio quality (codec-specific)", "quality", },
3655 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3656 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3657 "set audio sampling rate (in Hz)", "rate" },
3658 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3659 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3660 "set number of audio channels", "channels" },
3661 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3663 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3664 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3665 "force audio codec ('copy' to copy stream)", "codec" },
3666 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3667 OPT_OUTPUT, { .func_arg = opt_old2new },
3668 "force audio tag/fourcc", "fourcc/tag" },
3669 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3670 "change audio volume (256=normal)" , "volume" },
3671 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3672 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3673 "set sample format", "format" },
3674 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3675 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3676 "set channel layout", "layout" },
3677 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3678 "set audio filters", "filter_graph" },
3679 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3680 "set the maximum number of channels to try to guess the channel layout" },
3682 /* subtitle options */
3683 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3684 "disable subtitle" },
3685 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3686 "force subtitle codec ('copy' to copy stream)", "codec" },
3687 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3688 , "force subtitle tag/fourcc", "fourcc/tag" },
3689 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3690 "fix subtitles duration" },
3691 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3692 "set canvas size (WxH or abbreviation)", "size" },
3695 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3696 "deprecated, use -channel", "channel" },
3697 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3698 "deprecated, use -standard", "standard" },
3699 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3702 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3703 "set the maximum demux-decode delay", "seconds" },
3704 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3705 "set the initial demux-decode delay", "seconds" },
3706 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3707 "override the options from ffserver", "" },
3708 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3709 "specify a file in which to print sdp information", "file" },
3711 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3712 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3713 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3714 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3715 "two special values are defined - "
3716 "0 = use frame rate (video) or sample rate (audio),"
3717 "-1 = match source time base", "ratio" },
3719 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3720 "A comma-separated list of bitstream filters", "bitstream_filters" },
3721 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3722 "deprecated", "audio bitstream_filters" },
3723 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3724 "deprecated", "video bitstream_filters" },
3726 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3727 "set the audio options to the indicated preset", "preset" },
3728 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3729 "set the video options to the indicated preset", "preset" },
3730 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3731 "set the subtitle options to the indicated preset", "preset" },
3732 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3733 "set options from indicated preset file", "filename" },
3735 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3736 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3738 /* data codec support */
3739 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3740 "force data codec ('copy' to copy stream)", "codec" },
3741 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3745 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3746 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3750 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3751 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3754 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3755 "initialise hardware device", "args" },
3756 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3757 "set hardware device used when filtering", "device" },