2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
71 AV_HWDEVICE_TYPE_VDPAU },
74 { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
75 AV_HWDEVICE_TYPE_D3D11VA },
78 { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
79 AV_HWDEVICE_TYPE_DXVA2 },
82 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA,
83 AV_HWDEVICE_TYPE_NONE },
85 #if CONFIG_VIDEOTOOLBOX
86 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX,
87 AV_HWDEVICE_TYPE_NONE },
90 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV,
91 AV_HWDEVICE_TYPE_NONE },
94 { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
95 AV_HWDEVICE_TYPE_VAAPI },
98 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
99 AV_HWDEVICE_TYPE_NONE },
103 AVBufferRef *hw_device_ctx;
104 HWDevice *filter_hw_device;
106 char *vstats_filename;
109 float audio_drift_threshold = 0.1;
110 float dts_delta_threshold = 10;
111 float dts_error_threshold = 3600*30;
113 int audio_volume = 256;
114 int audio_sync_method = 0;
115 int video_sync_method = VSYNC_AUTO;
116 float frame_drop_threshold = 0;
117 int do_deinterlace = 0;
118 int do_benchmark = 0;
119 int do_benchmark_all = 0;
123 int start_at_zero = 0;
126 int exit_on_error = 0;
127 int abort_on_flags = 0;
128 int print_stats = -1;
130 int stdin_interaction = 1;
131 int frame_bits_per_raw_sample = 0;
132 float max_error_rate = 2.0/3;
133 int filter_nbthreads = 0;
134 int filter_complex_nbthreads = 0;
135 int vstats_version = 2;
138 static int intra_only = 0;
139 static int file_overwrite = 0;
140 static int no_file_overwrite = 0;
141 static int do_psnr = 0;
142 static int input_sync;
143 static int override_ffserver = 0;
144 static int input_stream_potentially_available = 0;
145 static int ignore_unknown_streams = 0;
146 static int copy_unknown_streams = 0;
147 static int find_stream_info = 1;
149 static void uninit_options(OptionsContext *o)
151 const OptionDef *po = options;
154 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
156 void *dst = (uint8_t*)o + po->u.off;
158 if (po->flags & OPT_SPEC) {
159 SpecifierOpt **so = dst;
160 int i, *count = (int*)(so + 1);
161 for (i = 0; i < *count; i++) {
162 av_freep(&(*so)[i].specifier);
163 if (po->flags & OPT_STRING)
164 av_freep(&(*so)[i].u.str);
168 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
173 for (i = 0; i < o->nb_stream_maps; i++)
174 av_freep(&o->stream_maps[i].linklabel);
175 av_freep(&o->stream_maps);
176 av_freep(&o->audio_channel_maps);
177 av_freep(&o->streamid_map);
178 av_freep(&o->attachments);
181 static void init_options(OptionsContext *o)
183 memset(o, 0, sizeof(*o));
185 o->stop_time = INT64_MAX;
186 o->mux_max_delay = 0.7;
187 o->start_time = AV_NOPTS_VALUE;
188 o->start_time_eof = AV_NOPTS_VALUE;
189 o->recording_time = INT64_MAX;
190 o->limit_filesize = UINT64_MAX;
191 o->chapters_input_file = INT_MAX;
192 o->accurate_seek = 1;
195 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
199 printf("Hardware acceleration methods:\n");
200 for (i = 0; hwaccels[i].name; i++) {
201 printf("%s\n", hwaccels[i].name);
207 /* return a copy of the input with the stream specifiers removed from the keys */
208 static AVDictionary *strip_specifiers(AVDictionary *dict)
210 AVDictionaryEntry *e = NULL;
211 AVDictionary *ret = NULL;
213 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
214 char *p = strchr(e->key, ':');
218 av_dict_set(&ret, e->key, e->value, 0);
225 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
227 static const AVOption opts[] = {
228 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
229 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
232 static const AVClass class = {
234 .item_name = av_default_item_name,
236 .version = LIBAVUTIL_VERSION_INT,
238 const AVClass *pclass = &class;
240 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
243 static int opt_sameq(void *optctx, const char *opt, const char *arg)
245 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
246 "If you are looking for an option to preserve the quality (which is not "
247 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
249 return AVERROR(EINVAL);
252 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
254 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
255 return opt_default(optctx, "channel", arg);
258 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
260 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
261 return opt_default(optctx, "standard", arg);
264 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
266 OptionsContext *o = optctx;
267 return parse_option(o, "codec:a", arg, options);
270 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
272 OptionsContext *o = optctx;
273 return parse_option(o, "codec:v", arg, options);
276 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
278 OptionsContext *o = optctx;
279 return parse_option(o, "codec:s", arg, options);
282 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
284 OptionsContext *o = optctx;
285 return parse_option(o, "codec:d", arg, options);
288 static int opt_map(void *optctx, const char *opt, const char *arg)
290 OptionsContext *o = optctx;
292 int i, negative = 0, file_idx;
293 int sync_file_idx = -1, sync_stream_idx = 0;
302 map = av_strdup(arg);
304 return AVERROR(ENOMEM);
306 /* parse sync stream first, just pick first matching stream */
307 if (sync = strchr(map, ',')) {
309 sync_file_idx = strtol(sync + 1, &sync, 0);
310 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
311 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
316 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
317 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
318 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
322 if (i == input_files[sync_file_idx]->nb_streams) {
323 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
324 "match any streams.\n", arg);
331 /* this mapping refers to lavfi output */
332 const char *c = map + 1;
333 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
334 m = &o->stream_maps[o->nb_stream_maps - 1];
335 m->linklabel = av_get_token(&c, "]");
337 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
341 if (allow_unused = strchr(map, '?'))
343 file_idx = strtol(map, &p, 0);
344 if (file_idx >= nb_input_files || file_idx < 0) {
345 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
349 /* disable some already defined maps */
350 for (i = 0; i < o->nb_stream_maps; i++) {
351 m = &o->stream_maps[i];
352 if (file_idx == m->file_index &&
353 check_stream_specifier(input_files[m->file_index]->ctx,
354 input_files[m->file_index]->ctx->streams[m->stream_index],
355 *p == ':' ? p + 1 : p) > 0)
359 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
360 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
361 *p == ':' ? p + 1 : p) <= 0)
363 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
364 m = &o->stream_maps[o->nb_stream_maps - 1];
366 m->file_index = file_idx;
369 if (sync_file_idx >= 0) {
370 m->sync_file_index = sync_file_idx;
371 m->sync_stream_index = sync_stream_idx;
373 m->sync_file_index = file_idx;
374 m->sync_stream_index = i;
381 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
383 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
384 "To ignore this, add a trailing '?' to the map.\n", arg);
393 static int opt_attach(void *optctx, const char *opt, const char *arg)
395 OptionsContext *o = optctx;
396 GROW_ARRAY(o->attachments, o->nb_attachments);
397 o->attachments[o->nb_attachments - 1] = arg;
401 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
403 OptionsContext *o = optctx;
409 mapchan = av_strdup(arg);
411 return AVERROR(ENOMEM);
413 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
414 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
416 /* muted channel syntax */
417 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
418 if ((n == 1 || n == 3) && m->channel_idx == -1) {
419 m->file_idx = m->stream_idx = -1;
421 m->ofile_idx = m->ostream_idx = -1;
427 n = sscanf(arg, "%d.%d.%d:%d.%d",
428 &m->file_idx, &m->stream_idx, &m->channel_idx,
429 &m->ofile_idx, &m->ostream_idx);
431 if (n != 3 && n != 5) {
432 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
433 "[file.stream.channel|-1][:syncfile:syncstream]\n");
437 if (n != 5) // only file.stream.channel specified
438 m->ofile_idx = m->ostream_idx = -1;
441 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
442 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
446 if (m->stream_idx < 0 ||
447 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
448 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
449 m->file_idx, m->stream_idx);
452 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
453 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
454 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
455 m->file_idx, m->stream_idx);
458 /* allow trailing ? to map_channel */
459 if (allow_unused = strchr(mapchan, '?'))
461 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
463 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
464 m->file_idx, m->stream_idx, m->channel_idx);
466 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
467 "To ignore this, add a trailing '?' to the map_channel.\n",
468 m->file_idx, m->stream_idx, m->channel_idx);
477 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
479 av_free(sdp_filename);
480 sdp_filename = av_strdup(arg);
485 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
488 const char *prefix = "vaapi:";
491 tmp = av_asprintf("%s%s", prefix, arg);
493 return AVERROR(ENOMEM);
494 err = hw_device_init_from_string(tmp, &dev);
498 hw_device_ctx = av_buffer_ref(dev->device_ref);
500 return AVERROR(ENOMEM);
505 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
507 if (!strcmp(arg, "list")) {
508 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
509 printf("Supported hardware device types:\n");
510 while ((type = av_hwdevice_iterate_types(type)) !=
511 AV_HWDEVICE_TYPE_NONE)
512 printf("%s\n", av_hwdevice_get_type_name(type));
516 return hw_device_init_from_string(arg, NULL);
520 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
522 if (filter_hw_device) {
523 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
524 return AVERROR(EINVAL);
526 filter_hw_device = hw_device_get_by_name(arg);
527 if (!filter_hw_device) {
528 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
529 return AVERROR(EINVAL);
535 * Parse a metadata specifier passed as 'arg' parameter.
536 * @param arg metadata string to parse
537 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
538 * @param index for type c/p, chapter/program index is written here
539 * @param stream_spec for type s, the stream specifier is written here
541 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
549 if (*(++arg) && *arg != ':') {
550 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
553 *stream_spec = *arg == ':' ? arg + 1 : "";
558 *index = strtol(++arg, NULL, 0);
561 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
568 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
570 AVDictionary **meta_in = NULL;
571 AVDictionary **meta_out = NULL;
573 char type_in, type_out;
574 const char *istream_spec = NULL, *ostream_spec = NULL;
575 int idx_in = 0, idx_out = 0;
577 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
578 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
581 if (type_out == 'g' || !*outspec)
582 o->metadata_global_manual = 1;
583 if (type_out == 's' || !*outspec)
584 o->metadata_streams_manual = 1;
585 if (type_out == 'c' || !*outspec)
586 o->metadata_chapters_manual = 1;
590 if (type_in == 'g' || type_out == 'g')
591 o->metadata_global_manual = 1;
592 if (type_in == 's' || type_out == 's')
593 o->metadata_streams_manual = 1;
594 if (type_in == 'c' || type_out == 'c')
595 o->metadata_chapters_manual = 1;
597 /* ic is NULL when just disabling automatic mappings */
601 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
602 if ((index) < 0 || (index) >= (nb_elems)) {\
603 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
608 #define SET_DICT(type, meta, context, index)\
611 meta = &context->metadata;\
614 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
615 meta = &context->chapters[index]->metadata;\
618 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
619 meta = &context->programs[index]->metadata;\
622 break; /* handled separately below */ \
623 default: av_assert0(0);\
626 SET_DICT(type_in, meta_in, ic, idx_in);
627 SET_DICT(type_out, meta_out, oc, idx_out);
629 /* for input streams choose first matching stream */
630 if (type_in == 's') {
631 for (i = 0; i < ic->nb_streams; i++) {
632 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
633 meta_in = &ic->streams[i]->metadata;
639 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
644 if (type_out == 's') {
645 for (i = 0; i < oc->nb_streams; i++) {
646 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
647 meta_out = &oc->streams[i]->metadata;
648 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
653 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
658 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
660 OptionsContext *o = optctx;
662 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
663 struct tm time = *gmtime((time_t*)&recording_timestamp);
664 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
666 parse_option(o, "metadata", buf, options);
668 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
669 "tag instead.\n", opt);
673 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
675 const AVCodecDescriptor *desc;
676 const char *codec_string = encoder ? "encoder" : "decoder";
680 avcodec_find_encoder_by_name(name) :
681 avcodec_find_decoder_by_name(name);
683 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
684 codec = encoder ? avcodec_find_encoder(desc->id) :
685 avcodec_find_decoder(desc->id);
687 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
688 codec_string, codec->name, desc->name);
692 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
695 if (codec->type != type) {
696 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
702 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
704 char *codec_name = NULL;
706 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
708 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
709 st->codecpar->codec_id = codec->id;
712 return avcodec_find_decoder(st->codecpar->codec_id);
715 /* Add all the streams from the given input file to the global
716 * list of input streams. */
717 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
721 for (i = 0; i < ic->nb_streams; i++) {
722 AVStream *st = ic->streams[i];
723 AVCodecParameters *par = st->codecpar;
724 InputStream *ist = av_mallocz(sizeof(*ist));
725 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
726 char *hwaccel_output_format = NULL;
727 char *codec_tag = NULL;
729 char *discard_str = NULL;
730 const AVClass *cc = avcodec_get_class();
731 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
736 GROW_ARRAY(input_streams, nb_input_streams);
737 input_streams[nb_input_streams - 1] = ist;
740 ist->file_index = nb_input_files;
742 st->discard = AVDISCARD_ALL;
744 ist->min_pts = INT64_MAX;
745 ist->max_pts = INT64_MIN;
748 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
751 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
753 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
755 uint32_t tag = strtol(codec_tag, &next, 0);
757 tag = AV_RL32(codec_tag);
758 st->codecpar->codec_tag = tag;
761 ist->dec = choose_decoder(o, ic, st);
762 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
764 ist->reinit_filters = -1;
765 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
767 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
768 ist->user_set_discard = AVDISCARD_NONE;
769 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
770 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
775 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
777 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
779 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
783 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
785 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
789 switch (par->codec_type) {
790 case AVMEDIA_TYPE_VIDEO:
792 ist->dec = avcodec_find_decoder(par->codec_id);
794 if (av_codec_get_lowres(st->codec)) {
795 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
796 ist->dec_ctx->width = st->codec->width;
797 ist->dec_ctx->height = st->codec->height;
798 ist->dec_ctx->coded_width = st->codec->coded_width;
799 ist->dec_ctx->coded_height = st->codec->coded_height;
801 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
806 // avformat_find_stream_info() doesn't set this for us anymore.
807 ist->dec_ctx->framerate = st->avg_frame_rate;
809 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
810 if (framerate && av_parse_video_rate(&ist->framerate,
812 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
817 ist->top_field_first = -1;
818 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
820 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
822 if (!strcmp(hwaccel, "none"))
823 ist->hwaccel_id = HWACCEL_NONE;
824 else if (!strcmp(hwaccel, "auto"))
825 ist->hwaccel_id = HWACCEL_AUTO;
828 for (i = 0; hwaccels[i].name; i++) {
829 if (!strcmp(hwaccels[i].name, hwaccel)) {
830 ist->hwaccel_id = hwaccels[i].id;
835 if (!ist->hwaccel_id) {
836 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
838 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
839 for (i = 0; hwaccels[i].name; i++)
840 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
841 av_log(NULL, AV_LOG_FATAL, "\n");
847 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
848 if (hwaccel_device) {
849 ist->hwaccel_device = av_strdup(hwaccel_device);
850 if (!ist->hwaccel_device)
854 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
855 hwaccel_output_format, ic, st);
856 if (hwaccel_output_format) {
857 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
858 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
859 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
860 "format: %s", hwaccel_output_format);
863 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
866 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
869 case AVMEDIA_TYPE_AUDIO:
870 ist->guess_layout_max = INT_MAX;
871 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
872 guess_input_channel_layout(ist);
874 case AVMEDIA_TYPE_DATA:
875 case AVMEDIA_TYPE_SUBTITLE: {
876 char *canvas_size = NULL;
878 ist->dec = avcodec_find_decoder(par->codec_id);
879 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
880 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
882 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
883 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
888 case AVMEDIA_TYPE_ATTACHMENT:
889 case AVMEDIA_TYPE_UNKNOWN:
895 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
897 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
903 static void assert_file_overwrite(const char *filename)
905 if (file_overwrite && no_file_overwrite) {
906 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
910 if (!file_overwrite) {
911 const char *proto_name = avio_find_protocol_name(filename);
912 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
913 if (stdin_interaction && !no_file_overwrite) {
914 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
917 signal(SIGINT, SIG_DFL);
919 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
925 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
932 static void dump_attachment(AVStream *st, const char *filename)
935 AVIOContext *out = NULL;
936 AVDictionaryEntry *e;
938 if (!st->codecpar->extradata_size) {
939 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
940 nb_input_files - 1, st->index);
943 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
946 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
947 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
951 assert_file_overwrite(filename);
953 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
954 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
959 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
964 static int open_input_file(OptionsContext *o, const char *filename)
968 AVInputFormat *file_iformat = NULL;
971 AVDictionary *unused_opts = NULL;
972 AVDictionaryEntry *e = NULL;
973 char * video_codec_name = NULL;
974 char * audio_codec_name = NULL;
975 char *subtitle_codec_name = NULL;
976 char * data_codec_name = NULL;
977 int scan_all_pmts_set = 0;
980 if (!(file_iformat = av_find_input_format(o->format))) {
981 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
986 if (!strcmp(filename, "-"))
989 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
990 strcmp(filename, "/dev/stdin");
992 /* get default parameters from command line */
993 ic = avformat_alloc_context();
995 print_error(filename, AVERROR(ENOMEM));
998 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
999 if (o->nb_audio_sample_rate) {
1000 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1002 if (o->nb_audio_channels) {
1003 /* because we set audio_channels based on both the "ac" and
1004 * "channel_layout" options, we need to check that the specified
1005 * demuxer actually has the "channels" option before setting it */
1006 if (file_iformat && file_iformat->priv_class &&
1007 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1008 AV_OPT_SEARCH_FAKE_OBJ)) {
1009 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1012 if (o->nb_frame_rates) {
1013 /* set the format-level framerate option;
1014 * this is important for video grabbers, e.g. x11 */
1015 if (file_iformat && file_iformat->priv_class &&
1016 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1017 AV_OPT_SEARCH_FAKE_OBJ)) {
1018 av_dict_set(&o->g->format_opts, "framerate",
1019 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1022 if (o->nb_frame_sizes) {
1023 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1025 if (o->nb_frame_pix_fmts)
1026 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1028 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1029 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1030 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1031 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1033 ic->video_codec_id = video_codec_name ?
1034 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
1035 ic->audio_codec_id = audio_codec_name ?
1036 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
1037 ic->subtitle_codec_id= subtitle_codec_name ?
1038 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
1039 ic->data_codec_id = data_codec_name ?
1040 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
1042 if (video_codec_name)
1043 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
1044 if (audio_codec_name)
1045 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
1046 if (subtitle_codec_name)
1047 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
1048 if (data_codec_name)
1049 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
1051 ic->flags |= AVFMT_FLAG_NONBLOCK;
1052 ic->interrupt_callback = int_cb;
1054 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1055 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1056 scan_all_pmts_set = 1;
1058 /* open the input file with generic avformat function */
1059 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1061 print_error(filename, err);
1062 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1063 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1066 if (scan_all_pmts_set)
1067 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1068 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1069 assert_avoptions(o->g->format_opts);
1071 /* apply forced codec ids */
1072 for (i = 0; i < ic->nb_streams; i++)
1073 choose_decoder(o, ic, ic->streams[i]);
1075 if (find_stream_info) {
1076 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1077 int orig_nb_streams = ic->nb_streams;
1079 /* If not enough info to get the stream parameters, we decode the
1080 first frames to get it. (used in mpeg case for example) */
1081 ret = avformat_find_stream_info(ic, opts);
1083 for (i = 0; i < orig_nb_streams; i++)
1084 av_dict_free(&opts[i]);
1088 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1089 if (ic->nb_streams == 0) {
1090 avformat_close_input(&ic);
1096 if (o->start_time_eof != AV_NOPTS_VALUE) {
1097 if (ic->duration>0) {
1098 o->start_time = o->start_time_eof + ic->duration;
1100 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1102 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1103 /* add the stream start time */
1104 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1105 timestamp += ic->start_time;
1107 /* if seeking requested, we execute it */
1108 if (o->start_time != AV_NOPTS_VALUE) {
1109 int64_t seek_timestamp = timestamp;
1111 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1112 int dts_heuristic = 0;
1113 for (i=0; i<ic->nb_streams; i++) {
1114 const AVCodecParameters *par = ic->streams[i]->codecpar;
1115 if (par->video_delay)
1118 if (dts_heuristic) {
1119 seek_timestamp -= 3*AV_TIME_BASE / 23;
1122 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1124 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1125 filename, (double)timestamp / AV_TIME_BASE);
1129 /* update the current parameters so that they match the one of the input stream */
1130 add_input_streams(o, ic);
1132 /* dump the file content */
1133 av_dump_format(ic, nb_input_files, filename, 0);
1135 GROW_ARRAY(input_files, nb_input_files);
1136 f = av_mallocz(sizeof(*f));
1139 input_files[nb_input_files - 1] = f;
1142 f->ist_index = nb_input_streams - ic->nb_streams;
1143 f->start_time = o->start_time;
1144 f->recording_time = o->recording_time;
1145 f->input_ts_offset = o->input_ts_offset;
1146 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1147 f->nb_streams = ic->nb_streams;
1148 f->rate_emu = o->rate_emu;
1149 f->accurate_seek = o->accurate_seek;
1152 f->time_base = (AVRational){ 1, 1 };
1154 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1157 /* check if all codec options have been used */
1158 unused_opts = strip_specifiers(o->g->codec_opts);
1159 for (i = f->ist_index; i < nb_input_streams; i++) {
1161 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1162 AV_DICT_IGNORE_SUFFIX)))
1163 av_dict_set(&unused_opts, e->key, NULL, 0);
1167 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1168 const AVClass *class = avcodec_get_class();
1169 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1170 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1171 const AVClass *fclass = avformat_get_class();
1172 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1173 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1174 if (!option || foption)
1178 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1179 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1180 "input file #%d (%s) is not a decoding option.\n", e->key,
1181 option->help ? option->help : "", nb_input_files - 1,
1186 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1187 "input file #%d (%s) has not been used for any stream. The most "
1188 "likely reason is either wrong type (e.g. a video option with "
1189 "no video streams) or that it is a private option of some decoder "
1190 "which was not actually used for any stream.\n", e->key,
1191 option->help ? option->help : "", nb_input_files - 1, filename);
1193 av_dict_free(&unused_opts);
1195 for (i = 0; i < o->nb_dump_attachment; i++) {
1198 for (j = 0; j < ic->nb_streams; j++) {
1199 AVStream *st = ic->streams[j];
1201 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1202 dump_attachment(st, o->dump_attachment[i].u.str);
1206 input_stream_potentially_available = 1;
1211 static uint8_t *get_line(AVIOContext *s)
1217 if (avio_open_dyn_buf(&line) < 0) {
1218 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1222 while ((c = avio_r8(s)) && c != '\n')
1225 avio_close_dyn_buf(line, &buf);
1230 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1233 char filename[1000];
1234 const char *base[3] = { getenv("AVCONV_DATADIR"),
1239 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1243 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1244 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1245 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1248 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1249 i != 1 ? "" : "/.avconv", preset_name);
1250 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1256 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1258 enum AVMediaType type = ost->st->codecpar->codec_type;
1259 char *codec_name = NULL;
1261 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1262 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1264 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1265 NULL, ost->st->codecpar->codec_type);
1266 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1268 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1269 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1270 "probably disabled. Please choose an encoder manually.\n",
1271 ost->file_index, ost->index, s->oformat->name,
1272 avcodec_get_name(ost->st->codecpar->codec_id));
1273 return AVERROR_ENCODER_NOT_FOUND;
1275 } else if (!strcmp(codec_name, "copy"))
1276 ost->stream_copy = 1;
1278 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1279 ost->st->codecpar->codec_id = ost->enc->id;
1281 ost->encoding_needed = !ost->stream_copy;
1283 /* no encoding supported for other media types */
1284 ost->stream_copy = 1;
1285 ost->encoding_needed = 0;
1291 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1294 AVStream *st = avformat_new_stream(oc, NULL);
1295 int idx = oc->nb_streams - 1, ret = 0;
1296 const char *bsfs = NULL, *time_base = NULL;
1297 char *next, *codec_tag = NULL;
1302 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1306 if (oc->nb_streams - 1 < o->nb_streamid_map)
1307 st->id = o->streamid_map[oc->nb_streams - 1];
1309 GROW_ARRAY(output_streams, nb_output_streams);
1310 if (!(ost = av_mallocz(sizeof(*ost))))
1312 output_streams[nb_output_streams - 1] = ost;
1314 ost->file_index = nb_output_files - 1;
1317 st->codecpar->codec_type = type;
1319 ret = choose_encoder(o, oc, ost);
1321 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1322 "%d:%d\n", ost->file_index, ost->index);
1326 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1327 if (!ost->enc_ctx) {
1328 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1331 ost->enc_ctx->codec_type = type;
1333 ost->ref_par = avcodec_parameters_alloc();
1334 if (!ost->ref_par) {
1335 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1340 AVIOContext *s = NULL;
1341 char *buf = NULL, *arg = NULL, *preset = NULL;
1343 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1345 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1346 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1349 if (!buf[0] || buf[0] == '#') {
1353 if (!(arg = strchr(buf, '='))) {
1354 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1358 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1360 } while (!s->eof_reached);
1364 av_log(NULL, AV_LOG_FATAL,
1365 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1366 preset, ost->file_index, ost->index);
1370 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1373 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1376 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1377 q.num <= 0 || q.den <= 0) {
1378 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1384 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1387 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1389 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1392 ost->enc_timebase = q;
1395 ost->max_frames = INT64_MAX;
1396 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1397 for (i = 0; i<o->nb_max_frames; i++) {
1398 char *p = o->max_frames[i].specifier;
1399 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1400 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1405 ost->copy_prior_start = -1;
1406 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1408 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1409 while (bsfs && *bsfs) {
1410 const AVBitStreamFilter *filter;
1411 char *bsf, *bsf_options_str, *bsf_name;
1413 bsf = av_get_token(&bsfs, ",");
1416 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1420 filter = av_bsf_get_by_name(bsf_name);
1422 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1426 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1427 ost->nb_bitstream_filters + 1,
1428 sizeof(*ost->bsf_ctx));
1432 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1434 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1438 ost->nb_bitstream_filters++;
1440 if (bsf_options_str && filter->priv_class) {
1441 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1442 const char * shorthand[2] = {NULL};
1445 shorthand[0] = opt->name;
1447 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1449 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1459 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1461 uint32_t tag = strtol(codec_tag, &next, 0);
1463 tag = AV_RL32(codec_tag);
1464 ost->st->codecpar->codec_tag =
1465 ost->enc_ctx->codec_tag = tag;
1468 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1470 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1471 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1474 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1475 ost->disposition = av_strdup(ost->disposition);
1477 ost->max_muxing_queue_size = 128;
1478 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1479 ost->max_muxing_queue_size *= sizeof(AVPacket);
1481 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1482 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1484 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1486 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1487 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1488 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1490 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1492 ost->source_index = source_index;
1493 if (source_index >= 0) {
1494 ost->sync_ist = input_streams[source_index];
1495 input_streams[source_index]->discard = 0;
1496 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1498 ost->last_mux_dts = AV_NOPTS_VALUE;
1500 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1501 if (!ost->muxing_queue)
1507 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1510 const char *p = str;
1517 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1524 /* read file contents into a string */
1525 static uint8_t *read_file(const char *filename)
1527 AVIOContext *pb = NULL;
1528 AVIOContext *dyn_buf = NULL;
1529 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1530 uint8_t buf[1024], *str;
1533 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1537 ret = avio_open_dyn_buf(&dyn_buf);
1542 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1543 avio_write(dyn_buf, buf, ret);
1544 avio_w8(dyn_buf, 0);
1547 ret = avio_close_dyn_buf(dyn_buf, &str);
1553 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1556 AVStream *st = ost->st;
1558 if (ost->filters_script && ost->filters) {
1559 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1560 "output stream #%d:%d.\n", nb_output_files, st->index);
1564 if (ost->filters_script)
1565 return read_file(ost->filters_script);
1566 else if (ost->filters)
1567 return av_strdup(ost->filters);
1569 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1573 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1574 const OutputStream *ost, enum AVMediaType type)
1576 if (ost->filters_script || ost->filters) {
1577 av_log(NULL, AV_LOG_ERROR,
1578 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1579 "Filtering and streamcopy cannot be used together.\n",
1580 ost->filters ? "Filtergraph" : "Filtergraph script",
1581 ost->filters ? ost->filters : ost->filters_script,
1582 av_get_media_type_string(type), ost->file_index, ost->index);
1587 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1591 AVCodecContext *video_enc;
1592 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1594 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1596 video_enc = ost->enc_ctx;
1598 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1599 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1600 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1603 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1604 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1606 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1607 if (frame_aspect_ratio) {
1609 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1610 q.num <= 0 || q.den <= 0) {
1611 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1614 ost->frame_aspect_ratio = q;
1617 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1618 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1620 if (!ost->stream_copy) {
1621 const char *p = NULL;
1622 char *frame_size = NULL;
1623 char *frame_pix_fmt = NULL;
1624 char *intra_matrix = NULL, *inter_matrix = NULL;
1625 char *chroma_intra_matrix = NULL;
1629 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1630 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1631 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1635 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1636 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1637 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1638 ost->keep_pix_fmt = 1;
1639 if (!*++frame_pix_fmt)
1640 frame_pix_fmt = NULL;
1642 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1643 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1646 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1649 video_enc->gop_size = 0;
1650 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1652 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1653 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1656 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1658 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1659 if (chroma_intra_matrix) {
1660 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1662 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1665 av_codec_set_chroma_intra_matrix(video_enc, p);
1666 parse_matrix_coeffs(p, chroma_intra_matrix);
1668 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1670 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1671 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1674 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1677 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1678 for (i = 0; p; i++) {
1680 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1682 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1685 video_enc->rc_override =
1686 av_realloc_array(video_enc->rc_override,
1687 i + 1, sizeof(RcOverride));
1688 if (!video_enc->rc_override) {
1689 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1692 video_enc->rc_override[i].start_frame = start;
1693 video_enc->rc_override[i].end_frame = end;
1695 video_enc->rc_override[i].qscale = q;
1696 video_enc->rc_override[i].quality_factor = 1.0;
1699 video_enc->rc_override[i].qscale = 0;
1700 video_enc->rc_override[i].quality_factor = -q/100.0;
1705 video_enc->rc_override_count = i;
1708 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1711 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1714 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1715 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1718 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1719 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1723 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1724 if (ost->logfile_prefix &&
1725 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1729 char logfilename[1024];
1732 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1733 ost->logfile_prefix ? ost->logfile_prefix :
1734 DEFAULT_PASS_LOGFILENAME_PREFIX,
1736 if (!strcmp(ost->enc->name, "libx264")) {
1737 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1739 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1740 char *logbuffer = read_file(logfilename);
1743 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1747 video_enc->stats_in = logbuffer;
1749 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1750 f = av_fopen_utf8(logfilename, "wb");
1752 av_log(NULL, AV_LOG_FATAL,
1753 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1754 logfilename, strerror(errno));
1762 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1763 if (ost->forced_keyframes)
1764 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1766 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1768 ost->top_field_first = -1;
1769 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1772 ost->avfilter = get_ost_filters(o, oc, ost);
1776 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1779 if (ost->stream_copy)
1780 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1785 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1790 AVCodecContext *audio_enc;
1792 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1795 audio_enc = ost->enc_ctx;
1796 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1798 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1799 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1801 if (!ost->stream_copy) {
1802 char *sample_fmt = NULL;
1804 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1806 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1808 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1809 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1813 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1815 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1816 ost->apad = av_strdup(ost->apad);
1818 ost->avfilter = get_ost_filters(o, oc, ost);
1822 /* check for channel mapping for this audio stream */
1823 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1824 AudioChannelMap *map = &o->audio_channel_maps[n];
1825 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1826 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1829 if (map->channel_idx == -1) {
1831 } else if (ost->source_index < 0) {
1832 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1833 ost->file_index, ost->st->index);
1836 ist = input_streams[ost->source_index];
1839 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1840 if (av_reallocp_array(&ost->audio_channels_map,
1841 ost->audio_channels_mapped + 1,
1842 sizeof(*ost->audio_channels_map)
1846 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1852 if (ost->stream_copy)
1853 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1858 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1862 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1863 if (!ost->stream_copy) {
1864 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1871 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1875 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1876 if (!ost->stream_copy) {
1877 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1884 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1886 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1887 ost->stream_copy = 1;
1892 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1896 AVCodecContext *subtitle_enc;
1898 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1900 subtitle_enc = ost->enc_ctx;
1902 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1904 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1906 if (!ost->stream_copy) {
1907 char *frame_size = NULL;
1909 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1910 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1911 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1919 /* arg format is "output-stream-index:streamid-value". */
1920 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1922 OptionsContext *o = optctx;
1927 av_strlcpy(idx_str, arg, sizeof(idx_str));
1928 p = strchr(idx_str, ':');
1930 av_log(NULL, AV_LOG_FATAL,
1931 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1936 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1937 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1938 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1942 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1944 AVFormatContext *is = ifile->ctx;
1945 AVFormatContext *os = ofile->ctx;
1949 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1951 return AVERROR(ENOMEM);
1954 for (i = 0; i < is->nb_chapters; i++) {
1955 AVChapter *in_ch = is->chapters[i], *out_ch;
1956 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1957 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1958 AV_TIME_BASE_Q, in_ch->time_base);
1959 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1960 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1963 if (in_ch->end < ts_off)
1965 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1968 out_ch = av_mallocz(sizeof(AVChapter));
1970 return AVERROR(ENOMEM);
1972 out_ch->id = in_ch->id;
1973 out_ch->time_base = in_ch->time_base;
1974 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1975 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1978 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1980 os->chapters[os->nb_chapters++] = out_ch;
1985 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1988 AVFormatContext *ic = avformat_alloc_context();
1990 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1991 ic->interrupt_callback = int_cb;
1992 err = avformat_open_input(&ic, filename, NULL, NULL);
1995 /* copy stream format */
1996 for(i=0;i<ic->nb_streams;i++) {
2000 const char *enc_config;
2002 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2004 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2005 return AVERROR(EINVAL);
2007 if (codec->type == AVMEDIA_TYPE_AUDIO)
2008 opt_audio_codec(o, "c:a", codec->name);
2009 else if (codec->type == AVMEDIA_TYPE_VIDEO)
2010 opt_video_codec(o, "c:v", codec->name);
2011 ost = new_output_stream(o, s, codec->type, -1);
2014 avcodec_get_context_defaults3(st->codec, codec);
2015 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
2017 AVDictionary *opts = NULL;
2018 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2019 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2020 av_dict_free(&opts);
2023 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2024 choose_sample_fmt(st, codec);
2025 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2026 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2027 avcodec_copy_context(ost->enc_ctx, st->codec);
2029 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2032 avformat_close_input(&ic);
2036 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2037 AVFormatContext *oc)
2041 switch (ofilter->type) {
2042 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2043 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2045 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2050 ost->source_index = -1;
2051 ost->filter = ofilter;
2054 ofilter->format = -1;
2056 if (ost->stream_copy) {
2057 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2058 "which is fed from a complex filtergraph. Filtering and streamcopy "
2059 "cannot be used together.\n", ost->file_index, ost->index);
2063 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2064 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2065 av_log(NULL, AV_LOG_ERROR,
2066 "%s '%s' was specified through the %s option "
2067 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2068 "%s and -filter_complex cannot be used together for the same stream.\n",
2069 ost->filters ? "Filtergraph" : "Filtergraph script",
2070 ost->filters ? ost->filters : ost->filters_script,
2071 opt, ost->file_index, ost->index, opt);
2075 avfilter_inout_free(&ofilter->out_tmp);
2078 static int init_complex_filters(void)
2082 for (i = 0; i < nb_filtergraphs; i++) {
2083 ret = init_complex_filtergraph(filtergraphs[i]);
2090 static int open_output_file(OptionsContext *o, const char *filename)
2092 AVFormatContext *oc;
2094 AVOutputFormat *file_oformat;
2098 AVDictionary *unused_opts = NULL;
2099 AVDictionaryEntry *e = NULL;
2100 int format_flags = 0;
2102 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2103 o->stop_time = INT64_MAX;
2104 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2107 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2108 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2109 if (o->stop_time <= start_time) {
2110 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2113 o->recording_time = o->stop_time - start_time;
2117 GROW_ARRAY(output_files, nb_output_files);
2118 of = av_mallocz(sizeof(*of));
2121 output_files[nb_output_files - 1] = of;
2123 of->ost_index = nb_output_streams;
2124 of->recording_time = o->recording_time;
2125 of->start_time = o->start_time;
2126 of->limit_filesize = o->limit_filesize;
2127 of->shortest = o->shortest;
2128 av_dict_copy(&of->opts, o->g->format_opts, 0);
2130 if (!strcmp(filename, "-"))
2133 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2135 print_error(filename, err);
2140 if (o->recording_time != INT64_MAX)
2141 oc->duration = o->recording_time;
2143 file_oformat= oc->oformat;
2144 oc->interrupt_callback = int_cb;
2146 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2148 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2149 av_opt_eval_flags(oc, o, e->value, &format_flags);
2152 /* create streams for all unlabeled output pads */
2153 for (i = 0; i < nb_filtergraphs; i++) {
2154 FilterGraph *fg = filtergraphs[i];
2155 for (j = 0; j < fg->nb_outputs; j++) {
2156 OutputFilter *ofilter = fg->outputs[j];
2158 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2161 switch (ofilter->type) {
2162 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2163 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2164 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2166 init_output_filter(ofilter, o, oc);
2170 /* ffserver seeking with date=... needs a date reference */
2171 if (!strcmp(file_oformat->name, "ffm") &&
2172 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2173 av_strstart(filename, "http:", NULL)) {
2174 int err = parse_option(o, "metadata", "creation_time=now", options);
2176 print_error(filename, err);
2181 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2182 av_strstart(filename, "http:", NULL)) {
2184 /* special case for files sent to ffserver: we get the stream
2185 parameters from ffserver */
2186 int err = read_ffserver_streams(o, oc, filename);
2188 print_error(filename, err);
2191 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2192 ost = output_streams[j];
2193 for (i = 0; i < nb_input_streams; i++) {
2194 ist = input_streams[i];
2195 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2197 ost->source_index= i;
2198 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2199 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2201 ist->st->discard = ist->user_set_discard;
2206 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2210 } else if (!o->nb_stream_maps) {
2211 char *subtitle_codec_name = NULL;
2212 /* pick the "best" stream of each type */
2214 /* video: highest resolution */
2215 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2216 int area = 0, idx = -1;
2217 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2218 for (i = 0; i < nb_input_streams; i++) {
2220 ist = input_streams[i];
2221 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2222 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2224 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2226 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2233 new_video_stream(o, oc, idx);
2236 /* audio: most channels */
2237 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2238 int best_score = 0, idx = -1;
2239 for (i = 0; i < nb_input_streams; i++) {
2241 ist = input_streams[i];
2242 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2243 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2244 score > best_score) {
2250 new_audio_stream(o, oc, idx);
2253 /* subtitles: pick first */
2254 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2255 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2256 for (i = 0; i < nb_input_streams; i++)
2257 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2258 AVCodecDescriptor const *input_descriptor =
2259 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2260 AVCodecDescriptor const *output_descriptor = NULL;
2261 AVCodec const *output_codec =
2262 avcodec_find_encoder(oc->oformat->subtitle_codec);
2263 int input_props = 0, output_props = 0;
2265 output_descriptor = avcodec_descriptor_get(output_codec->id);
2266 if (input_descriptor)
2267 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2268 if (output_descriptor)
2269 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2270 if (subtitle_codec_name ||
2271 input_props & output_props ||
2272 // Map dvb teletext which has neither property to any output subtitle encoder
2273 input_descriptor && output_descriptor &&
2274 (!input_descriptor->props ||
2275 !output_descriptor->props)) {
2276 new_subtitle_stream(o, oc, i);
2281 /* Data only if codec id match */
2282 if (!o->data_disable ) {
2283 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2284 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2285 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2286 && input_streams[i]->st->codecpar->codec_id == codec_id )
2287 new_data_stream(o, oc, i);
2291 for (i = 0; i < o->nb_stream_maps; i++) {
2292 StreamMap *map = &o->stream_maps[i];
2297 if (map->linklabel) {
2299 OutputFilter *ofilter = NULL;
2302 for (j = 0; j < nb_filtergraphs; j++) {
2303 fg = filtergraphs[j];
2304 for (k = 0; k < fg->nb_outputs; k++) {
2305 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2306 if (out && !strcmp(out->name, map->linklabel)) {
2307 ofilter = fg->outputs[k];
2314 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2315 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2318 init_output_filter(ofilter, o, oc);
2320 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2322 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2323 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2325 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2327 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2329 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2333 switch (ist->st->codecpar->codec_type) {
2334 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2335 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2336 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2337 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2338 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2339 case AVMEDIA_TYPE_UNKNOWN:
2340 if (copy_unknown_streams) {
2341 ost = new_unknown_stream (o, oc, src_idx);
2345 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2346 "Cannot map stream #%d:%d - unsupported type.\n",
2347 map->file_index, map->stream_index);
2348 if (!ignore_unknown_streams) {
2349 av_log(NULL, AV_LOG_FATAL,
2350 "If you want unsupported types ignored instead "
2351 "of failing, please use the -ignore_unknown option\n"
2352 "If you want them copied, please use -copy_unknown\n");
2357 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2358 + map->sync_stream_index];
2363 /* handle attached files */
2364 for (i = 0; i < o->nb_attachments; i++) {
2366 uint8_t *attachment;
2370 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2371 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2375 if ((len = avio_size(pb)) <= 0) {
2376 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2380 if (!(attachment = av_malloc(len))) {
2381 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2385 avio_read(pb, attachment, len);
2387 ost = new_attachment_stream(o, oc, -1);
2388 ost->stream_copy = 0;
2389 ost->attachment_filename = o->attachments[i];
2390 ost->st->codecpar->extradata = attachment;
2391 ost->st->codecpar->extradata_size = len;
2393 p = strrchr(o->attachments[i], '/');
2394 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2398 #if FF_API_LAVF_AVCTX
2399 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2400 AVDictionaryEntry *e;
2401 ost = output_streams[i];
2403 if ((ost->stream_copy || ost->attachment_filename)
2404 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2405 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2406 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2411 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2412 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2413 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2417 /* check if all codec options have been used */
2418 unused_opts = strip_specifiers(o->g->codec_opts);
2419 for (i = of->ost_index; i < nb_output_streams; i++) {
2421 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2422 AV_DICT_IGNORE_SUFFIX)))
2423 av_dict_set(&unused_opts, e->key, NULL, 0);
2427 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2428 const AVClass *class = avcodec_get_class();
2429 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2430 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2431 const AVClass *fclass = avformat_get_class();
2432 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2433 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2434 if (!option || foption)
2438 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2439 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2440 "output file #%d (%s) is not an encoding option.\n", e->key,
2441 option->help ? option->help : "", nb_output_files - 1,
2446 // gop_timecode is injected by generic code but not always used
2447 if (!strcmp(e->key, "gop_timecode"))
2450 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2451 "output file #%d (%s) has not been used for any stream. The most "
2452 "likely reason is either wrong type (e.g. a video option with "
2453 "no video streams) or that it is a private option of some encoder "
2454 "which was not actually used for any stream.\n", e->key,
2455 option->help ? option->help : "", nb_output_files - 1, filename);
2457 av_dict_free(&unused_opts);
2459 /* set the decoding_needed flags and create simple filtergraphs */
2460 for (i = of->ost_index; i < nb_output_streams; i++) {
2461 OutputStream *ost = output_streams[i];
2463 if (ost->encoding_needed && ost->source_index >= 0) {
2464 InputStream *ist = input_streams[ost->source_index];
2465 ist->decoding_needed |= DECODING_FOR_OST;
2467 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2468 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2469 err = init_simple_filtergraph(ist, ost);
2471 av_log(NULL, AV_LOG_ERROR,
2472 "Error initializing a simple filtergraph between streams "
2473 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2474 nb_output_files - 1, ost->st->index);
2480 /* set the filter output constraints */
2482 OutputFilter *f = ost->filter;
2484 switch (ost->enc_ctx->codec_type) {
2485 case AVMEDIA_TYPE_VIDEO:
2486 f->frame_rate = ost->frame_rate;
2487 f->width = ost->enc_ctx->width;
2488 f->height = ost->enc_ctx->height;
2489 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2490 f->format = ost->enc_ctx->pix_fmt;
2491 } else if (ost->enc->pix_fmts) {
2493 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2495 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2498 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2501 case AVMEDIA_TYPE_AUDIO:
2502 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2503 f->format = ost->enc_ctx->sample_fmt;
2504 } else if (ost->enc->sample_fmts) {
2506 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2508 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2511 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2513 if (ost->enc_ctx->sample_rate) {
2514 f->sample_rate = ost->enc_ctx->sample_rate;
2515 } else if (ost->enc->supported_samplerates) {
2517 while (ost->enc->supported_samplerates[count])
2519 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2520 if (!f->sample_rates)
2522 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2523 (count + 1) * sizeof(*f->sample_rates));
2525 if (ost->enc_ctx->channels) {
2526 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2527 } else if (ost->enc->channel_layouts) {
2529 while (ost->enc->channel_layouts[count])
2531 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2532 if (!f->channel_layouts)
2534 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2535 (count + 1) * sizeof(*f->channel_layouts));
2542 /* check filename in case of an image number is expected */
2543 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2544 if (!av_filename_number_test(oc->filename)) {
2545 print_error(oc->filename, AVERROR(EINVAL));
2550 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2551 av_log(NULL, AV_LOG_ERROR,
2552 "No input streams but output needs an input stream\n");
2556 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2557 /* test if it already exists to avoid losing precious files */
2558 assert_file_overwrite(filename);
2561 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2562 &oc->interrupt_callback,
2564 print_error(filename, err);
2567 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2568 assert_file_overwrite(filename);
2570 if (o->mux_preload) {
2571 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2573 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2576 for (i = 0; i < o->nb_metadata_map; i++) {
2578 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2580 if (in_file_index >= nb_input_files) {
2581 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2584 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2585 in_file_index >= 0 ?
2586 input_files[in_file_index]->ctx : NULL, o);
2590 if (o->chapters_input_file >= nb_input_files) {
2591 if (o->chapters_input_file == INT_MAX) {
2592 /* copy chapters from the first input file that has them*/
2593 o->chapters_input_file = -1;
2594 for (i = 0; i < nb_input_files; i++)
2595 if (input_files[i]->ctx->nb_chapters) {
2596 o->chapters_input_file = i;
2600 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2601 o->chapters_input_file);
2605 if (o->chapters_input_file >= 0)
2606 copy_chapters(input_files[o->chapters_input_file], of,
2607 !o->metadata_chapters_manual);
2609 /* copy global metadata by default */
2610 if (!o->metadata_global_manual && nb_input_files){
2611 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2612 AV_DICT_DONT_OVERWRITE);
2613 if(o->recording_time != INT64_MAX)
2614 av_dict_set(&oc->metadata, "duration", NULL, 0);
2615 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2617 if (!o->metadata_streams_manual)
2618 for (i = of->ost_index; i < nb_output_streams; i++) {
2620 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2622 ist = input_streams[output_streams[i]->source_index];
2623 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2624 if (!output_streams[i]->stream_copy) {
2625 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2629 /* process manually set programs */
2630 for (i = 0; i < o->nb_program; i++) {
2631 const char *p = o->program[i].u.str;
2636 const char *p2 = av_get_token(&p, ":");
2637 const char *to_dealloc = p2;
2644 key = av_get_token(&p2, "=");
2646 av_freep(&to_dealloc);
2652 if (!strcmp(key, "program_num"))
2653 progid = strtol(p2, NULL, 0);
2654 av_freep(&to_dealloc);
2658 program = av_new_program(oc, progid);
2660 p = o->program[i].u.str;
2662 const char *p2 = av_get_token(&p, ":");
2663 const char *to_dealloc = p2;
2669 key = av_get_token(&p2, "=");
2671 av_log(NULL, AV_LOG_FATAL,
2672 "No '=' character in program string %s.\n",
2680 if (!strcmp(key, "title")) {
2681 av_dict_set(&program->metadata, "title", p2, 0);
2682 } else if (!strcmp(key, "program_num")) {
2683 } else if (!strcmp(key, "st")) {
2684 int st_num = strtol(p2, NULL, 0);
2685 av_program_add_stream_index(oc, progid, st_num);
2687 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2690 av_freep(&to_dealloc);
2695 /* process manually set metadata */
2696 for (i = 0; i < o->nb_metadata; i++) {
2699 const char *stream_spec;
2700 int index = 0, j, ret = 0;
2702 val = strchr(o->metadata[i].u.str, '=');
2704 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2705 o->metadata[i].u.str);
2710 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2712 for (j = 0; j < oc->nb_streams; j++) {
2713 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2714 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2715 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2717 double theta = av_strtod(val, &tail);
2719 ost->rotate_overridden = 1;
2720 ost->rotate_override_value = theta;
2723 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2735 if (index < 0 || index >= oc->nb_chapters) {
2736 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2739 m = &oc->chapters[index]->metadata;
2742 if (index < 0 || index >= oc->nb_programs) {
2743 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2746 m = &oc->programs[index]->metadata;
2749 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2752 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2759 static int opt_target(void *optctx, const char *opt, const char *arg)
2761 OptionsContext *o = optctx;
2762 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2763 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2765 if (!strncmp(arg, "pal-", 4)) {
2768 } else if (!strncmp(arg, "ntsc-", 5)) {
2771 } else if (!strncmp(arg, "film-", 5)) {
2775 /* Try to determine PAL/NTSC by peeking in the input files */
2776 if (nb_input_files) {
2778 for (j = 0; j < nb_input_files; j++) {
2779 for (i = 0; i < input_files[j]->nb_streams; i++) {
2780 AVStream *st = input_files[j]->ctx->streams[i];
2781 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2783 fr = st->time_base.den * 1000 / st->time_base.num;
2787 } else if ((fr == 29970) || (fr == 23976)) {
2792 if (norm != UNKNOWN)
2796 if (norm != UNKNOWN)
2797 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2800 if (norm == UNKNOWN) {
2801 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2802 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2803 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2807 if (!strcmp(arg, "vcd")) {
2808 opt_video_codec(o, "c:v", "mpeg1video");
2809 opt_audio_codec(o, "c:a", "mp2");
2810 parse_option(o, "f", "vcd", options);
2812 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2813 parse_option(o, "r", frame_rates[norm], options);
2814 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2816 opt_default(NULL, "b:v", "1150000");
2817 opt_default(NULL, "maxrate:v", "1150000");
2818 opt_default(NULL, "minrate:v", "1150000");
2819 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2821 opt_default(NULL, "b:a", "224000");
2822 parse_option(o, "ar", "44100", options);
2823 parse_option(o, "ac", "2", options);
2825 opt_default(NULL, "packetsize", "2324");
2826 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2828 /* We have to offset the PTS, so that it is consistent with the SCR.
2829 SCR starts at 36000, but the first two packs contain only padding
2830 and the first pack from the other stream, respectively, may also have
2831 been written before.
2832 So the real data starts at SCR 36000+3*1200. */
2833 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2834 } else if (!strcmp(arg, "svcd")) {
2836 opt_video_codec(o, "c:v", "mpeg2video");
2837 opt_audio_codec(o, "c:a", "mp2");
2838 parse_option(o, "f", "svcd", options);
2840 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2841 parse_option(o, "r", frame_rates[norm], options);
2842 parse_option(o, "pix_fmt", "yuv420p", options);
2843 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2845 opt_default(NULL, "b:v", "2040000");
2846 opt_default(NULL, "maxrate:v", "2516000");
2847 opt_default(NULL, "minrate:v", "0"); // 1145000;
2848 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2849 opt_default(NULL, "scan_offset", "1");
2851 opt_default(NULL, "b:a", "224000");
2852 parse_option(o, "ar", "44100", options);
2854 opt_default(NULL, "packetsize", "2324");
2856 } else if (!strcmp(arg, "dvd")) {
2858 opt_video_codec(o, "c:v", "mpeg2video");
2859 opt_audio_codec(o, "c:a", "ac3");
2860 parse_option(o, "f", "dvd", options);
2862 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2863 parse_option(o, "r", frame_rates[norm], options);
2864 parse_option(o, "pix_fmt", "yuv420p", options);
2865 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2867 opt_default(NULL, "b:v", "6000000");
2868 opt_default(NULL, "maxrate:v", "9000000");
2869 opt_default(NULL, "minrate:v", "0"); // 1500000;
2870 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2872 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2873 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2875 opt_default(NULL, "b:a", "448000");
2876 parse_option(o, "ar", "48000", options);
2878 } else if (!strncmp(arg, "dv", 2)) {
2880 parse_option(o, "f", "dv", options);
2882 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2883 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2884 norm == PAL ? "yuv420p" : "yuv411p", options);
2885 parse_option(o, "r", frame_rates[norm], options);
2887 parse_option(o, "ar", "48000", options);
2888 parse_option(o, "ac", "2", options);
2891 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2892 return AVERROR(EINVAL);
2895 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2896 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2901 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2903 av_free (vstats_filename);
2904 vstats_filename = av_strdup (arg);
2908 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2911 time_t today2 = time(NULL);
2912 struct tm *today = localtime(&today2);
2914 if (!today) { // maybe tomorrow
2915 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2919 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2921 return opt_vstats_file(NULL, opt, filename);
2924 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2926 OptionsContext *o = optctx;
2927 return parse_option(o, "frames:v", arg, options);
2930 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2932 OptionsContext *o = optctx;
2933 return parse_option(o, "frames:a", arg, options);
2936 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2938 OptionsContext *o = optctx;
2939 return parse_option(o, "frames:d", arg, options);
2942 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2945 AVDictionary *cbak = codec_opts;
2946 AVDictionary *fbak = format_opts;
2950 ret = opt_default(NULL, opt, arg);
2952 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2953 av_dict_copy(&o->g->format_opts, format_opts, 0);
2954 av_dict_free(&codec_opts);
2955 av_dict_free(&format_opts);
2962 static int opt_preset(void *optctx, const char *opt, const char *arg)
2964 OptionsContext *o = optctx;
2966 char filename[1000], line[1000], tmp_line[1000];
2967 const char *codec_name = NULL;
2971 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2973 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2974 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2975 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2977 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2981 while (fgets(line, sizeof(line), f)) {
2982 char *key = tmp_line, *value, *endptr;
2984 if (strcspn(line, "#\n\r") == 0)
2986 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2987 if (!av_strtok(key, "=", &value) ||
2988 !av_strtok(value, "\r\n", &endptr)) {
2989 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2992 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2994 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2995 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2996 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2997 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2998 else if (opt_default_new(o, key, value) < 0) {
2999 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3000 filename, line, key, value);
3010 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3012 OptionsContext *o = optctx;
3013 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3014 int ret = parse_option(o, s, arg, options);
3019 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3021 OptionsContext *o = optctx;
3023 if(!strcmp(opt, "ab")){
3024 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3026 } else if(!strcmp(opt, "b")){
3027 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3028 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3031 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3035 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3037 OptionsContext *o = optctx;
3040 if(!strcmp(opt, "qscale")){
3041 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3042 return parse_option(o, "q:v", arg, options);
3044 s = av_asprintf("q%s", opt + 6);
3045 ret = parse_option(o, s, arg, options);
3050 static int opt_profile(void *optctx, const char *opt, const char *arg)
3052 OptionsContext *o = optctx;
3053 if(!strcmp(opt, "profile")){
3054 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3055 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3058 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3062 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3064 OptionsContext *o = optctx;
3065 return parse_option(o, "filter:v", arg, options);
3068 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3071 return parse_option(o, "filter:a", arg, options);
3074 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3076 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3077 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3078 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3079 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3081 if (video_sync_method == VSYNC_AUTO)
3082 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3086 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3088 OptionsContext *o = optctx;
3089 char *tcr = av_asprintf("timecode=%s", arg);
3090 int ret = parse_option(o, "metadata:g", tcr, options);
3092 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3097 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3099 OptionsContext *o = optctx;
3100 char layout_str[32];
3103 int ret, channels, ac_str_size;
3106 layout = av_get_channel_layout(arg);
3108 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3109 return AVERROR(EINVAL);
3111 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3112 ret = opt_default_new(o, opt, layout_str);
3116 /* set 'ac' option based on channel layout */
3117 channels = av_get_channel_layout_nb_channels(layout);
3118 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3119 stream_str = strchr(opt, ':');
3120 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3121 ac_str = av_mallocz(ac_str_size);
3123 return AVERROR(ENOMEM);
3124 av_strlcpy(ac_str, "ac", 3);
3126 av_strlcat(ac_str, stream_str, ac_str_size);
3127 ret = parse_option(o, ac_str, layout_str, options);
3133 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3135 OptionsContext *o = optctx;
3136 return parse_option(o, "q:a", arg, options);
3139 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3141 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3142 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3143 return AVERROR(ENOMEM);
3144 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3145 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3146 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3147 return AVERROR(ENOMEM);
3149 input_stream_potentially_available = 1;
3154 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3156 uint8_t *graph_desc = read_file(arg);
3158 return AVERROR(EINVAL);
3160 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3161 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3162 return AVERROR(ENOMEM);
3163 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3164 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3166 input_stream_potentially_available = 1;
3171 void show_help_default(const char *opt, const char *arg)
3173 /* per-file options have at least one of those set */
3174 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3175 int show_advanced = 0, show_avoptions = 0;
3178 if (!strcmp(opt, "long"))
3180 else if (!strcmp(opt, "full"))
3181 show_advanced = show_avoptions = 1;
3183 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3188 printf("Getting help:\n"
3189 " -h -- print basic options\n"
3190 " -h long -- print more options\n"
3191 " -h full -- print all options (including all format and codec specific options, very long)\n"
3192 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3193 " See man %s for detailed description of the options.\n"
3194 "\n", program_name);
3196 show_help_options(options, "Print help / information / capabilities:",
3199 show_help_options(options, "Global options (affect whole program "
3200 "instead of just one file:",
3201 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3203 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3204 per_file | OPT_EXIT, 0);
3206 show_help_options(options, "Per-file main options:", 0,
3207 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3208 OPT_EXIT, per_file);
3210 show_help_options(options, "Advanced per-file options:",
3211 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3213 show_help_options(options, "Video options:",
3214 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3216 show_help_options(options, "Advanced Video options:",
3217 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3219 show_help_options(options, "Audio options:",
3220 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3222 show_help_options(options, "Advanced Audio options:",
3223 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3224 show_help_options(options, "Subtitle options:",
3225 OPT_SUBTITLE, 0, 0);
3228 if (show_avoptions) {
3229 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3230 show_help_children(avcodec_get_class(), flags);
3231 show_help_children(avformat_get_class(), flags);
3233 show_help_children(sws_get_class(), flags);
3235 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3236 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3240 void show_usage(void)
3242 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3243 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3244 av_log(NULL, AV_LOG_INFO, "\n");
3252 static const OptionGroupDef groups[] = {
3253 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3254 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3257 static int open_files(OptionGroupList *l, const char *inout,
3258 int (*open_file)(OptionsContext*, const char*))
3262 for (i = 0; i < l->nb_groups; i++) {
3263 OptionGroup *g = &l->groups[i];
3269 ret = parse_optgroup(&o, g);
3271 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3272 "%s.\n", inout, g->arg);
3276 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3277 ret = open_file(&o, g->arg);
3280 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3284 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3290 int ffmpeg_parse_options(int argc, char **argv)
3292 OptionParseContext octx;
3296 memset(&octx, 0, sizeof(octx));
3298 /* split the commandline into an internal representation */
3299 ret = split_commandline(&octx, argc, argv, options, groups,
3300 FF_ARRAY_ELEMS(groups));
3302 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3306 /* apply global options */
3307 ret = parse_optgroup(NULL, &octx.global_opts);
3309 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3313 /* configure terminal and setup signal handlers */
3316 /* open input files */
3317 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3319 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3323 /* create the complex filtergraphs */
3324 ret = init_complex_filters();
3326 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3330 /* open output files */
3331 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3333 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3337 check_filter_outputs();
3340 uninit_parse_context(&octx);
3342 av_strerror(ret, error, sizeof(error));
3343 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3348 static int opt_progress(void *optctx, const char *opt, const char *arg)
3350 AVIOContext *avio = NULL;
3353 if (!strcmp(arg, "-"))
3355 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3357 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3358 arg, av_err2str(ret));
3361 progress_avio = avio;
3365 #define OFFSET(x) offsetof(OptionsContext, x)
3366 const OptionDef options[] = {
3368 CMDUTILS_COMMON_OPTIONS
3369 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3370 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3371 "force format", "fmt" },
3372 { "y", OPT_BOOL, { &file_overwrite },
3373 "overwrite output files" },
3374 { "n", OPT_BOOL, { &no_file_overwrite },
3375 "never overwrite output files" },
3376 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3377 "Ignore unknown stream types" },
3378 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3379 "Copy unknown stream types" },
3380 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3381 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3382 "codec name", "codec" },
3383 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3384 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3385 "codec name", "codec" },
3386 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3387 OPT_OUTPUT, { .off = OFFSET(presets) },
3388 "preset name", "preset" },
3389 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3390 OPT_OUTPUT, { .func_arg = opt_map },
3391 "set input stream mapping",
3392 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3393 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3394 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3395 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3396 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3397 "set metadata information of outfile from infile",
3398 "outfile[,metadata]:infile[,metadata]" },
3399 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3400 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3401 "set chapters mapping", "input_file_index" },
3402 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3403 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3404 "record or transcode \"duration\" seconds of audio/video",
3406 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3407 "record or transcode stop time", "time_stop" },
3408 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3409 "set the limit file size in bytes", "limit_size" },
3410 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3411 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3412 "set the start time offset", "time_off" },
3413 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3414 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3415 "set the start time offset relative to EOF", "time_off" },
3416 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3417 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3418 "enable/disable seeking by timestamp with -ss" },
3419 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3420 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3421 "enable/disable accurate seeking with -ss" },
3422 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3423 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3424 "set the input ts offset", "time_off" },
3425 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3426 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3427 "set the input ts scale", "scale" },
3428 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3429 "set the recording timestamp ('now' to set the current time)", "time" },
3430 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3431 "add metadata", "string=string" },
3432 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3433 "add program with specified streams", "title=string:st=number..." },
3434 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3435 OPT_OUTPUT, { .func_arg = opt_data_frames },
3436 "set the number of data frames to output", "number" },
3437 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3438 "add timings for benchmarking" },
3439 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3440 "add timings for each task" },
3441 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3442 "write program-readable progress information", "url" },
3443 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3444 "enable or disable interaction on standard input" },
3445 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3446 "set max runtime in seconds", "limit" },
3447 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3448 "dump each input packet" },
3449 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3450 "when dumping packets, also dump the payload" },
3451 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3452 OPT_INPUT, { .off = OFFSET(rate_emu) },
3453 "read input at native frame rate", "" },
3454 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3455 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3456 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3457 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3458 "video sync method", "" },
3459 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3460 "frame drop threshold", "" },
3461 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3462 "audio sync method", "" },
3463 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3464 "audio drift threshold", "threshold" },
3465 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3466 "copy timestamps" },
3467 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3468 "shift input timestamps to start at 0 when using copyts" },
3469 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3470 "copy input stream time base when stream copying", "mode" },
3471 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3472 OPT_OUTPUT, { .off = OFFSET(shortest) },
3473 "finish encoding within shortest input" },
3474 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3475 OPT_OUTPUT, { .off = OFFSET(apad) },
3477 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3478 "timestamp discontinuity delta threshold", "threshold" },
3479 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3480 "timestamp error delta threshold", "threshold" },
3481 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3482 "exit on error", "error" },
3483 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3484 "abort on the specified condition flags", "flags" },
3485 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3486 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3487 "copy initial non-keyframes" },
3488 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3489 "copy or discard frames before start time" },
3490 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3491 "set the number of frames to output", "number" },
3492 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3493 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3494 "force codec tag/fourcc", "fourcc/tag" },
3495 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3496 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3497 "use fixed quality scale (VBR)", "q" },
3498 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3499 OPT_OUTPUT, { .func_arg = opt_qscale },
3500 "use fixed quality scale (VBR)", "q" },
3501 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3502 "set profile", "profile" },
3503 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3504 "set stream filtergraph", "filter_graph" },
3505 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3506 "number of non-complex filter threads" },
3507 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3508 "read stream filtergraph description from a file", "filename" },
3509 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3510 "reinit filtergraph on input parameter changes", "" },
3511 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3512 "create a complex filtergraph", "graph_description" },
3513 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3514 "number of threads for -filter_complex" },
3515 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3516 "create a complex filtergraph", "graph_description" },
3517 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3518 "read complex filtergraph description from a file", "filename" },
3519 { "stats", OPT_BOOL, { &print_stats },
3520 "print progress report during encoding", },
3521 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3522 OPT_OUTPUT, { .func_arg = opt_attach },
3523 "add an attachment to the output file", "filename" },
3524 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3525 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3526 "extract an attachment into a file", "filename" },
3527 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3528 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3529 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3530 "print timestamp debugging info" },
3531 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3532 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3533 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3534 OPT_INPUT, { .off = OFFSET(discard) },
3536 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3537 OPT_OUTPUT, { .off = OFFSET(disposition) },
3538 "disposition", "" },
3539 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3540 { .off = OFFSET(thread_queue_size) },
3541 "set the maximum number of queued packets from the demuxer" },
3542 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3543 "read and decode the streams to fill missing information with heuristics" },
3546 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3547 "set the number of video frames to output", "number" },
3548 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3549 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3550 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3551 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3552 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3553 "set frame size (WxH or abbreviation)", "size" },
3554 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3555 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3556 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3557 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3558 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3559 "set pixel format", "format" },
3560 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3561 "set the number of bits per raw sample", "number" },
3562 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3563 "deprecated use -g 1" },
3564 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3566 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3567 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3568 "rate control override for specific intervals", "override" },
3569 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3570 OPT_OUTPUT, { .func_arg = opt_video_codec },
3571 "force video codec ('copy' to copy stream)", "codec" },
3572 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3574 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3576 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3577 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3578 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3579 "select the pass number (1 to 3)", "n" },
3580 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3581 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3582 "select two pass log file name prefix", "prefix" },
3583 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3584 "this option is deprecated, use the yadif filter instead" },
3585 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3586 "calculate PSNR of compressed frames" },
3587 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3588 "dump video coding statistics to file" },
3589 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3590 "dump video coding statistics to file", "file" },
3591 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3592 "Version of the vstats format to use."},
3593 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3594 "set video filters", "filter_graph" },
3595 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3596 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3597 "specify intra matrix coeffs", "matrix" },
3598 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3599 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3600 "specify inter matrix coeffs", "matrix" },
3601 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3602 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3603 "specify intra matrix coeffs", "matrix" },
3604 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3605 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3606 "top=1/bottom=0/auto=-1 field first", "" },
3607 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3608 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3609 "force video tag/fourcc", "fourcc/tag" },
3610 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3611 "show QP histogram" },
3612 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3613 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3614 "force the selected framerate, disable the best supported framerate selection" },
3615 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3616 OPT_OUTPUT, { .func_arg = opt_streamid },
3617 "set the value of an outfile streamid", "streamIndex:value" },
3618 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3619 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3620 "force key frames at specified timestamps", "timestamps" },
3621 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3622 "audio bitrate (please use -b:a)", "bitrate" },
3623 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3624 "video bitrate (please use -b:v)", "bitrate" },
3625 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3626 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3627 "use HW accelerated decoding", "hwaccel name" },
3628 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3629 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3630 "select a device for HW acceleration", "devicename" },
3631 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3632 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3633 "select output format used with HW accelerated decoding", "format" },
3634 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3635 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3637 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3638 "show available HW acceleration methods" },
3639 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3640 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3641 "automatically insert correct rotate filters" },
3644 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3645 "set the number of audio frames to output", "number" },
3646 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3647 "set audio quality (codec-specific)", "quality", },
3648 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3649 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3650 "set audio sampling rate (in Hz)", "rate" },
3651 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3652 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3653 "set number of audio channels", "channels" },
3654 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3656 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3657 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3658 "force audio codec ('copy' to copy stream)", "codec" },
3659 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3660 OPT_OUTPUT, { .func_arg = opt_old2new },
3661 "force audio tag/fourcc", "fourcc/tag" },
3662 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3663 "change audio volume (256=normal)" , "volume" },
3664 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3665 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3666 "set sample format", "format" },
3667 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3668 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3669 "set channel layout", "layout" },
3670 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3671 "set audio filters", "filter_graph" },
3672 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3673 "set the maximum number of channels to try to guess the channel layout" },
3675 /* subtitle options */
3676 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3677 "disable subtitle" },
3678 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3679 "force subtitle codec ('copy' to copy stream)", "codec" },
3680 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3681 , "force subtitle tag/fourcc", "fourcc/tag" },
3682 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3683 "fix subtitles duration" },
3684 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3685 "set canvas size (WxH or abbreviation)", "size" },
3688 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3689 "deprecated, use -channel", "channel" },
3690 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3691 "deprecated, use -standard", "standard" },
3692 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3695 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3696 "set the maximum demux-decode delay", "seconds" },
3697 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3698 "set the initial demux-decode delay", "seconds" },
3699 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3700 "override the options from ffserver", "" },
3701 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3702 "specify a file in which to print sdp information", "file" },
3704 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3705 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3706 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3707 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3708 "two special values are defined - "
3709 "0 = use frame rate (video) or sample rate (audio),"
3710 "-1 = match source time base", "ratio" },
3712 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3713 "A comma-separated list of bitstream filters", "bitstream_filters" },
3714 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3715 "deprecated", "audio bitstream_filters" },
3716 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3717 "deprecated", "video bitstream_filters" },
3719 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3720 "set the audio options to the indicated preset", "preset" },
3721 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3722 "set the video options to the indicated preset", "preset" },
3723 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3724 "set the subtitle options to the indicated preset", "preset" },
3725 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3726 "set options from indicated preset file", "filename" },
3728 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3729 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3731 /* data codec support */
3732 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3733 "force data codec ('copy' to copy stream)", "codec" },
3734 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3738 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3739 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3743 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3744 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3747 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3748 "initialise hardware device", "args" },
3749 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3750 "set hardware device used when filtering", "device" },