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[] = {
69 #if CONFIG_VIDEOTOOLBOX
70 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
73 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
76 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
80 AVBufferRef *hw_device_ctx;
81 HWDevice *filter_hw_device;
83 char *vstats_filename;
86 float audio_drift_threshold = 0.1;
87 float dts_delta_threshold = 10;
88 float dts_error_threshold = 3600*30;
90 int audio_volume = 256;
91 int audio_sync_method = 0;
92 int video_sync_method = VSYNC_AUTO;
93 float frame_drop_threshold = 0;
94 int do_deinterlace = 0;
96 int do_benchmark_all = 0;
100 int start_at_zero = 0;
103 int exit_on_error = 0;
104 int abort_on_flags = 0;
105 int print_stats = -1;
107 int stdin_interaction = 1;
108 int frame_bits_per_raw_sample = 0;
109 float max_error_rate = 2.0/3;
110 int filter_nbthreads = 0;
111 int filter_complex_nbthreads = 0;
112 int vstats_version = 2;
115 static int intra_only = 0;
116 static int file_overwrite = 0;
117 static int no_file_overwrite = 0;
118 static int do_psnr = 0;
119 static int input_sync;
120 static int input_stream_potentially_available = 0;
121 static int ignore_unknown_streams = 0;
122 static int copy_unknown_streams = 0;
123 static int find_stream_info = 1;
125 static void uninit_options(OptionsContext *o)
127 const OptionDef *po = options;
130 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
132 void *dst = (uint8_t*)o + po->u.off;
134 if (po->flags & OPT_SPEC) {
135 SpecifierOpt **so = dst;
136 int i, *count = (int*)(so + 1);
137 for (i = 0; i < *count; i++) {
138 av_freep(&(*so)[i].specifier);
139 if (po->flags & OPT_STRING)
140 av_freep(&(*so)[i].u.str);
144 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
149 for (i = 0; i < o->nb_stream_maps; i++)
150 av_freep(&o->stream_maps[i].linklabel);
151 av_freep(&o->stream_maps);
152 av_freep(&o->audio_channel_maps);
153 av_freep(&o->streamid_map);
154 av_freep(&o->attachments);
157 static void init_options(OptionsContext *o)
159 memset(o, 0, sizeof(*o));
161 o->stop_time = INT64_MAX;
162 o->mux_max_delay = 0.7;
163 o->start_time = AV_NOPTS_VALUE;
164 o->start_time_eof = AV_NOPTS_VALUE;
165 o->recording_time = INT64_MAX;
166 o->limit_filesize = UINT64_MAX;
167 o->chapters_input_file = INT_MAX;
168 o->accurate_seek = 1;
171 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
176 printf("Hardware acceleration methods:\n");
177 while ((type = av_hwdevice_iterate_types(type)) !=
178 AV_HWDEVICE_TYPE_NONE)
179 printf("%s\n", av_hwdevice_get_type_name(type));
180 for (i = 0; hwaccels[i].name; i++)
181 printf("%s\n", hwaccels[i].name);
186 /* return a copy of the input with the stream specifiers removed from the keys */
187 static AVDictionary *strip_specifiers(AVDictionary *dict)
189 AVDictionaryEntry *e = NULL;
190 AVDictionary *ret = NULL;
192 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
193 char *p = strchr(e->key, ':');
197 av_dict_set(&ret, e->key, e->value, 0);
204 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
206 static const AVOption opts[] = {
207 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
208 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
211 static const AVClass class = {
213 .item_name = av_default_item_name,
215 .version = LIBAVUTIL_VERSION_INT,
217 const AVClass *pclass = &class;
219 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
222 static int opt_sameq(void *optctx, const char *opt, const char *arg)
224 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
225 "If you are looking for an option to preserve the quality (which is not "
226 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
228 return AVERROR(EINVAL);
231 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
233 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
234 return opt_default(optctx, "channel", arg);
237 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
239 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
240 return opt_default(optctx, "standard", arg);
243 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
245 OptionsContext *o = optctx;
246 return parse_option(o, "codec:a", arg, options);
249 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
251 OptionsContext *o = optctx;
252 return parse_option(o, "codec:v", arg, options);
255 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
257 OptionsContext *o = optctx;
258 return parse_option(o, "codec:s", arg, options);
261 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
263 OptionsContext *o = optctx;
264 return parse_option(o, "codec:d", arg, options);
267 static int opt_map(void *optctx, const char *opt, const char *arg)
269 OptionsContext *o = optctx;
271 int i, negative = 0, file_idx, disabled = 0;
272 int sync_file_idx = -1, sync_stream_idx = 0;
281 map = av_strdup(arg);
283 return AVERROR(ENOMEM);
285 /* parse sync stream first, just pick first matching stream */
286 if (sync = strchr(map, ',')) {
288 sync_file_idx = strtol(sync + 1, &sync, 0);
289 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
290 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
295 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
296 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
297 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
301 if (i == input_files[sync_file_idx]->nb_streams) {
302 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
303 "match any streams.\n", arg);
306 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
307 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
315 /* this mapping refers to lavfi output */
316 const char *c = map + 1;
317 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
318 m = &o->stream_maps[o->nb_stream_maps - 1];
319 m->linklabel = av_get_token(&c, "]");
321 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
325 if (allow_unused = strchr(map, '?'))
327 file_idx = strtol(map, &p, 0);
328 if (file_idx >= nb_input_files || file_idx < 0) {
329 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
333 /* disable some already defined maps */
334 for (i = 0; i < o->nb_stream_maps; i++) {
335 m = &o->stream_maps[i];
336 if (file_idx == m->file_index &&
337 check_stream_specifier(input_files[m->file_index]->ctx,
338 input_files[m->file_index]->ctx->streams[m->stream_index],
339 *p == ':' ? p + 1 : p) > 0)
343 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
344 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
345 *p == ':' ? p + 1 : p) <= 0)
347 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
351 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
352 m = &o->stream_maps[o->nb_stream_maps - 1];
354 m->file_index = file_idx;
357 if (sync_file_idx >= 0) {
358 m->sync_file_index = sync_file_idx;
359 m->sync_stream_index = sync_stream_idx;
361 m->sync_file_index = file_idx;
362 m->sync_stream_index = i;
369 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
370 } else if (disabled) {
371 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
372 "To ignore this, add a trailing '?' to the map.\n", arg);
375 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
376 "To ignore this, add a trailing '?' to the map.\n", arg);
385 static int opt_attach(void *optctx, const char *opt, const char *arg)
387 OptionsContext *o = optctx;
388 GROW_ARRAY(o->attachments, o->nb_attachments);
389 o->attachments[o->nb_attachments - 1] = arg;
393 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
395 OptionsContext *o = optctx;
401 mapchan = av_strdup(arg);
403 return AVERROR(ENOMEM);
405 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
406 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
408 /* muted channel syntax */
409 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
410 if ((n == 1 || n == 3) && m->channel_idx == -1) {
411 m->file_idx = m->stream_idx = -1;
413 m->ofile_idx = m->ostream_idx = -1;
419 n = sscanf(arg, "%d.%d.%d:%d.%d",
420 &m->file_idx, &m->stream_idx, &m->channel_idx,
421 &m->ofile_idx, &m->ostream_idx);
423 if (n != 3 && n != 5) {
424 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
425 "[file.stream.channel|-1][:syncfile:syncstream]\n");
429 if (n != 5) // only file.stream.channel specified
430 m->ofile_idx = m->ostream_idx = -1;
433 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
434 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
438 if (m->stream_idx < 0 ||
439 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
440 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
441 m->file_idx, m->stream_idx);
444 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
445 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
446 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
447 m->file_idx, m->stream_idx);
450 /* allow trailing ? to map_channel */
451 if (allow_unused = strchr(mapchan, '?'))
453 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
454 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
456 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
457 m->file_idx, m->stream_idx, m->channel_idx);
459 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
460 "To ignore this, add a trailing '?' to the map_channel.\n",
461 m->file_idx, m->stream_idx, m->channel_idx);
470 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
472 av_free(sdp_filename);
473 sdp_filename = av_strdup(arg);
478 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
481 const char *prefix = "vaapi:";
484 tmp = av_asprintf("%s%s", prefix, arg);
486 return AVERROR(ENOMEM);
487 err = hw_device_init_from_string(tmp, &dev);
491 hw_device_ctx = av_buffer_ref(dev->device_ref);
493 return AVERROR(ENOMEM);
498 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
500 if (!strcmp(arg, "list")) {
501 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
502 printf("Supported hardware device types:\n");
503 while ((type = av_hwdevice_iterate_types(type)) !=
504 AV_HWDEVICE_TYPE_NONE)
505 printf("%s\n", av_hwdevice_get_type_name(type));
509 return hw_device_init_from_string(arg, NULL);
513 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
515 if (filter_hw_device) {
516 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
517 return AVERROR(EINVAL);
519 filter_hw_device = hw_device_get_by_name(arg);
520 if (!filter_hw_device) {
521 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
522 return AVERROR(EINVAL);
528 * Parse a metadata specifier passed as 'arg' parameter.
529 * @param arg metadata string to parse
530 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
531 * @param index for type c/p, chapter/program index is written here
532 * @param stream_spec for type s, the stream specifier is written here
534 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
542 if (*(++arg) && *arg != ':') {
543 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
546 *stream_spec = *arg == ':' ? arg + 1 : "";
551 *index = strtol(++arg, NULL, 0);
554 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
561 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
563 AVDictionary **meta_in = NULL;
564 AVDictionary **meta_out = NULL;
566 char type_in, type_out;
567 const char *istream_spec = NULL, *ostream_spec = NULL;
568 int idx_in = 0, idx_out = 0;
570 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
571 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
574 if (type_out == 'g' || !*outspec)
575 o->metadata_global_manual = 1;
576 if (type_out == 's' || !*outspec)
577 o->metadata_streams_manual = 1;
578 if (type_out == 'c' || !*outspec)
579 o->metadata_chapters_manual = 1;
583 if (type_in == 'g' || type_out == 'g')
584 o->metadata_global_manual = 1;
585 if (type_in == 's' || type_out == 's')
586 o->metadata_streams_manual = 1;
587 if (type_in == 'c' || type_out == 'c')
588 o->metadata_chapters_manual = 1;
590 /* ic is NULL when just disabling automatic mappings */
594 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
595 if ((index) < 0 || (index) >= (nb_elems)) {\
596 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
601 #define SET_DICT(type, meta, context, index)\
604 meta = &context->metadata;\
607 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
608 meta = &context->chapters[index]->metadata;\
611 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
612 meta = &context->programs[index]->metadata;\
615 break; /* handled separately below */ \
616 default: av_assert0(0);\
619 SET_DICT(type_in, meta_in, ic, idx_in);
620 SET_DICT(type_out, meta_out, oc, idx_out);
622 /* for input streams choose first matching stream */
623 if (type_in == 's') {
624 for (i = 0; i < ic->nb_streams; i++) {
625 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
626 meta_in = &ic->streams[i]->metadata;
632 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
637 if (type_out == 's') {
638 for (i = 0; i < oc->nb_streams; i++) {
639 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
640 meta_out = &oc->streams[i]->metadata;
641 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
646 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
651 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
653 OptionsContext *o = optctx;
655 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
656 struct tm time = *gmtime((time_t*)&recording_timestamp);
657 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
659 parse_option(o, "metadata", buf, options);
661 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
662 "tag instead.\n", opt);
666 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
668 const AVCodecDescriptor *desc;
669 const char *codec_string = encoder ? "encoder" : "decoder";
673 avcodec_find_encoder_by_name(name) :
674 avcodec_find_decoder_by_name(name);
676 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
677 codec = encoder ? avcodec_find_encoder(desc->id) :
678 avcodec_find_decoder(desc->id);
680 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
681 codec_string, codec->name, desc->name);
685 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
688 if (codec->type != type) {
689 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
695 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
697 char *codec_name = NULL;
699 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
701 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
702 st->codecpar->codec_id = codec->id;
705 return avcodec_find_decoder(st->codecpar->codec_id);
708 /* Add all the streams from the given input file to the global
709 * list of input streams. */
710 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
714 for (i = 0; i < ic->nb_streams; i++) {
715 AVStream *st = ic->streams[i];
716 AVCodecParameters *par = st->codecpar;
717 InputStream *ist = av_mallocz(sizeof(*ist));
718 char *framerate = NULL, *hwaccel_device = NULL;
719 const char *hwaccel = NULL;
720 char *hwaccel_output_format = NULL;
721 char *codec_tag = NULL;
723 char *discard_str = NULL;
724 const AVClass *cc = avcodec_get_class();
725 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
730 GROW_ARRAY(input_streams, nb_input_streams);
731 input_streams[nb_input_streams - 1] = ist;
734 ist->file_index = nb_input_files;
736 st->discard = AVDISCARD_ALL;
738 ist->min_pts = INT64_MAX;
739 ist->max_pts = INT64_MIN;
742 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
745 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
747 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
749 uint32_t tag = strtol(codec_tag, &next, 0);
751 tag = AV_RL32(codec_tag);
752 st->codecpar->codec_tag = tag;
755 ist->dec = choose_decoder(o, ic, st);
756 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
758 ist->reinit_filters = -1;
759 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
761 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
762 ist->user_set_discard = AVDISCARD_NONE;
764 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
765 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
766 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
767 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
768 ist->user_set_discard = AVDISCARD_ALL;
770 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
771 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
776 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
778 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
780 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
784 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
786 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
791 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
793 switch (par->codec_type) {
794 case AVMEDIA_TYPE_VIDEO:
796 ist->dec = avcodec_find_decoder(par->codec_id);
798 if (st->codec->lowres) {
799 ist->dec_ctx->lowres = st->codec->lowres;
800 ist->dec_ctx->width = st->codec->width;
801 ist->dec_ctx->height = st->codec->height;
802 ist->dec_ctx->coded_width = st->codec->coded_width;
803 ist->dec_ctx->coded_height = st->codec->coded_height;
807 // avformat_find_stream_info() doesn't set this for us anymore.
808 ist->dec_ctx->framerate = st->avg_frame_rate;
810 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
811 if (framerate && av_parse_video_rate(&ist->framerate,
813 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
818 ist->top_field_first = -1;
819 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
821 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
823 // The NVDEC hwaccels use a CUDA device, so remap the name here.
824 if (!strcmp(hwaccel, "nvdec"))
827 if (!strcmp(hwaccel, "none"))
828 ist->hwaccel_id = HWACCEL_NONE;
829 else if (!strcmp(hwaccel, "auto"))
830 ist->hwaccel_id = HWACCEL_AUTO;
832 enum AVHWDeviceType type;
834 for (i = 0; hwaccels[i].name; i++) {
835 if (!strcmp(hwaccels[i].name, hwaccel)) {
836 ist->hwaccel_id = hwaccels[i].id;
841 if (!ist->hwaccel_id) {
842 type = av_hwdevice_find_type_by_name(hwaccel);
843 if (type != AV_HWDEVICE_TYPE_NONE) {
844 ist->hwaccel_id = HWACCEL_GENERIC;
845 ist->hwaccel_device_type = type;
849 if (!ist->hwaccel_id) {
850 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
852 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
853 type = AV_HWDEVICE_TYPE_NONE;
854 while ((type = av_hwdevice_iterate_types(type)) !=
855 AV_HWDEVICE_TYPE_NONE)
856 av_log(NULL, AV_LOG_FATAL, "%s ",
857 av_hwdevice_get_type_name(type));
858 for (i = 0; hwaccels[i].name; i++)
859 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
860 av_log(NULL, AV_LOG_FATAL, "\n");
866 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
867 if (hwaccel_device) {
868 ist->hwaccel_device = av_strdup(hwaccel_device);
869 if (!ist->hwaccel_device)
873 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
874 hwaccel_output_format, ic, st);
875 if (hwaccel_output_format) {
876 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
877 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
878 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
879 "format: %s", hwaccel_output_format);
882 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
885 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
888 case AVMEDIA_TYPE_AUDIO:
889 ist->guess_layout_max = INT_MAX;
890 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
891 guess_input_channel_layout(ist);
893 case AVMEDIA_TYPE_DATA:
894 case AVMEDIA_TYPE_SUBTITLE: {
895 char *canvas_size = NULL;
897 ist->dec = avcodec_find_decoder(par->codec_id);
898 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
899 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
901 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
902 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
907 case AVMEDIA_TYPE_ATTACHMENT:
908 case AVMEDIA_TYPE_UNKNOWN:
914 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
916 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
922 static void assert_file_overwrite(const char *filename)
924 const char *proto_name = avio_find_protocol_name(filename);
926 if (file_overwrite && no_file_overwrite) {
927 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
931 if (!file_overwrite) {
932 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
933 if (stdin_interaction && !no_file_overwrite) {
934 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
937 signal(SIGINT, SIG_DFL);
939 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
945 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
951 if (proto_name && !strcmp(proto_name, "file")) {
952 for (int i = 0; i < nb_input_files; i++) {
953 InputFile *file = input_files[i];
954 if (file->ctx->iformat->flags & AVFMT_NOFILE)
956 if (!strcmp(filename, file->ctx->url)) {
957 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
958 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
965 static void dump_attachment(AVStream *st, const char *filename)
968 AVIOContext *out = NULL;
969 AVDictionaryEntry *e;
971 if (!st->codecpar->extradata_size) {
972 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
973 nb_input_files - 1, st->index);
976 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
979 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
980 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
984 assert_file_overwrite(filename);
986 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
987 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
992 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
997 static int open_input_file(OptionsContext *o, const char *filename)
1000 AVFormatContext *ic;
1001 AVInputFormat *file_iformat = NULL;
1004 AVDictionary *unused_opts = NULL;
1005 AVDictionaryEntry *e = NULL;
1006 char * video_codec_name = NULL;
1007 char * audio_codec_name = NULL;
1008 char *subtitle_codec_name = NULL;
1009 char * data_codec_name = NULL;
1010 int scan_all_pmts_set = 0;
1012 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1013 o->stop_time = INT64_MAX;
1014 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1017 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1018 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1019 if (o->stop_time <= start_time) {
1020 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1023 o->recording_time = o->stop_time - start_time;
1028 if (!(file_iformat = av_find_input_format(o->format))) {
1029 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1034 if (!strcmp(filename, "-"))
1037 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1038 strcmp(filename, "/dev/stdin");
1040 /* get default parameters from command line */
1041 ic = avformat_alloc_context();
1043 print_error(filename, AVERROR(ENOMEM));
1046 if (o->nb_audio_sample_rate) {
1047 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1049 if (o->nb_audio_channels) {
1050 /* because we set audio_channels based on both the "ac" and
1051 * "channel_layout" options, we need to check that the specified
1052 * demuxer actually has the "channels" option before setting it */
1053 if (file_iformat && file_iformat->priv_class &&
1054 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1055 AV_OPT_SEARCH_FAKE_OBJ)) {
1056 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1059 if (o->nb_frame_rates) {
1060 /* set the format-level framerate option;
1061 * this is important for video grabbers, e.g. x11 */
1062 if (file_iformat && file_iformat->priv_class &&
1063 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1064 AV_OPT_SEARCH_FAKE_OBJ)) {
1065 av_dict_set(&o->g->format_opts, "framerate",
1066 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1069 if (o->nb_frame_sizes) {
1070 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1072 if (o->nb_frame_pix_fmts)
1073 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1075 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1076 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1077 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1078 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1080 if (video_codec_name)
1081 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1082 if (audio_codec_name)
1083 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1084 if (subtitle_codec_name)
1085 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1086 if (data_codec_name)
1087 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1089 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1090 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1091 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1092 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1094 ic->flags |= AVFMT_FLAG_NONBLOCK;
1096 ic->flags |= AVFMT_FLAG_BITEXACT;
1097 ic->interrupt_callback = int_cb;
1099 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1100 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1101 scan_all_pmts_set = 1;
1103 /* open the input file with generic avformat function */
1104 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1106 print_error(filename, err);
1107 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1108 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1111 if (scan_all_pmts_set)
1112 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1113 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1114 assert_avoptions(o->g->format_opts);
1116 /* apply forced codec ids */
1117 for (i = 0; i < ic->nb_streams; i++)
1118 choose_decoder(o, ic, ic->streams[i]);
1120 if (find_stream_info) {
1121 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1122 int orig_nb_streams = ic->nb_streams;
1124 /* If not enough info to get the stream parameters, we decode the
1125 first frames to get it. (used in mpeg case for example) */
1126 ret = avformat_find_stream_info(ic, opts);
1128 for (i = 0; i < orig_nb_streams; i++)
1129 av_dict_free(&opts[i]);
1133 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1134 if (ic->nb_streams == 0) {
1135 avformat_close_input(&ic);
1141 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1142 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1143 o->start_time_eof = AV_NOPTS_VALUE;
1146 if (o->start_time_eof != AV_NOPTS_VALUE) {
1147 if (o->start_time_eof >= 0) {
1148 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1151 if (ic->duration > 0) {
1152 o->start_time = o->start_time_eof + ic->duration;
1153 if (o->start_time < 0) {
1154 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1155 o->start_time = AV_NOPTS_VALUE;
1158 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1160 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1161 /* add the stream start time */
1162 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1163 timestamp += ic->start_time;
1165 /* if seeking requested, we execute it */
1166 if (o->start_time != AV_NOPTS_VALUE) {
1167 int64_t seek_timestamp = timestamp;
1169 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1170 int dts_heuristic = 0;
1171 for (i=0; i<ic->nb_streams; i++) {
1172 const AVCodecParameters *par = ic->streams[i]->codecpar;
1173 if (par->video_delay) {
1178 if (dts_heuristic) {
1179 seek_timestamp -= 3*AV_TIME_BASE / 23;
1182 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1184 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1185 filename, (double)timestamp / AV_TIME_BASE);
1189 /* update the current parameters so that they match the one of the input stream */
1190 add_input_streams(o, ic);
1192 /* dump the file content */
1193 av_dump_format(ic, nb_input_files, filename, 0);
1195 GROW_ARRAY(input_files, nb_input_files);
1196 f = av_mallocz(sizeof(*f));
1199 input_files[nb_input_files - 1] = f;
1202 f->ist_index = nb_input_streams - ic->nb_streams;
1203 f->start_time = o->start_time;
1204 f->recording_time = o->recording_time;
1205 f->input_ts_offset = o->input_ts_offset;
1206 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1207 f->nb_streams = ic->nb_streams;
1208 f->rate_emu = o->rate_emu;
1209 f->accurate_seek = o->accurate_seek;
1212 f->time_base = (AVRational){ 1, 1 };
1214 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1217 /* check if all codec options have been used */
1218 unused_opts = strip_specifiers(o->g->codec_opts);
1219 for (i = f->ist_index; i < nb_input_streams; i++) {
1221 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1222 AV_DICT_IGNORE_SUFFIX)))
1223 av_dict_set(&unused_opts, e->key, NULL, 0);
1227 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1228 const AVClass *class = avcodec_get_class();
1229 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1230 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1231 const AVClass *fclass = avformat_get_class();
1232 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1233 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1234 if (!option || foption)
1238 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1239 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1240 "input file #%d (%s) is not a decoding option.\n", e->key,
1241 option->help ? option->help : "", nb_input_files - 1,
1246 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1247 "input file #%d (%s) has not been used for any stream. The most "
1248 "likely reason is either wrong type (e.g. a video option with "
1249 "no video streams) or that it is a private option of some decoder "
1250 "which was not actually used for any stream.\n", e->key,
1251 option->help ? option->help : "", nb_input_files - 1, filename);
1253 av_dict_free(&unused_opts);
1255 for (i = 0; i < o->nb_dump_attachment; i++) {
1258 for (j = 0; j < ic->nb_streams; j++) {
1259 AVStream *st = ic->streams[j];
1261 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1262 dump_attachment(st, o->dump_attachment[i].u.str);
1266 input_stream_potentially_available = 1;
1271 static uint8_t *get_line(AVIOContext *s)
1277 if (avio_open_dyn_buf(&line) < 0) {
1278 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1282 while ((c = avio_r8(s)) && c != '\n')
1285 avio_close_dyn_buf(line, &buf);
1290 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1293 char filename[1000];
1294 const char *base[3] = { getenv("AVCONV_DATADIR"),
1299 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1303 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1304 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1305 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1308 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1309 i != 1 ? "" : "/.avconv", preset_name);
1310 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1316 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1318 enum AVMediaType type = ost->st->codecpar->codec_type;
1319 char *codec_name = NULL;
1321 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1322 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1324 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1325 NULL, ost->st->codecpar->codec_type);
1326 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1328 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1329 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1330 "probably disabled. Please choose an encoder manually.\n",
1331 ost->file_index, ost->index, s->oformat->name,
1332 avcodec_get_name(ost->st->codecpar->codec_id));
1333 return AVERROR_ENCODER_NOT_FOUND;
1335 } else if (!strcmp(codec_name, "copy"))
1336 ost->stream_copy = 1;
1338 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1339 ost->st->codecpar->codec_id = ost->enc->id;
1341 ost->encoding_needed = !ost->stream_copy;
1343 /* no encoding supported for other media types */
1344 ost->stream_copy = 1;
1345 ost->encoding_needed = 0;
1351 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1354 AVStream *st = avformat_new_stream(oc, NULL);
1355 int idx = oc->nb_streams - 1, ret = 0;
1356 const char *bsfs = NULL, *time_base = NULL;
1357 char *next, *codec_tag = NULL;
1362 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1366 if (oc->nb_streams - 1 < o->nb_streamid_map)
1367 st->id = o->streamid_map[oc->nb_streams - 1];
1369 GROW_ARRAY(output_streams, nb_output_streams);
1370 if (!(ost = av_mallocz(sizeof(*ost))))
1372 output_streams[nb_output_streams - 1] = ost;
1374 ost->file_index = nb_output_files - 1;
1377 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1378 st->codecpar->codec_type = type;
1380 ret = choose_encoder(o, oc, ost);
1382 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1383 "%d:%d\n", ost->file_index, ost->index);
1387 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1388 if (!ost->enc_ctx) {
1389 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1392 ost->enc_ctx->codec_type = type;
1394 ost->ref_par = avcodec_parameters_alloc();
1395 if (!ost->ref_par) {
1396 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1401 AVIOContext *s = NULL;
1402 char *buf = NULL, *arg = NULL, *preset = NULL;
1404 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1406 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1407 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1410 if (!buf[0] || buf[0] == '#') {
1414 if (!(arg = strchr(buf, '='))) {
1415 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1419 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1421 } while (!s->eof_reached);
1425 av_log(NULL, AV_LOG_FATAL,
1426 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1427 preset, ost->file_index, ost->index);
1431 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1436 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1438 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1441 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1442 q.num <= 0 || q.den <= 0) {
1443 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1449 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1452 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1454 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1457 ost->enc_timebase = q;
1460 ost->max_frames = INT64_MAX;
1461 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1462 for (i = 0; i<o->nb_max_frames; i++) {
1463 char *p = o->max_frames[i].specifier;
1464 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1465 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1470 ost->copy_prior_start = -1;
1471 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1473 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1474 while (bsfs && *bsfs) {
1475 const AVBitStreamFilter *filter;
1476 char *bsf, *bsf_options_str, *bsf_name;
1478 bsf = av_get_token(&bsfs, ",");
1481 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1485 filter = av_bsf_get_by_name(bsf_name);
1487 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1491 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1492 ost->nb_bitstream_filters + 1,
1493 sizeof(*ost->bsf_ctx));
1497 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1499 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1503 ost->nb_bitstream_filters++;
1505 if (bsf_options_str && filter->priv_class) {
1506 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1507 const char * shorthand[2] = {NULL};
1510 shorthand[0] = opt->name;
1512 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1514 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1524 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1526 uint32_t tag = strtol(codec_tag, &next, 0);
1528 tag = AV_RL32(codec_tag);
1529 ost->st->codecpar->codec_tag =
1530 ost->enc_ctx->codec_tag = tag;
1533 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1535 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1536 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1539 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1540 ost->disposition = av_strdup(ost->disposition);
1542 ost->max_muxing_queue_size = 128;
1543 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1544 ost->max_muxing_queue_size *= sizeof(AVPacket);
1546 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1547 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1549 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1551 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1552 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1553 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1555 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1557 ost->source_index = source_index;
1558 if (source_index >= 0) {
1559 ost->sync_ist = input_streams[source_index];
1560 input_streams[source_index]->discard = 0;
1561 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1563 ost->last_mux_dts = AV_NOPTS_VALUE;
1565 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1566 if (!ost->muxing_queue)
1572 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1575 const char *p = str;
1582 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1589 /* read file contents into a string */
1590 static uint8_t *read_file(const char *filename)
1592 AVIOContext *pb = NULL;
1593 AVIOContext *dyn_buf = NULL;
1594 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1595 uint8_t buf[1024], *str;
1598 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1602 ret = avio_open_dyn_buf(&dyn_buf);
1607 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1608 avio_write(dyn_buf, buf, ret);
1609 avio_w8(dyn_buf, 0);
1612 ret = avio_close_dyn_buf(dyn_buf, &str);
1618 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1621 AVStream *st = ost->st;
1623 if (ost->filters_script && ost->filters) {
1624 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1625 "output stream #%d:%d.\n", nb_output_files, st->index);
1629 if (ost->filters_script)
1630 return read_file(ost->filters_script);
1631 else if (ost->filters)
1632 return av_strdup(ost->filters);
1634 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1638 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1639 const OutputStream *ost, enum AVMediaType type)
1641 if (ost->filters_script || ost->filters) {
1642 av_log(NULL, AV_LOG_ERROR,
1643 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1644 "Filtering and streamcopy cannot be used together.\n",
1645 ost->filters ? "Filtergraph" : "Filtergraph script",
1646 ost->filters ? ost->filters : ost->filters_script,
1647 av_get_media_type_string(type), ost->file_index, ost->index);
1652 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1656 AVCodecContext *video_enc;
1657 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1659 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1661 video_enc = ost->enc_ctx;
1663 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1664 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1665 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1668 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1669 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1671 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1672 if (frame_aspect_ratio) {
1674 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1675 q.num <= 0 || q.den <= 0) {
1676 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1679 ost->frame_aspect_ratio = q;
1682 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1683 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1684 if (o->nb_filters > 1)
1685 av_log(NULL, AV_LOG_ERROR, "Only '-vf %s' read, ignoring remaining -vf options: Use ',' to separate filters\n", ost->filters);
1687 if (!ost->stream_copy) {
1688 const char *p = NULL;
1689 char *frame_size = NULL;
1690 char *frame_pix_fmt = NULL;
1691 char *intra_matrix = NULL, *inter_matrix = NULL;
1692 char *chroma_intra_matrix = NULL;
1696 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1697 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1698 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1702 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1703 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1704 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1705 ost->keep_pix_fmt = 1;
1706 if (!*++frame_pix_fmt)
1707 frame_pix_fmt = NULL;
1709 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1710 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1713 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1716 video_enc->gop_size = 0;
1717 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1719 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1720 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1723 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1725 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1726 if (chroma_intra_matrix) {
1727 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1729 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1732 video_enc->chroma_intra_matrix = p;
1733 parse_matrix_coeffs(p, chroma_intra_matrix);
1735 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1737 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1738 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1741 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1744 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1745 for (i = 0; p; i++) {
1747 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1749 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1752 video_enc->rc_override =
1753 av_realloc_array(video_enc->rc_override,
1754 i + 1, sizeof(RcOverride));
1755 if (!video_enc->rc_override) {
1756 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1759 video_enc->rc_override[i].start_frame = start;
1760 video_enc->rc_override[i].end_frame = end;
1762 video_enc->rc_override[i].qscale = q;
1763 video_enc->rc_override[i].quality_factor = 1.0;
1766 video_enc->rc_override[i].qscale = 0;
1767 video_enc->rc_override[i].quality_factor = -q/100.0;
1772 video_enc->rc_override_count = i;
1775 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1778 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1781 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1782 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1785 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1786 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1790 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1791 if (ost->logfile_prefix &&
1792 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1796 char logfilename[1024];
1799 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1800 ost->logfile_prefix ? ost->logfile_prefix :
1801 DEFAULT_PASS_LOGFILENAME_PREFIX,
1803 if (!strcmp(ost->enc->name, "libx264")) {
1804 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1806 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1807 char *logbuffer = read_file(logfilename);
1810 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1814 video_enc->stats_in = logbuffer;
1816 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1817 f = av_fopen_utf8(logfilename, "wb");
1819 av_log(NULL, AV_LOG_FATAL,
1820 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1821 logfilename, strerror(errno));
1829 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1830 if (ost->forced_keyframes)
1831 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1833 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1835 ost->top_field_first = -1;
1836 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1839 ost->avfilter = get_ost_filters(o, oc, ost);
1843 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1846 if (ost->stream_copy)
1847 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1852 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1857 AVCodecContext *audio_enc;
1859 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1862 audio_enc = ost->enc_ctx;
1863 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1865 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1866 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1867 if (o->nb_filters > 1)
1868 av_log(NULL, AV_LOG_ERROR, "Only '-af %s' read, ignoring remaining -af options: Use ',' to separate filters\n", ost->filters);
1870 if (!ost->stream_copy) {
1871 char *sample_fmt = NULL;
1873 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1875 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1877 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1878 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1882 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1884 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1885 ost->apad = av_strdup(ost->apad);
1887 ost->avfilter = get_ost_filters(o, oc, ost);
1891 /* check for channel mapping for this audio stream */
1892 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1893 AudioChannelMap *map = &o->audio_channel_maps[n];
1894 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1895 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1898 if (map->channel_idx == -1) {
1900 } else if (ost->source_index < 0) {
1901 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1902 ost->file_index, ost->st->index);
1905 ist = input_streams[ost->source_index];
1908 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1909 if (av_reallocp_array(&ost->audio_channels_map,
1910 ost->audio_channels_mapped + 1,
1911 sizeof(*ost->audio_channels_map)
1915 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1921 if (ost->stream_copy)
1922 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1927 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1931 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1932 if (!ost->stream_copy) {
1933 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1940 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1944 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1945 if (!ost->stream_copy) {
1946 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1953 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1955 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1956 ost->stream_copy = 1;
1961 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1965 AVCodecContext *subtitle_enc;
1967 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1969 subtitle_enc = ost->enc_ctx;
1971 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1973 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1975 if (!ost->stream_copy) {
1976 char *frame_size = NULL;
1978 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1979 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1980 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1988 /* arg format is "output-stream-index:streamid-value". */
1989 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1991 OptionsContext *o = optctx;
1996 av_strlcpy(idx_str, arg, sizeof(idx_str));
1997 p = strchr(idx_str, ':');
1999 av_log(NULL, AV_LOG_FATAL,
2000 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2005 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2006 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2007 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2011 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2013 AVFormatContext *is = ifile->ctx;
2014 AVFormatContext *os = ofile->ctx;
2018 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2020 return AVERROR(ENOMEM);
2023 for (i = 0; i < is->nb_chapters; i++) {
2024 AVChapter *in_ch = is->chapters[i], *out_ch;
2025 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2026 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2027 AV_TIME_BASE_Q, in_ch->time_base);
2028 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2029 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2032 if (in_ch->end < ts_off)
2034 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2037 out_ch = av_mallocz(sizeof(AVChapter));
2039 return AVERROR(ENOMEM);
2041 out_ch->id = in_ch->id;
2042 out_ch->time_base = in_ch->time_base;
2043 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2044 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2047 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2049 os->chapters[os->nb_chapters++] = out_ch;
2054 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2055 AVFormatContext *oc)
2059 switch (ofilter->type) {
2060 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2061 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2063 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2068 ost->source_index = -1;
2069 ost->filter = ofilter;
2072 ofilter->format = -1;
2074 if (ost->stream_copy) {
2075 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2076 "which is fed from a complex filtergraph. Filtering and streamcopy "
2077 "cannot be used together.\n", ost->file_index, ost->index);
2081 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2082 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2083 av_log(NULL, AV_LOG_ERROR,
2084 "%s '%s' was specified through the %s option "
2085 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2086 "%s and -filter_complex cannot be used together for the same stream.\n",
2087 ost->filters ? "Filtergraph" : "Filtergraph script",
2088 ost->filters ? ost->filters : ost->filters_script,
2089 opt, ost->file_index, ost->index, opt);
2093 avfilter_inout_free(&ofilter->out_tmp);
2096 static int init_complex_filters(void)
2100 for (i = 0; i < nb_filtergraphs; i++) {
2101 ret = init_complex_filtergraph(filtergraphs[i]);
2108 static int open_output_file(OptionsContext *o, const char *filename)
2110 AVFormatContext *oc;
2115 AVDictionary *unused_opts = NULL;
2116 AVDictionaryEntry *e = NULL;
2117 int format_flags = 0;
2119 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2120 o->stop_time = INT64_MAX;
2121 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2124 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2125 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2126 if (o->stop_time <= start_time) {
2127 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2130 o->recording_time = o->stop_time - start_time;
2134 GROW_ARRAY(output_files, nb_output_files);
2135 of = av_mallocz(sizeof(*of));
2138 output_files[nb_output_files - 1] = of;
2140 of->ost_index = nb_output_streams;
2141 of->recording_time = o->recording_time;
2142 of->start_time = o->start_time;
2143 of->limit_filesize = o->limit_filesize;
2144 of->shortest = o->shortest;
2145 av_dict_copy(&of->opts, o->g->format_opts, 0);
2147 if (!strcmp(filename, "-"))
2150 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2152 print_error(filename, err);
2157 if (o->recording_time != INT64_MAX)
2158 oc->duration = o->recording_time;
2160 oc->interrupt_callback = int_cb;
2162 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2164 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2165 av_opt_eval_flags(oc, o, e->value, &format_flags);
2168 format_flags |= AVFMT_FLAG_BITEXACT;
2169 oc->flags |= AVFMT_FLAG_BITEXACT;
2172 /* create streams for all unlabeled output pads */
2173 for (i = 0; i < nb_filtergraphs; i++) {
2174 FilterGraph *fg = filtergraphs[i];
2175 for (j = 0; j < fg->nb_outputs; j++) {
2176 OutputFilter *ofilter = fg->outputs[j];
2178 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2181 switch (ofilter->type) {
2182 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2183 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2184 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2186 init_output_filter(ofilter, o, oc);
2190 if (!o->nb_stream_maps) {
2191 char *subtitle_codec_name = NULL;
2192 /* pick the "best" stream of each type */
2194 /* video: highest resolution */
2195 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2196 int area = 0, idx = -1;
2197 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2198 for (i = 0; i < nb_input_streams; i++) {
2200 ist = input_streams[i];
2201 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2202 if (ist->user_set_discard == AVDISCARD_ALL)
2204 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2206 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2208 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2215 new_video_stream(o, oc, idx);
2218 /* audio: most channels */
2219 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2220 int best_score = 0, idx = -1;
2221 for (i = 0; i < nb_input_streams; i++) {
2223 ist = input_streams[i];
2224 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2225 if (ist->user_set_discard == AVDISCARD_ALL)
2227 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2228 score > best_score) {
2234 new_audio_stream(o, oc, idx);
2237 /* subtitles: pick first */
2238 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2239 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2240 for (i = 0; i < nb_input_streams; i++)
2241 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2242 AVCodecDescriptor const *input_descriptor =
2243 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2244 AVCodecDescriptor const *output_descriptor = NULL;
2245 AVCodec const *output_codec =
2246 avcodec_find_encoder(oc->oformat->subtitle_codec);
2247 int input_props = 0, output_props = 0;
2248 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2251 output_descriptor = avcodec_descriptor_get(output_codec->id);
2252 if (input_descriptor)
2253 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2254 if (output_descriptor)
2255 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2256 if (subtitle_codec_name ||
2257 input_props & output_props ||
2258 // Map dvb teletext which has neither property to any output subtitle encoder
2259 input_descriptor && output_descriptor &&
2260 (!input_descriptor->props ||
2261 !output_descriptor->props)) {
2262 new_subtitle_stream(o, oc, i);
2267 /* Data only if codec id match */
2268 if (!o->data_disable ) {
2269 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2270 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2271 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2273 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2274 && input_streams[i]->st->codecpar->codec_id == codec_id )
2275 new_data_stream(o, oc, i);
2279 for (i = 0; i < o->nb_stream_maps; i++) {
2280 StreamMap *map = &o->stream_maps[i];
2285 if (map->linklabel) {
2287 OutputFilter *ofilter = NULL;
2290 for (j = 0; j < nb_filtergraphs; j++) {
2291 fg = filtergraphs[j];
2292 for (k = 0; k < fg->nb_outputs; k++) {
2293 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2294 if (out && !strcmp(out->name, map->linklabel)) {
2295 ofilter = fg->outputs[k];
2302 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2303 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2306 init_output_filter(ofilter, o, oc);
2308 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2310 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2311 if (ist->user_set_discard == AVDISCARD_ALL) {
2312 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2313 map->file_index, map->stream_index);
2316 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2318 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2320 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2322 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2326 switch (ist->st->codecpar->codec_type) {
2327 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2328 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2329 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2330 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2331 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2332 case AVMEDIA_TYPE_UNKNOWN:
2333 if (copy_unknown_streams) {
2334 ost = new_unknown_stream (o, oc, src_idx);
2338 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2339 "Cannot map stream #%d:%d - unsupported type.\n",
2340 map->file_index, map->stream_index);
2341 if (!ignore_unknown_streams) {
2342 av_log(NULL, AV_LOG_FATAL,
2343 "If you want unsupported types ignored instead "
2344 "of failing, please use the -ignore_unknown option\n"
2345 "If you want them copied, please use -copy_unknown\n");
2350 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2351 + map->sync_stream_index];
2356 /* handle attached files */
2357 for (i = 0; i < o->nb_attachments; i++) {
2359 uint8_t *attachment;
2363 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2364 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2368 if ((len = avio_size(pb)) <= 0) {
2369 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2373 if (!(attachment = av_malloc(len))) {
2374 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2378 avio_read(pb, attachment, len);
2380 ost = new_attachment_stream(o, oc, -1);
2381 ost->stream_copy = 0;
2382 ost->attachment_filename = o->attachments[i];
2383 ost->st->codecpar->extradata = attachment;
2384 ost->st->codecpar->extradata_size = len;
2386 p = strrchr(o->attachments[i], '/');
2387 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2391 #if FF_API_LAVF_AVCTX
2392 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2393 AVDictionaryEntry *e;
2394 ost = output_streams[i];
2396 if ((ost->stream_copy || ost->attachment_filename)
2397 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2398 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2399 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2404 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2405 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2406 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2410 /* check if all codec options have been used */
2411 unused_opts = strip_specifiers(o->g->codec_opts);
2412 for (i = of->ost_index; i < nb_output_streams; i++) {
2414 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2415 AV_DICT_IGNORE_SUFFIX)))
2416 av_dict_set(&unused_opts, e->key, NULL, 0);
2420 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2421 const AVClass *class = avcodec_get_class();
2422 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2423 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2424 const AVClass *fclass = avformat_get_class();
2425 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2426 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2427 if (!option || foption)
2431 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2432 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2433 "output file #%d (%s) is not an encoding option.\n", e->key,
2434 option->help ? option->help : "", nb_output_files - 1,
2439 // gop_timecode is injected by generic code but not always used
2440 if (!strcmp(e->key, "gop_timecode"))
2443 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2444 "output file #%d (%s) has not been used for any stream. The most "
2445 "likely reason is either wrong type (e.g. a video option with "
2446 "no video streams) or that it is a private option of some encoder "
2447 "which was not actually used for any stream.\n", e->key,
2448 option->help ? option->help : "", nb_output_files - 1, filename);
2450 av_dict_free(&unused_opts);
2452 /* set the decoding_needed flags and create simple filtergraphs */
2453 for (i = of->ost_index; i < nb_output_streams; i++) {
2454 OutputStream *ost = output_streams[i];
2456 if (ost->encoding_needed && ost->source_index >= 0) {
2457 InputStream *ist = input_streams[ost->source_index];
2458 ist->decoding_needed |= DECODING_FOR_OST;
2460 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2461 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2462 err = init_simple_filtergraph(ist, ost);
2464 av_log(NULL, AV_LOG_ERROR,
2465 "Error initializing a simple filtergraph between streams "
2466 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2467 nb_output_files - 1, ost->st->index);
2473 /* set the filter output constraints */
2475 OutputFilter *f = ost->filter;
2477 switch (ost->enc_ctx->codec_type) {
2478 case AVMEDIA_TYPE_VIDEO:
2479 f->frame_rate = ost->frame_rate;
2480 f->width = ost->enc_ctx->width;
2481 f->height = ost->enc_ctx->height;
2482 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2483 f->format = ost->enc_ctx->pix_fmt;
2484 } else if (ost->enc->pix_fmts) {
2486 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2488 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2491 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2494 case AVMEDIA_TYPE_AUDIO:
2495 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2496 f->format = ost->enc_ctx->sample_fmt;
2497 } else if (ost->enc->sample_fmts) {
2499 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2501 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2504 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2506 if (ost->enc_ctx->sample_rate) {
2507 f->sample_rate = ost->enc_ctx->sample_rate;
2508 } else if (ost->enc->supported_samplerates) {
2510 while (ost->enc->supported_samplerates[count])
2512 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2513 if (!f->sample_rates)
2515 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2516 (count + 1) * sizeof(*f->sample_rates));
2518 if (ost->enc_ctx->channels) {
2519 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2520 } else if (ost->enc->channel_layouts) {
2522 while (ost->enc->channel_layouts[count])
2524 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2525 if (!f->channel_layouts)
2527 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2528 (count + 1) * sizeof(*f->channel_layouts));
2535 /* check filename in case of an image number is expected */
2536 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2537 if (!av_filename_number_test(oc->url)) {
2538 print_error(oc->url, AVERROR(EINVAL));
2543 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2544 av_log(NULL, AV_LOG_ERROR,
2545 "No input streams but output needs an input stream\n");
2549 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2550 /* test if it already exists to avoid losing precious files */
2551 assert_file_overwrite(filename);
2554 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2555 &oc->interrupt_callback,
2557 print_error(filename, err);
2560 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2561 assert_file_overwrite(filename);
2563 if (o->mux_preload) {
2564 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2566 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2569 for (i = 0; i < o->nb_metadata_map; i++) {
2571 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2573 if (in_file_index >= nb_input_files) {
2574 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2577 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2578 in_file_index >= 0 ?
2579 input_files[in_file_index]->ctx : NULL, o);
2583 if (o->chapters_input_file >= nb_input_files) {
2584 if (o->chapters_input_file == INT_MAX) {
2585 /* copy chapters from the first input file that has them*/
2586 o->chapters_input_file = -1;
2587 for (i = 0; i < nb_input_files; i++)
2588 if (input_files[i]->ctx->nb_chapters) {
2589 o->chapters_input_file = i;
2593 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2594 o->chapters_input_file);
2598 if (o->chapters_input_file >= 0)
2599 copy_chapters(input_files[o->chapters_input_file], of,
2600 !o->metadata_chapters_manual);
2602 /* copy global metadata by default */
2603 if (!o->metadata_global_manual && nb_input_files){
2604 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2605 AV_DICT_DONT_OVERWRITE);
2606 if(o->recording_time != INT64_MAX)
2607 av_dict_set(&oc->metadata, "duration", NULL, 0);
2608 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2610 if (!o->metadata_streams_manual)
2611 for (i = of->ost_index; i < nb_output_streams; i++) {
2613 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2615 ist = input_streams[output_streams[i]->source_index];
2616 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2617 if (!output_streams[i]->stream_copy) {
2618 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2622 /* process manually set programs */
2623 for (i = 0; i < o->nb_program; i++) {
2624 const char *p = o->program[i].u.str;
2629 const char *p2 = av_get_token(&p, ":");
2630 const char *to_dealloc = p2;
2637 key = av_get_token(&p2, "=");
2639 av_freep(&to_dealloc);
2645 if (!strcmp(key, "program_num"))
2646 progid = strtol(p2, NULL, 0);
2647 av_freep(&to_dealloc);
2651 program = av_new_program(oc, progid);
2653 p = o->program[i].u.str;
2655 const char *p2 = av_get_token(&p, ":");
2656 const char *to_dealloc = p2;
2662 key = av_get_token(&p2, "=");
2664 av_log(NULL, AV_LOG_FATAL,
2665 "No '=' character in program string %s.\n",
2673 if (!strcmp(key, "title")) {
2674 av_dict_set(&program->metadata, "title", p2, 0);
2675 } else if (!strcmp(key, "program_num")) {
2676 } else if (!strcmp(key, "st")) {
2677 int st_num = strtol(p2, NULL, 0);
2678 av_program_add_stream_index(oc, progid, st_num);
2680 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2683 av_freep(&to_dealloc);
2688 /* process manually set metadata */
2689 for (i = 0; i < o->nb_metadata; i++) {
2692 const char *stream_spec;
2693 int index = 0, j, ret = 0;
2695 val = strchr(o->metadata[i].u.str, '=');
2697 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2698 o->metadata[i].u.str);
2703 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2705 for (j = 0; j < oc->nb_streams; j++) {
2706 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2707 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2708 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2710 double theta = av_strtod(val, &tail);
2712 ost->rotate_overridden = 1;
2713 ost->rotate_override_value = theta;
2716 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2728 if (index < 0 || index >= oc->nb_chapters) {
2729 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2732 m = &oc->chapters[index]->metadata;
2735 if (index < 0 || index >= oc->nb_programs) {
2736 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2739 m = &oc->programs[index]->metadata;
2742 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2745 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2752 static int opt_target(void *optctx, const char *opt, const char *arg)
2754 OptionsContext *o = optctx;
2755 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2756 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2758 if (!strncmp(arg, "pal-", 4)) {
2761 } else if (!strncmp(arg, "ntsc-", 5)) {
2764 } else if (!strncmp(arg, "film-", 5)) {
2768 /* Try to determine PAL/NTSC by peeking in the input files */
2769 if (nb_input_files) {
2771 for (j = 0; j < nb_input_files; j++) {
2772 for (i = 0; i < input_files[j]->nb_streams; i++) {
2773 AVStream *st = input_files[j]->ctx->streams[i];
2774 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2776 fr = st->time_base.den * 1000 / st->time_base.num;
2780 } else if ((fr == 29970) || (fr == 23976)) {
2785 if (norm != UNKNOWN)
2789 if (norm != UNKNOWN)
2790 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2793 if (norm == UNKNOWN) {
2794 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2795 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2796 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2800 if (!strcmp(arg, "vcd")) {
2801 opt_video_codec(o, "c:v", "mpeg1video");
2802 opt_audio_codec(o, "c:a", "mp2");
2803 parse_option(o, "f", "vcd", options);
2805 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2806 parse_option(o, "r", frame_rates[norm], options);
2807 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2809 opt_default(NULL, "b:v", "1150000");
2810 opt_default(NULL, "maxrate:v", "1150000");
2811 opt_default(NULL, "minrate:v", "1150000");
2812 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2814 opt_default(NULL, "b:a", "224000");
2815 parse_option(o, "ar", "44100", options);
2816 parse_option(o, "ac", "2", options);
2818 opt_default(NULL, "packetsize", "2324");
2819 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2821 /* We have to offset the PTS, so that it is consistent with the SCR.
2822 SCR starts at 36000, but the first two packs contain only padding
2823 and the first pack from the other stream, respectively, may also have
2824 been written before.
2825 So the real data starts at SCR 36000+3*1200. */
2826 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2827 } else if (!strcmp(arg, "svcd")) {
2829 opt_video_codec(o, "c:v", "mpeg2video");
2830 opt_audio_codec(o, "c:a", "mp2");
2831 parse_option(o, "f", "svcd", options);
2833 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2834 parse_option(o, "r", frame_rates[norm], options);
2835 parse_option(o, "pix_fmt", "yuv420p", options);
2836 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2838 opt_default(NULL, "b:v", "2040000");
2839 opt_default(NULL, "maxrate:v", "2516000");
2840 opt_default(NULL, "minrate:v", "0"); // 1145000;
2841 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2842 opt_default(NULL, "scan_offset", "1");
2844 opt_default(NULL, "b:a", "224000");
2845 parse_option(o, "ar", "44100", options);
2847 opt_default(NULL, "packetsize", "2324");
2849 } else if (!strcmp(arg, "dvd")) {
2851 opt_video_codec(o, "c:v", "mpeg2video");
2852 opt_audio_codec(o, "c:a", "ac3");
2853 parse_option(o, "f", "dvd", options);
2855 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2856 parse_option(o, "r", frame_rates[norm], options);
2857 parse_option(o, "pix_fmt", "yuv420p", options);
2858 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2860 opt_default(NULL, "b:v", "6000000");
2861 opt_default(NULL, "maxrate:v", "9000000");
2862 opt_default(NULL, "minrate:v", "0"); // 1500000;
2863 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2865 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2866 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2868 opt_default(NULL, "b:a", "448000");
2869 parse_option(o, "ar", "48000", options);
2871 } else if (!strncmp(arg, "dv", 2)) {
2873 parse_option(o, "f", "dv", options);
2875 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2876 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2877 norm == PAL ? "yuv420p" : "yuv411p", options);
2878 parse_option(o, "r", frame_rates[norm], options);
2880 parse_option(o, "ar", "48000", options);
2881 parse_option(o, "ac", "2", options);
2884 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2885 return AVERROR(EINVAL);
2888 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2889 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2894 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2896 av_free (vstats_filename);
2897 vstats_filename = av_strdup (arg);
2901 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2904 time_t today2 = time(NULL);
2905 struct tm *today = localtime(&today2);
2907 if (!today) { // maybe tomorrow
2908 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2912 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2914 return opt_vstats_file(NULL, opt, filename);
2917 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2919 OptionsContext *o = optctx;
2920 return parse_option(o, "frames:v", arg, options);
2923 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2925 OptionsContext *o = optctx;
2926 return parse_option(o, "frames:a", arg, options);
2929 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2931 OptionsContext *o = optctx;
2932 return parse_option(o, "frames:d", arg, options);
2935 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2938 AVDictionary *cbak = codec_opts;
2939 AVDictionary *fbak = format_opts;
2943 ret = opt_default(NULL, opt, arg);
2945 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2946 av_dict_copy(&o->g->format_opts, format_opts, 0);
2947 av_dict_free(&codec_opts);
2948 av_dict_free(&format_opts);
2955 static int opt_preset(void *optctx, const char *opt, const char *arg)
2957 OptionsContext *o = optctx;
2959 char filename[1000], line[1000], tmp_line[1000];
2960 const char *codec_name = NULL;
2964 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2966 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2967 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2968 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2970 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2974 while (fgets(line, sizeof(line), f)) {
2975 char *key = tmp_line, *value, *endptr;
2977 if (strcspn(line, "#\n\r") == 0)
2979 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2980 if (!av_strtok(key, "=", &value) ||
2981 !av_strtok(value, "\r\n", &endptr)) {
2982 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2985 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2987 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2988 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2989 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2990 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2991 else if (opt_default_new(o, key, value) < 0) {
2992 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2993 filename, line, key, value);
3003 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3005 OptionsContext *o = optctx;
3006 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3007 int ret = parse_option(o, s, arg, options);
3012 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3014 OptionsContext *o = optctx;
3016 if(!strcmp(opt, "ab")){
3017 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3019 } else if(!strcmp(opt, "b")){
3020 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3021 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3024 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3028 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3030 OptionsContext *o = optctx;
3033 if(!strcmp(opt, "qscale")){
3034 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3035 return parse_option(o, "q:v", arg, options);
3037 s = av_asprintf("q%s", opt + 6);
3038 ret = parse_option(o, s, arg, options);
3043 static int opt_profile(void *optctx, const char *opt, const char *arg)
3045 OptionsContext *o = optctx;
3046 if(!strcmp(opt, "profile")){
3047 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3048 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3051 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3055 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3057 OptionsContext *o = optctx;
3058 return parse_option(o, "filter:v", arg, options);
3061 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3063 OptionsContext *o = optctx;
3064 return parse_option(o, "filter:a", arg, options);
3067 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3069 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3070 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3071 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3072 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3074 if (video_sync_method == VSYNC_AUTO)
3075 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3079 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3081 OptionsContext *o = optctx;
3082 char *tcr = av_asprintf("timecode=%s", arg);
3083 int ret = parse_option(o, "metadata:g", tcr, options);
3085 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3090 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3092 OptionsContext *o = optctx;
3093 char layout_str[32];
3096 int ret, channels, ac_str_size;
3099 layout = av_get_channel_layout(arg);
3101 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3102 return AVERROR(EINVAL);
3104 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3105 ret = opt_default_new(o, opt, layout_str);
3109 /* set 'ac' option based on channel layout */
3110 channels = av_get_channel_layout_nb_channels(layout);
3111 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3112 stream_str = strchr(opt, ':');
3113 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3114 ac_str = av_mallocz(ac_str_size);
3116 return AVERROR(ENOMEM);
3117 av_strlcpy(ac_str, "ac", 3);
3119 av_strlcat(ac_str, stream_str, ac_str_size);
3120 ret = parse_option(o, ac_str, layout_str, options);
3126 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3128 OptionsContext *o = optctx;
3129 return parse_option(o, "q:a", arg, options);
3132 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3134 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3135 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3136 return AVERROR(ENOMEM);
3137 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3138 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3139 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3140 return AVERROR(ENOMEM);
3142 input_stream_potentially_available = 1;
3147 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3149 uint8_t *graph_desc = read_file(arg);
3151 return AVERROR(EINVAL);
3153 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3154 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3155 return AVERROR(ENOMEM);
3156 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3157 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3159 input_stream_potentially_available = 1;
3164 void show_help_default(const char *opt, const char *arg)
3166 /* per-file options have at least one of those set */
3167 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3168 int show_advanced = 0, show_avoptions = 0;
3171 if (!strcmp(opt, "long"))
3173 else if (!strcmp(opt, "full"))
3174 show_advanced = show_avoptions = 1;
3176 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3181 printf("Getting help:\n"
3182 " -h -- print basic options\n"
3183 " -h long -- print more options\n"
3184 " -h full -- print all options (including all format and codec specific options, very long)\n"
3185 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3186 " See man %s for detailed description of the options.\n"
3187 "\n", program_name);
3189 show_help_options(options, "Print help / information / capabilities:",
3192 show_help_options(options, "Global options (affect whole program "
3193 "instead of just one file:",
3194 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3196 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3197 per_file | OPT_EXIT, 0);
3199 show_help_options(options, "Per-file main options:", 0,
3200 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3201 OPT_EXIT, per_file);
3203 show_help_options(options, "Advanced per-file options:",
3204 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3206 show_help_options(options, "Video options:",
3207 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3209 show_help_options(options, "Advanced Video options:",
3210 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3212 show_help_options(options, "Audio options:",
3213 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3215 show_help_options(options, "Advanced Audio options:",
3216 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3217 show_help_options(options, "Subtitle options:",
3218 OPT_SUBTITLE, 0, 0);
3221 if (show_avoptions) {
3222 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3223 show_help_children(avcodec_get_class(), flags);
3224 show_help_children(avformat_get_class(), flags);
3226 show_help_children(sws_get_class(), flags);
3228 #if CONFIG_SWRESAMPLE
3229 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3231 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3232 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3236 void show_usage(void)
3238 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3239 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3240 av_log(NULL, AV_LOG_INFO, "\n");
3248 static const OptionGroupDef groups[] = {
3249 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3250 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3253 static int open_files(OptionGroupList *l, const char *inout,
3254 int (*open_file)(OptionsContext*, const char*))
3258 for (i = 0; i < l->nb_groups; i++) {
3259 OptionGroup *g = &l->groups[i];
3265 ret = parse_optgroup(&o, g);
3267 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3268 "%s.\n", inout, g->arg);
3272 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3273 ret = open_file(&o, g->arg);
3276 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3280 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3286 int ffmpeg_parse_options(int argc, char **argv)
3288 OptionParseContext octx;
3292 memset(&octx, 0, sizeof(octx));
3294 /* split the commandline into an internal representation */
3295 ret = split_commandline(&octx, argc, argv, options, groups,
3296 FF_ARRAY_ELEMS(groups));
3298 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3302 /* apply global options */
3303 ret = parse_optgroup(NULL, &octx.global_opts);
3305 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3309 /* configure terminal and setup signal handlers */
3312 /* open input files */
3313 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3315 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3319 /* create the complex filtergraphs */
3320 ret = init_complex_filters();
3322 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3326 /* open output files */
3327 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3329 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3333 check_filter_outputs();
3336 uninit_parse_context(&octx);
3338 av_strerror(ret, error, sizeof(error));
3339 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3344 static int opt_progress(void *optctx, const char *opt, const char *arg)
3346 AVIOContext *avio = NULL;
3349 if (!strcmp(arg, "-"))
3351 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3353 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3354 arg, av_err2str(ret));
3357 progress_avio = avio;
3361 #define OFFSET(x) offsetof(OptionsContext, x)
3362 const OptionDef options[] = {
3364 CMDUTILS_COMMON_OPTIONS
3365 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3366 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3367 "force format", "fmt" },
3368 { "y", OPT_BOOL, { &file_overwrite },
3369 "overwrite output files" },
3370 { "n", OPT_BOOL, { &no_file_overwrite },
3371 "never overwrite output files" },
3372 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3373 "Ignore unknown stream types" },
3374 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3375 "Copy unknown stream types" },
3376 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3377 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3378 "codec name", "codec" },
3379 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3380 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3381 "codec name", "codec" },
3382 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3383 OPT_OUTPUT, { .off = OFFSET(presets) },
3384 "preset name", "preset" },
3385 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3386 OPT_OUTPUT, { .func_arg = opt_map },
3387 "set input stream mapping",
3388 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3389 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3390 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3391 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3392 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3393 "set metadata information of outfile from infile",
3394 "outfile[,metadata]:infile[,metadata]" },
3395 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3396 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3397 "set chapters mapping", "input_file_index" },
3398 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3399 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3400 "record or transcode \"duration\" seconds of audio/video",
3402 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3403 "record or transcode stop time", "time_stop" },
3404 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3405 "set the limit file size in bytes", "limit_size" },
3406 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3407 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3408 "set the start time offset", "time_off" },
3409 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3410 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3411 "set the start time offset relative to EOF", "time_off" },
3412 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3413 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3414 "enable/disable seeking by timestamp with -ss" },
3415 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3416 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3417 "enable/disable accurate seeking with -ss" },
3418 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3419 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3420 "set the input ts offset", "time_off" },
3421 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3422 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3423 "set the input ts scale", "scale" },
3424 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3425 "set the recording timestamp ('now' to set the current time)", "time" },
3426 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3427 "add metadata", "string=string" },
3428 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3429 "add program with specified streams", "title=string:st=number..." },
3430 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3431 OPT_OUTPUT, { .func_arg = opt_data_frames },
3432 "set the number of data frames to output", "number" },
3433 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3434 "add timings for benchmarking" },
3435 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3436 "add timings for each task" },
3437 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3438 "write program-readable progress information", "url" },
3439 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3440 "enable or disable interaction on standard input" },
3441 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3442 "set max runtime in seconds", "limit" },
3443 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3444 "dump each input packet" },
3445 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3446 "when dumping packets, also dump the payload" },
3447 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3448 OPT_INPUT, { .off = OFFSET(rate_emu) },
3449 "read input at native frame rate", "" },
3450 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3451 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3452 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3453 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3454 "video sync method", "" },
3455 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3456 "frame drop threshold", "" },
3457 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3458 "audio sync method", "" },
3459 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3460 "audio drift threshold", "threshold" },
3461 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3462 "copy timestamps" },
3463 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3464 "shift input timestamps to start at 0 when using copyts" },
3465 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3466 "copy input stream time base when stream copying", "mode" },
3467 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3468 OPT_OUTPUT, { .off = OFFSET(shortest) },
3469 "finish encoding within shortest input" },
3470 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3471 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3473 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3474 OPT_OUTPUT, { .off = OFFSET(apad) },
3476 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3477 "timestamp discontinuity delta threshold", "threshold" },
3478 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3479 "timestamp error delta threshold", "threshold" },
3480 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3481 "exit on error", "error" },
3482 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3483 "abort on the specified condition flags", "flags" },
3484 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3485 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3486 "copy initial non-keyframes" },
3487 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3488 "copy or discard frames before start time" },
3489 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3490 "set the number of frames to output", "number" },
3491 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3492 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3493 "force codec tag/fourcc", "fourcc/tag" },
3494 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3495 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3496 "use fixed quality scale (VBR)", "q" },
3497 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3498 OPT_OUTPUT, { .func_arg = opt_qscale },
3499 "use fixed quality scale (VBR)", "q" },
3500 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3501 "set profile", "profile" },
3502 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3503 "set stream filtergraph", "filter_graph" },
3504 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3505 "number of non-complex filter threads" },
3506 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3507 "read stream filtergraph description from a file", "filename" },
3508 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3509 "reinit filtergraph on input parameter changes", "" },
3510 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3511 "create a complex filtergraph", "graph_description" },
3512 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3513 "number of threads for -filter_complex" },
3514 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3515 "create a complex filtergraph", "graph_description" },
3516 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3517 "read complex filtergraph description from a file", "filename" },
3518 { "stats", OPT_BOOL, { &print_stats },
3519 "print progress report during encoding", },
3520 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3521 OPT_OUTPUT, { .func_arg = opt_attach },
3522 "add an attachment to the output file", "filename" },
3523 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3524 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3525 "extract an attachment into a file", "filename" },
3526 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3527 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3528 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3529 "print timestamp debugging info" },
3530 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3531 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3532 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3533 OPT_INPUT, { .off = OFFSET(discard) },
3535 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3536 OPT_OUTPUT, { .off = OFFSET(disposition) },
3537 "disposition", "" },
3538 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3539 { .off = OFFSET(thread_queue_size) },
3540 "set the maximum number of queued packets from the demuxer" },
3541 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3542 "read and decode the streams to fill missing information with heuristics" },
3545 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3546 "set the number of video frames to output", "number" },
3547 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3548 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3549 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3550 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3551 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3552 "set frame size (WxH or abbreviation)", "size" },
3553 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3554 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3555 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3556 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3557 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3558 "set pixel format", "format" },
3559 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3560 "set the number of bits per raw sample", "number" },
3561 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3562 "deprecated use -g 1" },
3563 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3565 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3566 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3567 "rate control override for specific intervals", "override" },
3568 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3569 OPT_OUTPUT, { .func_arg = opt_video_codec },
3570 "force video codec ('copy' to copy stream)", "codec" },
3571 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3573 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3575 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3576 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3577 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3578 "select the pass number (1 to 3)", "n" },
3579 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3580 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3581 "select two pass log file name prefix", "prefix" },
3582 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3583 "this option is deprecated, use the yadif filter instead" },
3584 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3585 "calculate PSNR of compressed frames" },
3586 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3587 "dump video coding statistics to file" },
3588 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3589 "dump video coding statistics to file", "file" },
3590 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3591 "Version of the vstats format to use."},
3592 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3593 "set video filters", "filter_graph" },
3594 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3595 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3596 "specify intra matrix coeffs", "matrix" },
3597 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3598 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3599 "specify inter matrix coeffs", "matrix" },
3600 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3601 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3602 "specify intra matrix coeffs", "matrix" },
3603 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3604 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3605 "top=1/bottom=0/auto=-1 field first", "" },
3606 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3607 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3608 "force video tag/fourcc", "fourcc/tag" },
3609 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3610 "show QP histogram" },
3611 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3612 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3613 "force the selected framerate, disable the best supported framerate selection" },
3614 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3615 OPT_OUTPUT, { .func_arg = opt_streamid },
3616 "set the value of an outfile streamid", "streamIndex:value" },
3617 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3618 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3619 "force key frames at specified timestamps", "timestamps" },
3620 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3621 "audio bitrate (please use -b:a)", "bitrate" },
3622 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3623 "video bitrate (please use -b:v)", "bitrate" },
3624 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3625 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3626 "use HW accelerated decoding", "hwaccel name" },
3627 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3628 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3629 "select a device for HW acceleration", "devicename" },
3630 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3631 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3632 "select output format used with HW accelerated decoding", "format" },
3633 #if CONFIG_VIDEOTOOLBOX
3634 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3636 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3637 "show available HW acceleration methods" },
3638 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3639 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3640 "automatically insert correct rotate filters" },
3643 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3644 "set the number of audio frames to output", "number" },
3645 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3646 "set audio quality (codec-specific)", "quality", },
3647 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3648 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3649 "set audio sampling rate (in Hz)", "rate" },
3650 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3651 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3652 "set number of audio channels", "channels" },
3653 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3655 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3656 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3657 "force audio codec ('copy' to copy stream)", "codec" },
3658 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3659 OPT_OUTPUT, { .func_arg = opt_old2new },
3660 "force audio tag/fourcc", "fourcc/tag" },
3661 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3662 "change audio volume (256=normal)" , "volume" },
3663 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3664 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3665 "set sample format", "format" },
3666 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3667 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3668 "set channel layout", "layout" },
3669 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3670 "set audio filters", "filter_graph" },
3671 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3672 "set the maximum number of channels to try to guess the channel layout" },
3674 /* subtitle options */
3675 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3676 "disable subtitle" },
3677 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3678 "force subtitle codec ('copy' to copy stream)", "codec" },
3679 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3680 , "force subtitle tag/fourcc", "fourcc/tag" },
3681 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3682 "fix subtitles duration" },
3683 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3684 "set canvas size (WxH or abbreviation)", "size" },
3687 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3688 "deprecated, use -channel", "channel" },
3689 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3690 "deprecated, use -standard", "standard" },
3691 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3694 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3695 "set the maximum demux-decode delay", "seconds" },
3696 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3697 "set the initial demux-decode delay", "seconds" },
3698 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3699 "specify a file in which to print sdp information", "file" },
3701 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3702 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3703 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3704 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3705 "two special values are defined - "
3706 "0 = use frame rate (video) or sample rate (audio),"
3707 "-1 = match source time base", "ratio" },
3709 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3710 "A comma-separated list of bitstream filters", "bitstream_filters" },
3711 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3712 "deprecated", "audio bitstream_filters" },
3713 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3714 "deprecated", "video bitstream_filters" },
3716 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3717 "set the audio options to the indicated preset", "preset" },
3718 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3719 "set the video options to the indicated preset", "preset" },
3720 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3721 "set the subtitle options to the indicated preset", "preset" },
3722 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3723 "set options from indicated preset file", "filename" },
3725 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3726 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3728 /* data codec support */
3729 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3730 "force data codec ('copy' to copy stream)", "codec" },
3731 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3735 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3736 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3740 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3741 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3744 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3745 "initialise hardware device", "args" },
3746 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3747 "set hardware device used when filtering", "device" },