2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
69 #if CONFIG_VIDEOTOOLBOX
70 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
73 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
76 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
80 AVBufferRef *hw_device_ctx;
81 HWDevice *filter_hw_device;
83 char *vstats_filename;
86 float audio_drift_threshold = 0.1;
87 float dts_delta_threshold = 10;
88 float dts_error_threshold = 3600*30;
90 int audio_volume = 256;
91 int audio_sync_method = 0;
92 int video_sync_method = VSYNC_AUTO;
93 float frame_drop_threshold = 0;
94 int do_deinterlace = 0;
96 int do_benchmark_all = 0;
100 int start_at_zero = 0;
103 int exit_on_error = 0;
104 int abort_on_flags = 0;
105 int print_stats = -1;
107 int stdin_interaction = 1;
108 int frame_bits_per_raw_sample = 0;
109 float max_error_rate = 2.0/3;
110 int filter_nbthreads = 0;
111 int filter_complex_nbthreads = 0;
112 int vstats_version = 2;
115 static int intra_only = 0;
116 static int file_overwrite = 0;
117 static int no_file_overwrite = 0;
118 static int do_psnr = 0;
119 static int input_sync;
120 static int input_stream_potentially_available = 0;
121 static int ignore_unknown_streams = 0;
122 static int copy_unknown_streams = 0;
123 static int find_stream_info = 1;
125 static void uninit_options(OptionsContext *o)
127 const OptionDef *po = options;
130 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
132 void *dst = (uint8_t*)o + po->u.off;
134 if (po->flags & OPT_SPEC) {
135 SpecifierOpt **so = dst;
136 int i, *count = (int*)(so + 1);
137 for (i = 0; i < *count; i++) {
138 av_freep(&(*so)[i].specifier);
139 if (po->flags & OPT_STRING)
140 av_freep(&(*so)[i].u.str);
144 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
149 for (i = 0; i < o->nb_stream_maps; i++)
150 av_freep(&o->stream_maps[i].linklabel);
151 av_freep(&o->stream_maps);
152 av_freep(&o->audio_channel_maps);
153 av_freep(&o->streamid_map);
154 av_freep(&o->attachments);
157 static void init_options(OptionsContext *o)
159 memset(o, 0, sizeof(*o));
161 o->stop_time = INT64_MAX;
162 o->mux_max_delay = 0.7;
163 o->start_time = AV_NOPTS_VALUE;
164 o->start_time_eof = AV_NOPTS_VALUE;
165 o->recording_time = INT64_MAX;
166 o->limit_filesize = UINT64_MAX;
167 o->chapters_input_file = INT_MAX;
168 o->accurate_seek = 1;
171 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
176 printf("Hardware acceleration methods:\n");
177 while ((type = av_hwdevice_iterate_types(type)) !=
178 AV_HWDEVICE_TYPE_NONE)
179 printf("%s\n", av_hwdevice_get_type_name(type));
180 for (i = 0; hwaccels[i].name; i++)
181 printf("%s\n", hwaccels[i].name);
186 /* return a copy of the input with the stream specifiers removed from the keys */
187 static AVDictionary *strip_specifiers(AVDictionary *dict)
189 AVDictionaryEntry *e = NULL;
190 AVDictionary *ret = NULL;
192 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
193 char *p = strchr(e->key, ':');
197 av_dict_set(&ret, e->key, e->value, 0);
204 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
206 static const AVOption opts[] = {
207 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
208 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
211 static const AVClass class = {
213 .item_name = av_default_item_name,
215 .version = LIBAVUTIL_VERSION_INT,
217 const AVClass *pclass = &class;
219 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
222 static int opt_sameq(void *optctx, const char *opt, const char *arg)
224 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
225 "If you are looking for an option to preserve the quality (which is not "
226 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
228 return AVERROR(EINVAL);
231 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
233 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
234 return opt_default(optctx, "channel", arg);
237 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
239 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
240 return opt_default(optctx, "standard", arg);
243 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
245 OptionsContext *o = optctx;
246 return parse_option(o, "codec:a", arg, options);
249 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
251 OptionsContext *o = optctx;
252 return parse_option(o, "codec:v", arg, options);
255 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
257 OptionsContext *o = optctx;
258 return parse_option(o, "codec:s", arg, options);
261 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
263 OptionsContext *o = optctx;
264 return parse_option(o, "codec:d", arg, options);
267 static int opt_map(void *optctx, const char *opt, const char *arg)
269 OptionsContext *o = optctx;
271 int i, negative = 0, file_idx, disabled = 0;
272 int sync_file_idx = -1, sync_stream_idx = 0;
281 map = av_strdup(arg);
283 return AVERROR(ENOMEM);
285 /* parse sync stream first, just pick first matching stream */
286 if (sync = strchr(map, ',')) {
288 sync_file_idx = strtol(sync + 1, &sync, 0);
289 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
290 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
295 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
296 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
297 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
301 if (i == input_files[sync_file_idx]->nb_streams) {
302 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
303 "match any streams.\n", arg);
306 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
307 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
315 /* this mapping refers to lavfi output */
316 const char *c = map + 1;
317 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
318 m = &o->stream_maps[o->nb_stream_maps - 1];
319 m->linklabel = av_get_token(&c, "]");
321 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
325 if (allow_unused = strchr(map, '?'))
327 file_idx = strtol(map, &p, 0);
328 if (file_idx >= nb_input_files || file_idx < 0) {
329 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
333 /* disable some already defined maps */
334 for (i = 0; i < o->nb_stream_maps; i++) {
335 m = &o->stream_maps[i];
336 if (file_idx == m->file_index &&
337 check_stream_specifier(input_files[m->file_index]->ctx,
338 input_files[m->file_index]->ctx->streams[m->stream_index],
339 *p == ':' ? p + 1 : p) > 0)
343 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
344 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
345 *p == ':' ? p + 1 : p) <= 0)
347 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
351 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
352 m = &o->stream_maps[o->nb_stream_maps - 1];
354 m->file_index = file_idx;
357 if (sync_file_idx >= 0) {
358 m->sync_file_index = sync_file_idx;
359 m->sync_stream_index = sync_stream_idx;
361 m->sync_file_index = file_idx;
362 m->sync_stream_index = i;
369 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
370 } else if (disabled) {
371 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
372 "To ignore this, add a trailing '?' to the map.\n", arg);
375 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
376 "To ignore this, add a trailing '?' to the map.\n", arg);
385 static int opt_attach(void *optctx, const char *opt, const char *arg)
387 OptionsContext *o = optctx;
388 GROW_ARRAY(o->attachments, o->nb_attachments);
389 o->attachments[o->nb_attachments - 1] = arg;
393 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
395 OptionsContext *o = optctx;
401 mapchan = av_strdup(arg);
403 return AVERROR(ENOMEM);
405 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
406 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
408 /* muted channel syntax */
409 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
410 if ((n == 1 || n == 3) && m->channel_idx == -1) {
411 m->file_idx = m->stream_idx = -1;
413 m->ofile_idx = m->ostream_idx = -1;
419 n = sscanf(arg, "%d.%d.%d:%d.%d",
420 &m->file_idx, &m->stream_idx, &m->channel_idx,
421 &m->ofile_idx, &m->ostream_idx);
423 if (n != 3 && n != 5) {
424 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
425 "[file.stream.channel|-1][:syncfile:syncstream]\n");
429 if (n != 5) // only file.stream.channel specified
430 m->ofile_idx = m->ostream_idx = -1;
433 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
434 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
438 if (m->stream_idx < 0 ||
439 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
440 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
441 m->file_idx, m->stream_idx);
444 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
445 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
446 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
447 m->file_idx, m->stream_idx);
450 /* allow trailing ? to map_channel */
451 if (allow_unused = strchr(mapchan, '?'))
453 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
454 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
456 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
457 m->file_idx, m->stream_idx, m->channel_idx);
459 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
460 "To ignore this, add a trailing '?' to the map_channel.\n",
461 m->file_idx, m->stream_idx, m->channel_idx);
470 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
472 av_free(sdp_filename);
473 sdp_filename = av_strdup(arg);
478 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
481 const char *prefix = "vaapi:";
484 tmp = av_asprintf("%s%s", prefix, arg);
486 return AVERROR(ENOMEM);
487 err = hw_device_init_from_string(tmp, &dev);
491 hw_device_ctx = av_buffer_ref(dev->device_ref);
493 return AVERROR(ENOMEM);
498 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
500 if (!strcmp(arg, "list")) {
501 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
502 printf("Supported hardware device types:\n");
503 while ((type = av_hwdevice_iterate_types(type)) !=
504 AV_HWDEVICE_TYPE_NONE)
505 printf("%s\n", av_hwdevice_get_type_name(type));
509 return hw_device_init_from_string(arg, NULL);
513 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
515 if (filter_hw_device) {
516 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
517 return AVERROR(EINVAL);
519 filter_hw_device = hw_device_get_by_name(arg);
520 if (!filter_hw_device) {
521 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
522 return AVERROR(EINVAL);
528 * Parse a metadata specifier passed as 'arg' parameter.
529 * @param arg metadata string to parse
530 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
531 * @param index for type c/p, chapter/program index is written here
532 * @param stream_spec for type s, the stream specifier is written here
534 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
542 if (*(++arg) && *arg != ':') {
543 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
546 *stream_spec = *arg == ':' ? arg + 1 : "";
551 *index = strtol(++arg, NULL, 0);
554 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
561 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
563 AVDictionary **meta_in = NULL;
564 AVDictionary **meta_out = NULL;
566 char type_in, type_out;
567 const char *istream_spec = NULL, *ostream_spec = NULL;
568 int idx_in = 0, idx_out = 0;
570 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
571 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
574 if (type_out == 'g' || !*outspec)
575 o->metadata_global_manual = 1;
576 if (type_out == 's' || !*outspec)
577 o->metadata_streams_manual = 1;
578 if (type_out == 'c' || !*outspec)
579 o->metadata_chapters_manual = 1;
583 if (type_in == 'g' || type_out == 'g')
584 o->metadata_global_manual = 1;
585 if (type_in == 's' || type_out == 's')
586 o->metadata_streams_manual = 1;
587 if (type_in == 'c' || type_out == 'c')
588 o->metadata_chapters_manual = 1;
590 /* ic is NULL when just disabling automatic mappings */
594 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
595 if ((index) < 0 || (index) >= (nb_elems)) {\
596 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
601 #define SET_DICT(type, meta, context, index)\
604 meta = &context->metadata;\
607 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
608 meta = &context->chapters[index]->metadata;\
611 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
612 meta = &context->programs[index]->metadata;\
615 break; /* handled separately below */ \
616 default: av_assert0(0);\
619 SET_DICT(type_in, meta_in, ic, idx_in);
620 SET_DICT(type_out, meta_out, oc, idx_out);
622 /* for input streams choose first matching stream */
623 if (type_in == 's') {
624 for (i = 0; i < ic->nb_streams; i++) {
625 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
626 meta_in = &ic->streams[i]->metadata;
632 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
637 if (type_out == 's') {
638 for (i = 0; i < oc->nb_streams; i++) {
639 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
640 meta_out = &oc->streams[i]->metadata;
641 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
646 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
651 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
653 OptionsContext *o = optctx;
655 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
656 struct tm time = *gmtime((time_t*)&recording_timestamp);
657 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
659 parse_option(o, "metadata", buf, options);
661 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
662 "tag instead.\n", opt);
666 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
668 const AVCodecDescriptor *desc;
669 const char *codec_string = encoder ? "encoder" : "decoder";
673 avcodec_find_encoder_by_name(name) :
674 avcodec_find_decoder_by_name(name);
676 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
677 codec = encoder ? avcodec_find_encoder(desc->id) :
678 avcodec_find_decoder(desc->id);
680 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
681 codec_string, codec->name, desc->name);
685 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
688 if (codec->type != type) {
689 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
695 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
697 char *codec_name = NULL;
699 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
701 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
702 st->codecpar->codec_id = codec->id;
705 return avcodec_find_decoder(st->codecpar->codec_id);
708 /* Add all the streams from the given input file to the global
709 * list of input streams. */
710 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
714 for (i = 0; i < ic->nb_streams; i++) {
715 AVStream *st = ic->streams[i];
716 AVCodecParameters *par = st->codecpar;
717 InputStream *ist = av_mallocz(sizeof(*ist));
718 char *framerate = NULL, *hwaccel_device = NULL;
719 const char *hwaccel = NULL;
720 char *hwaccel_output_format = NULL;
721 char *codec_tag = NULL;
723 char *discard_str = NULL;
724 const AVClass *cc = avcodec_get_class();
725 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
730 GROW_ARRAY(input_streams, nb_input_streams);
731 input_streams[nb_input_streams - 1] = ist;
734 ist->file_index = nb_input_files;
736 st->discard = AVDISCARD_ALL;
738 ist->min_pts = INT64_MAX;
739 ist->max_pts = INT64_MIN;
742 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
745 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
747 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
749 uint32_t tag = strtol(codec_tag, &next, 0);
751 tag = AV_RL32(codec_tag);
752 st->codecpar->codec_tag = tag;
755 ist->dec = choose_decoder(o, ic, st);
756 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
758 ist->reinit_filters = -1;
759 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
761 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
762 ist->user_set_discard = AVDISCARD_NONE;
763 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
764 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
769 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
771 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
773 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
777 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
779 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
784 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
786 switch (par->codec_type) {
787 case AVMEDIA_TYPE_VIDEO:
789 ist->dec = avcodec_find_decoder(par->codec_id);
791 if (st->codec->lowres) {
792 ist->dec_ctx->lowres = st->codec->lowres;
793 ist->dec_ctx->width = st->codec->width;
794 ist->dec_ctx->height = st->codec->height;
795 ist->dec_ctx->coded_width = st->codec->coded_width;
796 ist->dec_ctx->coded_height = st->codec->coded_height;
800 // avformat_find_stream_info() doesn't set this for us anymore.
801 ist->dec_ctx->framerate = st->avg_frame_rate;
803 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
804 if (framerate && av_parse_video_rate(&ist->framerate,
806 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
811 ist->top_field_first = -1;
812 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
814 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
816 // The NVDEC hwaccels use a CUDA device, so remap the name here.
817 if (!strcmp(hwaccel, "nvdec"))
820 if (!strcmp(hwaccel, "none"))
821 ist->hwaccel_id = HWACCEL_NONE;
822 else if (!strcmp(hwaccel, "auto"))
823 ist->hwaccel_id = HWACCEL_AUTO;
825 enum AVHWDeviceType type;
827 for (i = 0; hwaccels[i].name; i++) {
828 if (!strcmp(hwaccels[i].name, hwaccel)) {
829 ist->hwaccel_id = hwaccels[i].id;
834 if (!ist->hwaccel_id) {
835 type = av_hwdevice_find_type_by_name(hwaccel);
836 if (type != AV_HWDEVICE_TYPE_NONE) {
837 ist->hwaccel_id = HWACCEL_GENERIC;
838 ist->hwaccel_device_type = type;
842 if (!ist->hwaccel_id) {
843 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
845 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
846 type = AV_HWDEVICE_TYPE_NONE;
847 while ((type = av_hwdevice_iterate_types(type)) !=
848 AV_HWDEVICE_TYPE_NONE)
849 av_log(NULL, AV_LOG_FATAL, "%s ",
850 av_hwdevice_get_type_name(type));
851 for (i = 0; hwaccels[i].name; i++)
852 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
853 av_log(NULL, AV_LOG_FATAL, "\n");
859 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
860 if (hwaccel_device) {
861 ist->hwaccel_device = av_strdup(hwaccel_device);
862 if (!ist->hwaccel_device)
866 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
867 hwaccel_output_format, ic, st);
868 if (hwaccel_output_format) {
869 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
870 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
871 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
872 "format: %s", hwaccel_output_format);
875 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
878 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
881 case AVMEDIA_TYPE_AUDIO:
882 ist->guess_layout_max = INT_MAX;
883 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
884 guess_input_channel_layout(ist);
886 case AVMEDIA_TYPE_DATA:
887 case AVMEDIA_TYPE_SUBTITLE: {
888 char *canvas_size = NULL;
890 ist->dec = avcodec_find_decoder(par->codec_id);
891 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
892 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
894 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
895 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
900 case AVMEDIA_TYPE_ATTACHMENT:
901 case AVMEDIA_TYPE_UNKNOWN:
907 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
909 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
915 static void assert_file_overwrite(const char *filename)
917 const char *proto_name = avio_find_protocol_name(filename);
919 if (file_overwrite && no_file_overwrite) {
920 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
924 if (!file_overwrite) {
925 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
926 if (stdin_interaction && !no_file_overwrite) {
927 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
930 signal(SIGINT, SIG_DFL);
932 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
938 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
944 if (proto_name && !strcmp(proto_name, "file")) {
945 for (int i = 0; i < nb_input_files; i++) {
946 InputFile *file = input_files[i];
947 if (file->ctx->iformat->flags & AVFMT_NOFILE)
949 if (!strcmp(filename, file->ctx->url)) {
950 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
951 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
958 static void dump_attachment(AVStream *st, const char *filename)
961 AVIOContext *out = NULL;
962 AVDictionaryEntry *e;
964 if (!st->codecpar->extradata_size) {
965 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
966 nb_input_files - 1, st->index);
969 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
972 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
973 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
977 assert_file_overwrite(filename);
979 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
980 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
985 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
990 static int open_input_file(OptionsContext *o, const char *filename)
994 AVInputFormat *file_iformat = NULL;
997 AVDictionary *unused_opts = NULL;
998 AVDictionaryEntry *e = NULL;
999 char * video_codec_name = NULL;
1000 char * audio_codec_name = NULL;
1001 char *subtitle_codec_name = NULL;
1002 char * data_codec_name = NULL;
1003 int scan_all_pmts_set = 0;
1005 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1006 o->stop_time = INT64_MAX;
1007 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1010 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1011 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1012 if (o->stop_time <= start_time) {
1013 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1016 o->recording_time = o->stop_time - start_time;
1021 if (!(file_iformat = av_find_input_format(o->format))) {
1022 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1027 if (!strcmp(filename, "-"))
1030 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1031 strcmp(filename, "/dev/stdin");
1033 /* get default parameters from command line */
1034 ic = avformat_alloc_context();
1036 print_error(filename, AVERROR(ENOMEM));
1039 if (o->nb_audio_sample_rate) {
1040 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1042 if (o->nb_audio_channels) {
1043 /* because we set audio_channels based on both the "ac" and
1044 * "channel_layout" options, we need to check that the specified
1045 * demuxer actually has the "channels" option before setting it */
1046 if (file_iformat && file_iformat->priv_class &&
1047 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1048 AV_OPT_SEARCH_FAKE_OBJ)) {
1049 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1052 if (o->nb_frame_rates) {
1053 /* set the format-level framerate option;
1054 * this is important for video grabbers, e.g. x11 */
1055 if (file_iformat && file_iformat->priv_class &&
1056 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1057 AV_OPT_SEARCH_FAKE_OBJ)) {
1058 av_dict_set(&o->g->format_opts, "framerate",
1059 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1062 if (o->nb_frame_sizes) {
1063 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1065 if (o->nb_frame_pix_fmts)
1066 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1068 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1069 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1070 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1071 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1073 if (video_codec_name)
1074 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1075 if (audio_codec_name)
1076 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1077 if (subtitle_codec_name)
1078 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1079 if (data_codec_name)
1080 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1082 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1083 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1084 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1085 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1087 ic->flags |= AVFMT_FLAG_NONBLOCK;
1089 ic->flags |= AVFMT_FLAG_BITEXACT;
1090 ic->interrupt_callback = int_cb;
1092 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1093 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1094 scan_all_pmts_set = 1;
1096 /* open the input file with generic avformat function */
1097 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1099 print_error(filename, err);
1100 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1101 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1104 if (scan_all_pmts_set)
1105 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1106 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1107 assert_avoptions(o->g->format_opts);
1109 /* apply forced codec ids */
1110 for (i = 0; i < ic->nb_streams; i++)
1111 choose_decoder(o, ic, ic->streams[i]);
1113 if (find_stream_info) {
1114 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1115 int orig_nb_streams = ic->nb_streams;
1117 /* If not enough info to get the stream parameters, we decode the
1118 first frames to get it. (used in mpeg case for example) */
1119 ret = avformat_find_stream_info(ic, opts);
1121 for (i = 0; i < orig_nb_streams; i++)
1122 av_dict_free(&opts[i]);
1126 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1127 if (ic->nb_streams == 0) {
1128 avformat_close_input(&ic);
1134 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1135 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1136 o->start_time_eof = AV_NOPTS_VALUE;
1139 if (o->start_time_eof != AV_NOPTS_VALUE) {
1140 if (o->start_time_eof >= 0) {
1141 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1144 if (ic->duration > 0) {
1145 o->start_time = o->start_time_eof + ic->duration;
1146 if (o->start_time < 0) {
1147 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1148 o->start_time = AV_NOPTS_VALUE;
1151 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1153 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1154 /* add the stream start time */
1155 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1156 timestamp += ic->start_time;
1158 /* if seeking requested, we execute it */
1159 if (o->start_time != AV_NOPTS_VALUE) {
1160 int64_t seek_timestamp = timestamp;
1162 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1163 int dts_heuristic = 0;
1164 for (i=0; i<ic->nb_streams; i++) {
1165 const AVCodecParameters *par = ic->streams[i]->codecpar;
1166 if (par->video_delay) {
1171 if (dts_heuristic) {
1172 seek_timestamp -= 3*AV_TIME_BASE / 23;
1175 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1177 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1178 filename, (double)timestamp / AV_TIME_BASE);
1182 /* update the current parameters so that they match the one of the input stream */
1183 add_input_streams(o, ic);
1185 /* dump the file content */
1186 av_dump_format(ic, nb_input_files, filename, 0);
1188 GROW_ARRAY(input_files, nb_input_files);
1189 f = av_mallocz(sizeof(*f));
1192 input_files[nb_input_files - 1] = f;
1195 f->ist_index = nb_input_streams - ic->nb_streams;
1196 f->start_time = o->start_time;
1197 f->recording_time = o->recording_time;
1198 f->input_ts_offset = o->input_ts_offset;
1199 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1200 f->nb_streams = ic->nb_streams;
1201 f->rate_emu = o->rate_emu;
1202 f->accurate_seek = o->accurate_seek;
1205 f->time_base = (AVRational){ 1, 1 };
1207 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1210 /* check if all codec options have been used */
1211 unused_opts = strip_specifiers(o->g->codec_opts);
1212 for (i = f->ist_index; i < nb_input_streams; i++) {
1214 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1215 AV_DICT_IGNORE_SUFFIX)))
1216 av_dict_set(&unused_opts, e->key, NULL, 0);
1220 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1221 const AVClass *class = avcodec_get_class();
1222 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1223 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1224 const AVClass *fclass = avformat_get_class();
1225 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1226 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1227 if (!option || foption)
1231 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1232 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1233 "input file #%d (%s) is not a decoding option.\n", e->key,
1234 option->help ? option->help : "", nb_input_files - 1,
1239 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1240 "input file #%d (%s) has not been used for any stream. The most "
1241 "likely reason is either wrong type (e.g. a video option with "
1242 "no video streams) or that it is a private option of some decoder "
1243 "which was not actually used for any stream.\n", e->key,
1244 option->help ? option->help : "", nb_input_files - 1, filename);
1246 av_dict_free(&unused_opts);
1248 for (i = 0; i < o->nb_dump_attachment; i++) {
1251 for (j = 0; j < ic->nb_streams; j++) {
1252 AVStream *st = ic->streams[j];
1254 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1255 dump_attachment(st, o->dump_attachment[i].u.str);
1259 input_stream_potentially_available = 1;
1264 static uint8_t *get_line(AVIOContext *s)
1270 if (avio_open_dyn_buf(&line) < 0) {
1271 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1275 while ((c = avio_r8(s)) && c != '\n')
1278 avio_close_dyn_buf(line, &buf);
1283 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1286 char filename[1000];
1287 const char *base[3] = { getenv("AVCONV_DATADIR"),
1292 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1296 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1297 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1298 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1301 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1302 i != 1 ? "" : "/.avconv", preset_name);
1303 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1309 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1311 enum AVMediaType type = ost->st->codecpar->codec_type;
1312 char *codec_name = NULL;
1314 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1315 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1317 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1318 NULL, ost->st->codecpar->codec_type);
1319 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1321 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1322 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1323 "probably disabled. Please choose an encoder manually.\n",
1324 ost->file_index, ost->index, s->oformat->name,
1325 avcodec_get_name(ost->st->codecpar->codec_id));
1326 return AVERROR_ENCODER_NOT_FOUND;
1328 } else if (!strcmp(codec_name, "copy"))
1329 ost->stream_copy = 1;
1331 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1332 ost->st->codecpar->codec_id = ost->enc->id;
1334 ost->encoding_needed = !ost->stream_copy;
1336 /* no encoding supported for other media types */
1337 ost->stream_copy = 1;
1338 ost->encoding_needed = 0;
1344 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1347 AVStream *st = avformat_new_stream(oc, NULL);
1348 int idx = oc->nb_streams - 1, ret = 0;
1349 const char *bsfs = NULL, *time_base = NULL;
1350 char *next, *codec_tag = NULL;
1355 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1359 if (oc->nb_streams - 1 < o->nb_streamid_map)
1360 st->id = o->streamid_map[oc->nb_streams - 1];
1362 GROW_ARRAY(output_streams, nb_output_streams);
1363 if (!(ost = av_mallocz(sizeof(*ost))))
1365 output_streams[nb_output_streams - 1] = ost;
1367 ost->file_index = nb_output_files - 1;
1370 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1371 st->codecpar->codec_type = type;
1373 ret = choose_encoder(o, oc, ost);
1375 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1376 "%d:%d\n", ost->file_index, ost->index);
1380 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1381 if (!ost->enc_ctx) {
1382 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1385 ost->enc_ctx->codec_type = type;
1387 ost->ref_par = avcodec_parameters_alloc();
1388 if (!ost->ref_par) {
1389 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1394 AVIOContext *s = NULL;
1395 char *buf = NULL, *arg = NULL, *preset = NULL;
1397 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1399 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1400 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1403 if (!buf[0] || buf[0] == '#') {
1407 if (!(arg = strchr(buf, '='))) {
1408 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1412 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1414 } while (!s->eof_reached);
1418 av_log(NULL, AV_LOG_FATAL,
1419 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1420 preset, ost->file_index, ost->index);
1424 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1429 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1431 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1434 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1435 q.num <= 0 || q.den <= 0) {
1436 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1442 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1445 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1447 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1450 ost->enc_timebase = q;
1453 ost->max_frames = INT64_MAX;
1454 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1455 for (i = 0; i<o->nb_max_frames; i++) {
1456 char *p = o->max_frames[i].specifier;
1457 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1458 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1463 ost->copy_prior_start = -1;
1464 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1466 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1467 while (bsfs && *bsfs) {
1468 const AVBitStreamFilter *filter;
1469 char *bsf, *bsf_options_str, *bsf_name;
1471 bsf = av_get_token(&bsfs, ",");
1474 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1478 filter = av_bsf_get_by_name(bsf_name);
1480 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1484 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1485 ost->nb_bitstream_filters + 1,
1486 sizeof(*ost->bsf_ctx));
1490 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1492 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1496 ost->nb_bitstream_filters++;
1498 if (bsf_options_str && filter->priv_class) {
1499 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1500 const char * shorthand[2] = {NULL};
1503 shorthand[0] = opt->name;
1505 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1507 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1517 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1519 uint32_t tag = strtol(codec_tag, &next, 0);
1521 tag = AV_RL32(codec_tag);
1522 ost->st->codecpar->codec_tag =
1523 ost->enc_ctx->codec_tag = tag;
1526 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1528 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1529 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1532 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1533 ost->disposition = av_strdup(ost->disposition);
1535 ost->max_muxing_queue_size = 128;
1536 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1537 ost->max_muxing_queue_size *= sizeof(AVPacket);
1539 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1540 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1542 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1544 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1545 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1546 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1548 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1550 ost->source_index = source_index;
1551 if (source_index >= 0) {
1552 ost->sync_ist = input_streams[source_index];
1553 input_streams[source_index]->discard = 0;
1554 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1556 ost->last_mux_dts = AV_NOPTS_VALUE;
1558 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1559 if (!ost->muxing_queue)
1565 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1568 const char *p = str;
1575 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1582 /* read file contents into a string */
1583 static uint8_t *read_file(const char *filename)
1585 AVIOContext *pb = NULL;
1586 AVIOContext *dyn_buf = NULL;
1587 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1588 uint8_t buf[1024], *str;
1591 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1595 ret = avio_open_dyn_buf(&dyn_buf);
1600 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1601 avio_write(dyn_buf, buf, ret);
1602 avio_w8(dyn_buf, 0);
1605 ret = avio_close_dyn_buf(dyn_buf, &str);
1611 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1614 AVStream *st = ost->st;
1616 if (ost->filters_script && ost->filters) {
1617 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1618 "output stream #%d:%d.\n", nb_output_files, st->index);
1622 if (ost->filters_script)
1623 return read_file(ost->filters_script);
1624 else if (ost->filters)
1625 return av_strdup(ost->filters);
1627 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1631 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1632 const OutputStream *ost, enum AVMediaType type)
1634 if (ost->filters_script || ost->filters) {
1635 av_log(NULL, AV_LOG_ERROR,
1636 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1637 "Filtering and streamcopy cannot be used together.\n",
1638 ost->filters ? "Filtergraph" : "Filtergraph script",
1639 ost->filters ? ost->filters : ost->filters_script,
1640 av_get_media_type_string(type), ost->file_index, ost->index);
1645 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1649 AVCodecContext *video_enc;
1650 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1652 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1654 video_enc = ost->enc_ctx;
1656 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1657 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1658 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1661 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1662 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1664 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1665 if (frame_aspect_ratio) {
1667 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1668 q.num <= 0 || q.den <= 0) {
1669 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1672 ost->frame_aspect_ratio = q;
1675 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1676 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1678 if (!ost->stream_copy) {
1679 const char *p = NULL;
1680 char *frame_size = NULL;
1681 char *frame_pix_fmt = NULL;
1682 char *intra_matrix = NULL, *inter_matrix = NULL;
1683 char *chroma_intra_matrix = NULL;
1687 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1688 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1689 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1693 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1694 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1695 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1696 ost->keep_pix_fmt = 1;
1697 if (!*++frame_pix_fmt)
1698 frame_pix_fmt = NULL;
1700 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1701 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1704 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1707 video_enc->gop_size = 0;
1708 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1710 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1711 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1714 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1716 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1717 if (chroma_intra_matrix) {
1718 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1720 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1723 video_enc->chroma_intra_matrix = p;
1724 parse_matrix_coeffs(p, chroma_intra_matrix);
1726 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1728 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1729 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1732 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1735 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1736 for (i = 0; p; i++) {
1738 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1740 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1743 video_enc->rc_override =
1744 av_realloc_array(video_enc->rc_override,
1745 i + 1, sizeof(RcOverride));
1746 if (!video_enc->rc_override) {
1747 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1750 video_enc->rc_override[i].start_frame = start;
1751 video_enc->rc_override[i].end_frame = end;
1753 video_enc->rc_override[i].qscale = q;
1754 video_enc->rc_override[i].quality_factor = 1.0;
1757 video_enc->rc_override[i].qscale = 0;
1758 video_enc->rc_override[i].quality_factor = -q/100.0;
1763 video_enc->rc_override_count = i;
1766 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1769 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1772 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1773 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1776 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1777 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1781 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1782 if (ost->logfile_prefix &&
1783 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1787 char logfilename[1024];
1790 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1791 ost->logfile_prefix ? ost->logfile_prefix :
1792 DEFAULT_PASS_LOGFILENAME_PREFIX,
1794 if (!strcmp(ost->enc->name, "libx264")) {
1795 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1797 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1798 char *logbuffer = read_file(logfilename);
1801 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1805 video_enc->stats_in = logbuffer;
1807 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1808 f = av_fopen_utf8(logfilename, "wb");
1810 av_log(NULL, AV_LOG_FATAL,
1811 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1812 logfilename, strerror(errno));
1820 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1821 if (ost->forced_keyframes)
1822 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1824 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1826 ost->top_field_first = -1;
1827 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1830 ost->avfilter = get_ost_filters(o, oc, ost);
1834 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1837 if (ost->stream_copy)
1838 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1843 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1848 AVCodecContext *audio_enc;
1850 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1853 audio_enc = ost->enc_ctx;
1854 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1856 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1857 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1859 if (!ost->stream_copy) {
1860 char *sample_fmt = NULL;
1862 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1864 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1866 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1867 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1871 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1873 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1874 ost->apad = av_strdup(ost->apad);
1876 ost->avfilter = get_ost_filters(o, oc, ost);
1880 /* check for channel mapping for this audio stream */
1881 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1882 AudioChannelMap *map = &o->audio_channel_maps[n];
1883 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1884 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1887 if (map->channel_idx == -1) {
1889 } else if (ost->source_index < 0) {
1890 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1891 ost->file_index, ost->st->index);
1894 ist = input_streams[ost->source_index];
1897 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1898 if (av_reallocp_array(&ost->audio_channels_map,
1899 ost->audio_channels_mapped + 1,
1900 sizeof(*ost->audio_channels_map)
1904 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1910 if (ost->stream_copy)
1911 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1916 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1920 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1921 if (!ost->stream_copy) {
1922 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1929 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1933 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1934 if (!ost->stream_copy) {
1935 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1942 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1944 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1945 ost->stream_copy = 1;
1950 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1954 AVCodecContext *subtitle_enc;
1956 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1958 subtitle_enc = ost->enc_ctx;
1960 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1962 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1964 if (!ost->stream_copy) {
1965 char *frame_size = NULL;
1967 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1968 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1969 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1977 /* arg format is "output-stream-index:streamid-value". */
1978 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1980 OptionsContext *o = optctx;
1985 av_strlcpy(idx_str, arg, sizeof(idx_str));
1986 p = strchr(idx_str, ':');
1988 av_log(NULL, AV_LOG_FATAL,
1989 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1994 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1995 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1996 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2000 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2002 AVFormatContext *is = ifile->ctx;
2003 AVFormatContext *os = ofile->ctx;
2007 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2009 return AVERROR(ENOMEM);
2012 for (i = 0; i < is->nb_chapters; i++) {
2013 AVChapter *in_ch = is->chapters[i], *out_ch;
2014 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2015 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2016 AV_TIME_BASE_Q, in_ch->time_base);
2017 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2018 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2021 if (in_ch->end < ts_off)
2023 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2026 out_ch = av_mallocz(sizeof(AVChapter));
2028 return AVERROR(ENOMEM);
2030 out_ch->id = in_ch->id;
2031 out_ch->time_base = in_ch->time_base;
2032 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2033 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2036 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2038 os->chapters[os->nb_chapters++] = out_ch;
2043 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2044 AVFormatContext *oc)
2048 switch (ofilter->type) {
2049 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2050 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2052 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2057 ost->source_index = -1;
2058 ost->filter = ofilter;
2061 ofilter->format = -1;
2063 if (ost->stream_copy) {
2064 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2065 "which is fed from a complex filtergraph. Filtering and streamcopy "
2066 "cannot be used together.\n", ost->file_index, ost->index);
2070 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2071 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2072 av_log(NULL, AV_LOG_ERROR,
2073 "%s '%s' was specified through the %s option "
2074 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2075 "%s and -filter_complex cannot be used together for the same stream.\n",
2076 ost->filters ? "Filtergraph" : "Filtergraph script",
2077 ost->filters ? ost->filters : ost->filters_script,
2078 opt, ost->file_index, ost->index, opt);
2082 avfilter_inout_free(&ofilter->out_tmp);
2085 static int init_complex_filters(void)
2089 for (i = 0; i < nb_filtergraphs; i++) {
2090 ret = init_complex_filtergraph(filtergraphs[i]);
2097 static int open_output_file(OptionsContext *o, const char *filename)
2099 AVFormatContext *oc;
2104 AVDictionary *unused_opts = NULL;
2105 AVDictionaryEntry *e = NULL;
2106 int format_flags = 0;
2108 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2109 o->stop_time = INT64_MAX;
2110 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2113 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2114 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2115 if (o->stop_time <= start_time) {
2116 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2119 o->recording_time = o->stop_time - start_time;
2123 GROW_ARRAY(output_files, nb_output_files);
2124 of = av_mallocz(sizeof(*of));
2127 output_files[nb_output_files - 1] = of;
2129 of->ost_index = nb_output_streams;
2130 of->recording_time = o->recording_time;
2131 of->start_time = o->start_time;
2132 of->limit_filesize = o->limit_filesize;
2133 of->shortest = o->shortest;
2134 av_dict_copy(&of->opts, o->g->format_opts, 0);
2136 if (!strcmp(filename, "-"))
2139 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2141 print_error(filename, err);
2146 if (o->recording_time != INT64_MAX)
2147 oc->duration = o->recording_time;
2149 oc->interrupt_callback = int_cb;
2151 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2153 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2154 av_opt_eval_flags(oc, o, e->value, &format_flags);
2157 format_flags |= AVFMT_FLAG_BITEXACT;
2158 oc->flags |= AVFMT_FLAG_BITEXACT;
2161 /* create streams for all unlabeled output pads */
2162 for (i = 0; i < nb_filtergraphs; i++) {
2163 FilterGraph *fg = filtergraphs[i];
2164 for (j = 0; j < fg->nb_outputs; j++) {
2165 OutputFilter *ofilter = fg->outputs[j];
2167 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2170 switch (ofilter->type) {
2171 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2172 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2173 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2175 init_output_filter(ofilter, o, oc);
2179 if (!o->nb_stream_maps) {
2180 char *subtitle_codec_name = NULL;
2181 /* pick the "best" stream of each type */
2183 /* video: highest resolution */
2184 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2185 int area = 0, idx = -1;
2186 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2187 for (i = 0; i < nb_input_streams; i++) {
2189 ist = input_streams[i];
2190 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2191 if (ist->user_set_discard == AVDISCARD_ALL)
2193 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2195 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2197 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2204 new_video_stream(o, oc, idx);
2207 /* audio: most channels */
2208 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2209 int best_score = 0, idx = -1;
2210 for (i = 0; i < nb_input_streams; i++) {
2212 ist = input_streams[i];
2213 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2214 if (ist->user_set_discard == AVDISCARD_ALL)
2216 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2217 score > best_score) {
2223 new_audio_stream(o, oc, idx);
2226 /* subtitles: pick first */
2227 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2228 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2229 for (i = 0; i < nb_input_streams; i++)
2230 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2231 AVCodecDescriptor const *input_descriptor =
2232 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2233 AVCodecDescriptor const *output_descriptor = NULL;
2234 AVCodec const *output_codec =
2235 avcodec_find_encoder(oc->oformat->subtitle_codec);
2236 int input_props = 0, output_props = 0;
2237 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2240 output_descriptor = avcodec_descriptor_get(output_codec->id);
2241 if (input_descriptor)
2242 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2243 if (output_descriptor)
2244 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2245 if (subtitle_codec_name ||
2246 input_props & output_props ||
2247 // Map dvb teletext which has neither property to any output subtitle encoder
2248 input_descriptor && output_descriptor &&
2249 (!input_descriptor->props ||
2250 !output_descriptor->props)) {
2251 new_subtitle_stream(o, oc, i);
2256 /* Data only if codec id match */
2257 if (!o->data_disable ) {
2258 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2259 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2260 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2262 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2263 && input_streams[i]->st->codecpar->codec_id == codec_id )
2264 new_data_stream(o, oc, i);
2268 for (i = 0; i < o->nb_stream_maps; i++) {
2269 StreamMap *map = &o->stream_maps[i];
2274 if (map->linklabel) {
2276 OutputFilter *ofilter = NULL;
2279 for (j = 0; j < nb_filtergraphs; j++) {
2280 fg = filtergraphs[j];
2281 for (k = 0; k < fg->nb_outputs; k++) {
2282 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2283 if (out && !strcmp(out->name, map->linklabel)) {
2284 ofilter = fg->outputs[k];
2291 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2292 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2295 init_output_filter(ofilter, o, oc);
2297 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2299 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2300 if (ist->user_set_discard == AVDISCARD_ALL) {
2301 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2302 map->file_index, map->stream_index);
2305 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2307 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2309 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2311 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2315 switch (ist->st->codecpar->codec_type) {
2316 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2317 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2318 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2319 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2320 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2321 case AVMEDIA_TYPE_UNKNOWN:
2322 if (copy_unknown_streams) {
2323 ost = new_unknown_stream (o, oc, src_idx);
2327 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2328 "Cannot map stream #%d:%d - unsupported type.\n",
2329 map->file_index, map->stream_index);
2330 if (!ignore_unknown_streams) {
2331 av_log(NULL, AV_LOG_FATAL,
2332 "If you want unsupported types ignored instead "
2333 "of failing, please use the -ignore_unknown option\n"
2334 "If you want them copied, please use -copy_unknown\n");
2339 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2340 + map->sync_stream_index];
2345 /* handle attached files */
2346 for (i = 0; i < o->nb_attachments; i++) {
2348 uint8_t *attachment;
2352 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2353 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2357 if ((len = avio_size(pb)) <= 0) {
2358 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2362 if (!(attachment = av_malloc(len))) {
2363 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2367 avio_read(pb, attachment, len);
2369 ost = new_attachment_stream(o, oc, -1);
2370 ost->stream_copy = 0;
2371 ost->attachment_filename = o->attachments[i];
2372 ost->st->codecpar->extradata = attachment;
2373 ost->st->codecpar->extradata_size = len;
2375 p = strrchr(o->attachments[i], '/');
2376 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2380 #if FF_API_LAVF_AVCTX
2381 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2382 AVDictionaryEntry *e;
2383 ost = output_streams[i];
2385 if ((ost->stream_copy || ost->attachment_filename)
2386 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2387 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2388 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2393 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2394 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2395 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2399 /* check if all codec options have been used */
2400 unused_opts = strip_specifiers(o->g->codec_opts);
2401 for (i = of->ost_index; i < nb_output_streams; i++) {
2403 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2404 AV_DICT_IGNORE_SUFFIX)))
2405 av_dict_set(&unused_opts, e->key, NULL, 0);
2409 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2410 const AVClass *class = avcodec_get_class();
2411 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2412 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2413 const AVClass *fclass = avformat_get_class();
2414 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2415 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2416 if (!option || foption)
2420 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2421 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2422 "output file #%d (%s) is not an encoding option.\n", e->key,
2423 option->help ? option->help : "", nb_output_files - 1,
2428 // gop_timecode is injected by generic code but not always used
2429 if (!strcmp(e->key, "gop_timecode"))
2432 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2433 "output file #%d (%s) has not been used for any stream. The most "
2434 "likely reason is either wrong type (e.g. a video option with "
2435 "no video streams) or that it is a private option of some encoder "
2436 "which was not actually used for any stream.\n", e->key,
2437 option->help ? option->help : "", nb_output_files - 1, filename);
2439 av_dict_free(&unused_opts);
2441 /* set the decoding_needed flags and create simple filtergraphs */
2442 for (i = of->ost_index; i < nb_output_streams; i++) {
2443 OutputStream *ost = output_streams[i];
2445 if (ost->encoding_needed && ost->source_index >= 0) {
2446 InputStream *ist = input_streams[ost->source_index];
2447 ist->decoding_needed |= DECODING_FOR_OST;
2449 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2450 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2451 err = init_simple_filtergraph(ist, ost);
2453 av_log(NULL, AV_LOG_ERROR,
2454 "Error initializing a simple filtergraph between streams "
2455 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2456 nb_output_files - 1, ost->st->index);
2462 /* set the filter output constraints */
2464 OutputFilter *f = ost->filter;
2466 switch (ost->enc_ctx->codec_type) {
2467 case AVMEDIA_TYPE_VIDEO:
2468 f->frame_rate = ost->frame_rate;
2469 f->width = ost->enc_ctx->width;
2470 f->height = ost->enc_ctx->height;
2471 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2472 f->format = ost->enc_ctx->pix_fmt;
2473 } else if (ost->enc->pix_fmts) {
2475 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2477 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2480 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2483 case AVMEDIA_TYPE_AUDIO:
2484 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2485 f->format = ost->enc_ctx->sample_fmt;
2486 } else if (ost->enc->sample_fmts) {
2488 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2490 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2493 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2495 if (ost->enc_ctx->sample_rate) {
2496 f->sample_rate = ost->enc_ctx->sample_rate;
2497 } else if (ost->enc->supported_samplerates) {
2499 while (ost->enc->supported_samplerates[count])
2501 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2502 if (!f->sample_rates)
2504 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2505 (count + 1) * sizeof(*f->sample_rates));
2507 if (ost->enc_ctx->channels) {
2508 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2509 } else if (ost->enc->channel_layouts) {
2511 while (ost->enc->channel_layouts[count])
2513 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2514 if (!f->channel_layouts)
2516 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2517 (count + 1) * sizeof(*f->channel_layouts));
2524 /* check filename in case of an image number is expected */
2525 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2526 if (!av_filename_number_test(oc->url)) {
2527 print_error(oc->url, AVERROR(EINVAL));
2532 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2533 av_log(NULL, AV_LOG_ERROR,
2534 "No input streams but output needs an input stream\n");
2538 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2539 /* test if it already exists to avoid losing precious files */
2540 assert_file_overwrite(filename);
2543 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2544 &oc->interrupt_callback,
2546 print_error(filename, err);
2549 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2550 assert_file_overwrite(filename);
2552 if (o->mux_preload) {
2553 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2555 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2558 for (i = 0; i < o->nb_metadata_map; i++) {
2560 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2562 if (in_file_index >= nb_input_files) {
2563 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2566 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2567 in_file_index >= 0 ?
2568 input_files[in_file_index]->ctx : NULL, o);
2572 if (o->chapters_input_file >= nb_input_files) {
2573 if (o->chapters_input_file == INT_MAX) {
2574 /* copy chapters from the first input file that has them*/
2575 o->chapters_input_file = -1;
2576 for (i = 0; i < nb_input_files; i++)
2577 if (input_files[i]->ctx->nb_chapters) {
2578 o->chapters_input_file = i;
2582 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2583 o->chapters_input_file);
2587 if (o->chapters_input_file >= 0)
2588 copy_chapters(input_files[o->chapters_input_file], of,
2589 !o->metadata_chapters_manual);
2591 /* copy global metadata by default */
2592 if (!o->metadata_global_manual && nb_input_files){
2593 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2594 AV_DICT_DONT_OVERWRITE);
2595 if(o->recording_time != INT64_MAX)
2596 av_dict_set(&oc->metadata, "duration", NULL, 0);
2597 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2599 if (!o->metadata_streams_manual)
2600 for (i = of->ost_index; i < nb_output_streams; i++) {
2602 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2604 ist = input_streams[output_streams[i]->source_index];
2605 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2606 if (!output_streams[i]->stream_copy) {
2607 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2611 /* process manually set programs */
2612 for (i = 0; i < o->nb_program; i++) {
2613 const char *p = o->program[i].u.str;
2618 const char *p2 = av_get_token(&p, ":");
2619 const char *to_dealloc = p2;
2626 key = av_get_token(&p2, "=");
2628 av_freep(&to_dealloc);
2634 if (!strcmp(key, "program_num"))
2635 progid = strtol(p2, NULL, 0);
2636 av_freep(&to_dealloc);
2640 program = av_new_program(oc, progid);
2642 p = o->program[i].u.str;
2644 const char *p2 = av_get_token(&p, ":");
2645 const char *to_dealloc = p2;
2651 key = av_get_token(&p2, "=");
2653 av_log(NULL, AV_LOG_FATAL,
2654 "No '=' character in program string %s.\n",
2662 if (!strcmp(key, "title")) {
2663 av_dict_set(&program->metadata, "title", p2, 0);
2664 } else if (!strcmp(key, "program_num")) {
2665 } else if (!strcmp(key, "st")) {
2666 int st_num = strtol(p2, NULL, 0);
2667 av_program_add_stream_index(oc, progid, st_num);
2669 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2672 av_freep(&to_dealloc);
2677 /* process manually set metadata */
2678 for (i = 0; i < o->nb_metadata; i++) {
2681 const char *stream_spec;
2682 int index = 0, j, ret = 0;
2684 val = strchr(o->metadata[i].u.str, '=');
2686 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2687 o->metadata[i].u.str);
2692 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2694 for (j = 0; j < oc->nb_streams; j++) {
2695 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2696 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2697 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2699 double theta = av_strtod(val, &tail);
2701 ost->rotate_overridden = 1;
2702 ost->rotate_override_value = theta;
2705 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2717 if (index < 0 || index >= oc->nb_chapters) {
2718 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2721 m = &oc->chapters[index]->metadata;
2724 if (index < 0 || index >= oc->nb_programs) {
2725 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2728 m = &oc->programs[index]->metadata;
2731 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2734 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2741 static int opt_target(void *optctx, const char *opt, const char *arg)
2743 OptionsContext *o = optctx;
2744 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2745 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2747 if (!strncmp(arg, "pal-", 4)) {
2750 } else if (!strncmp(arg, "ntsc-", 5)) {
2753 } else if (!strncmp(arg, "film-", 5)) {
2757 /* Try to determine PAL/NTSC by peeking in the input files */
2758 if (nb_input_files) {
2760 for (j = 0; j < nb_input_files; j++) {
2761 for (i = 0; i < input_files[j]->nb_streams; i++) {
2762 AVStream *st = input_files[j]->ctx->streams[i];
2763 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2765 fr = st->time_base.den * 1000 / st->time_base.num;
2769 } else if ((fr == 29970) || (fr == 23976)) {
2774 if (norm != UNKNOWN)
2778 if (norm != UNKNOWN)
2779 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2782 if (norm == UNKNOWN) {
2783 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2784 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2785 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2789 if (!strcmp(arg, "vcd")) {
2790 opt_video_codec(o, "c:v", "mpeg1video");
2791 opt_audio_codec(o, "c:a", "mp2");
2792 parse_option(o, "f", "vcd", options);
2794 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2795 parse_option(o, "r", frame_rates[norm], options);
2796 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2798 opt_default(NULL, "b:v", "1150000");
2799 opt_default(NULL, "maxrate:v", "1150000");
2800 opt_default(NULL, "minrate:v", "1150000");
2801 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2803 opt_default(NULL, "b:a", "224000");
2804 parse_option(o, "ar", "44100", options);
2805 parse_option(o, "ac", "2", options);
2807 opt_default(NULL, "packetsize", "2324");
2808 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2810 /* We have to offset the PTS, so that it is consistent with the SCR.
2811 SCR starts at 36000, but the first two packs contain only padding
2812 and the first pack from the other stream, respectively, may also have
2813 been written before.
2814 So the real data starts at SCR 36000+3*1200. */
2815 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2816 } else if (!strcmp(arg, "svcd")) {
2818 opt_video_codec(o, "c:v", "mpeg2video");
2819 opt_audio_codec(o, "c:a", "mp2");
2820 parse_option(o, "f", "svcd", options);
2822 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2823 parse_option(o, "r", frame_rates[norm], options);
2824 parse_option(o, "pix_fmt", "yuv420p", options);
2825 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2827 opt_default(NULL, "b:v", "2040000");
2828 opt_default(NULL, "maxrate:v", "2516000");
2829 opt_default(NULL, "minrate:v", "0"); // 1145000;
2830 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2831 opt_default(NULL, "scan_offset", "1");
2833 opt_default(NULL, "b:a", "224000");
2834 parse_option(o, "ar", "44100", options);
2836 opt_default(NULL, "packetsize", "2324");
2838 } else if (!strcmp(arg, "dvd")) {
2840 opt_video_codec(o, "c:v", "mpeg2video");
2841 opt_audio_codec(o, "c:a", "ac3");
2842 parse_option(o, "f", "dvd", options);
2844 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2845 parse_option(o, "r", frame_rates[norm], options);
2846 parse_option(o, "pix_fmt", "yuv420p", options);
2847 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2849 opt_default(NULL, "b:v", "6000000");
2850 opt_default(NULL, "maxrate:v", "9000000");
2851 opt_default(NULL, "minrate:v", "0"); // 1500000;
2852 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2854 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2855 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2857 opt_default(NULL, "b:a", "448000");
2858 parse_option(o, "ar", "48000", options);
2860 } else if (!strncmp(arg, "dv", 2)) {
2862 parse_option(o, "f", "dv", options);
2864 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2865 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2866 norm == PAL ? "yuv420p" : "yuv411p", options);
2867 parse_option(o, "r", frame_rates[norm], options);
2869 parse_option(o, "ar", "48000", options);
2870 parse_option(o, "ac", "2", options);
2873 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2874 return AVERROR(EINVAL);
2877 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2878 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2883 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2885 av_free (vstats_filename);
2886 vstats_filename = av_strdup (arg);
2890 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2893 time_t today2 = time(NULL);
2894 struct tm *today = localtime(&today2);
2896 if (!today) { // maybe tomorrow
2897 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2901 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2903 return opt_vstats_file(NULL, opt, filename);
2906 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2908 OptionsContext *o = optctx;
2909 return parse_option(o, "frames:v", arg, options);
2912 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2914 OptionsContext *o = optctx;
2915 return parse_option(o, "frames:a", arg, options);
2918 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2920 OptionsContext *o = optctx;
2921 return parse_option(o, "frames:d", arg, options);
2924 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2927 AVDictionary *cbak = codec_opts;
2928 AVDictionary *fbak = format_opts;
2932 ret = opt_default(NULL, opt, arg);
2934 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2935 av_dict_copy(&o->g->format_opts, format_opts, 0);
2936 av_dict_free(&codec_opts);
2937 av_dict_free(&format_opts);
2944 static int opt_preset(void *optctx, const char *opt, const char *arg)
2946 OptionsContext *o = optctx;
2948 char filename[1000], line[1000], tmp_line[1000];
2949 const char *codec_name = NULL;
2953 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2955 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2956 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2957 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2959 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2963 while (fgets(line, sizeof(line), f)) {
2964 char *key = tmp_line, *value, *endptr;
2966 if (strcspn(line, "#\n\r") == 0)
2968 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2969 if (!av_strtok(key, "=", &value) ||
2970 !av_strtok(value, "\r\n", &endptr)) {
2971 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2974 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2976 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2977 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2978 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2979 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2980 else if (opt_default_new(o, key, value) < 0) {
2981 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2982 filename, line, key, value);
2992 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2994 OptionsContext *o = optctx;
2995 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2996 int ret = parse_option(o, s, arg, options);
3001 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3003 OptionsContext *o = optctx;
3005 if(!strcmp(opt, "ab")){
3006 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3008 } else if(!strcmp(opt, "b")){
3009 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3010 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3013 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3017 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3019 OptionsContext *o = optctx;
3022 if(!strcmp(opt, "qscale")){
3023 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3024 return parse_option(o, "q:v", arg, options);
3026 s = av_asprintf("q%s", opt + 6);
3027 ret = parse_option(o, s, arg, options);
3032 static int opt_profile(void *optctx, const char *opt, const char *arg)
3034 OptionsContext *o = optctx;
3035 if(!strcmp(opt, "profile")){
3036 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3037 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3040 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3044 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3046 OptionsContext *o = optctx;
3047 return parse_option(o, "filter:v", arg, options);
3050 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3052 OptionsContext *o = optctx;
3053 return parse_option(o, "filter:a", arg, options);
3056 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3058 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3059 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3060 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3061 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3063 if (video_sync_method == VSYNC_AUTO)
3064 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3068 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3071 char *tcr = av_asprintf("timecode=%s", arg);
3072 int ret = parse_option(o, "metadata:g", tcr, options);
3074 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3079 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3081 OptionsContext *o = optctx;
3082 char layout_str[32];
3085 int ret, channels, ac_str_size;
3088 layout = av_get_channel_layout(arg);
3090 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3091 return AVERROR(EINVAL);
3093 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3094 ret = opt_default_new(o, opt, layout_str);
3098 /* set 'ac' option based on channel layout */
3099 channels = av_get_channel_layout_nb_channels(layout);
3100 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3101 stream_str = strchr(opt, ':');
3102 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3103 ac_str = av_mallocz(ac_str_size);
3105 return AVERROR(ENOMEM);
3106 av_strlcpy(ac_str, "ac", 3);
3108 av_strlcat(ac_str, stream_str, ac_str_size);
3109 ret = parse_option(o, ac_str, layout_str, options);
3115 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3117 OptionsContext *o = optctx;
3118 return parse_option(o, "q:a", arg, options);
3121 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3123 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3124 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3125 return AVERROR(ENOMEM);
3126 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3127 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3128 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3129 return AVERROR(ENOMEM);
3131 input_stream_potentially_available = 1;
3136 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3138 uint8_t *graph_desc = read_file(arg);
3140 return AVERROR(EINVAL);
3142 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3143 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3144 return AVERROR(ENOMEM);
3145 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3146 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3148 input_stream_potentially_available = 1;
3153 void show_help_default(const char *opt, const char *arg)
3155 /* per-file options have at least one of those set */
3156 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3157 int show_advanced = 0, show_avoptions = 0;
3160 if (!strcmp(opt, "long"))
3162 else if (!strcmp(opt, "full"))
3163 show_advanced = show_avoptions = 1;
3165 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3170 printf("Getting help:\n"
3171 " -h -- print basic options\n"
3172 " -h long -- print more options\n"
3173 " -h full -- print all options (including all format and codec specific options, very long)\n"
3174 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3175 " See man %s for detailed description of the options.\n"
3176 "\n", program_name);
3178 show_help_options(options, "Print help / information / capabilities:",
3181 show_help_options(options, "Global options (affect whole program "
3182 "instead of just one file:",
3183 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3185 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3186 per_file | OPT_EXIT, 0);
3188 show_help_options(options, "Per-file main options:", 0,
3189 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3190 OPT_EXIT, per_file);
3192 show_help_options(options, "Advanced per-file options:",
3193 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3195 show_help_options(options, "Video options:",
3196 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3198 show_help_options(options, "Advanced Video options:",
3199 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3201 show_help_options(options, "Audio options:",
3202 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3204 show_help_options(options, "Advanced Audio options:",
3205 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3206 show_help_options(options, "Subtitle options:",
3207 OPT_SUBTITLE, 0, 0);
3210 if (show_avoptions) {
3211 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3212 show_help_children(avcodec_get_class(), flags);
3213 show_help_children(avformat_get_class(), flags);
3215 show_help_children(sws_get_class(), flags);
3217 #if CONFIG_SWRESAMPLE
3218 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3220 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3221 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3225 void show_usage(void)
3227 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3228 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3229 av_log(NULL, AV_LOG_INFO, "\n");
3237 static const OptionGroupDef groups[] = {
3238 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3239 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3242 static int open_files(OptionGroupList *l, const char *inout,
3243 int (*open_file)(OptionsContext*, const char*))
3247 for (i = 0; i < l->nb_groups; i++) {
3248 OptionGroup *g = &l->groups[i];
3254 ret = parse_optgroup(&o, g);
3256 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3257 "%s.\n", inout, g->arg);
3261 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3262 ret = open_file(&o, g->arg);
3265 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3269 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3275 int ffmpeg_parse_options(int argc, char **argv)
3277 OptionParseContext octx;
3281 memset(&octx, 0, sizeof(octx));
3283 /* split the commandline into an internal representation */
3284 ret = split_commandline(&octx, argc, argv, options, groups,
3285 FF_ARRAY_ELEMS(groups));
3287 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3291 /* apply global options */
3292 ret = parse_optgroup(NULL, &octx.global_opts);
3294 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3298 /* configure terminal and setup signal handlers */
3301 /* open input files */
3302 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3304 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3308 /* create the complex filtergraphs */
3309 ret = init_complex_filters();
3311 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3315 /* open output files */
3316 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3318 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3322 check_filter_outputs();
3325 uninit_parse_context(&octx);
3327 av_strerror(ret, error, sizeof(error));
3328 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3333 static int opt_progress(void *optctx, const char *opt, const char *arg)
3335 AVIOContext *avio = NULL;
3338 if (!strcmp(arg, "-"))
3340 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3342 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3343 arg, av_err2str(ret));
3346 progress_avio = avio;
3350 #define OFFSET(x) offsetof(OptionsContext, x)
3351 const OptionDef options[] = {
3353 CMDUTILS_COMMON_OPTIONS
3354 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3355 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3356 "force format", "fmt" },
3357 { "y", OPT_BOOL, { &file_overwrite },
3358 "overwrite output files" },
3359 { "n", OPT_BOOL, { &no_file_overwrite },
3360 "never overwrite output files" },
3361 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3362 "Ignore unknown stream types" },
3363 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3364 "Copy unknown stream types" },
3365 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3366 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3367 "codec name", "codec" },
3368 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3369 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3370 "codec name", "codec" },
3371 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3372 OPT_OUTPUT, { .off = OFFSET(presets) },
3373 "preset name", "preset" },
3374 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3375 OPT_OUTPUT, { .func_arg = opt_map },
3376 "set input stream mapping",
3377 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3378 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3379 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3380 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3381 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3382 "set metadata information of outfile from infile",
3383 "outfile[,metadata]:infile[,metadata]" },
3384 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3385 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3386 "set chapters mapping", "input_file_index" },
3387 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3388 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3389 "record or transcode \"duration\" seconds of audio/video",
3391 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3392 "record or transcode stop time", "time_stop" },
3393 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3394 "set the limit file size in bytes", "limit_size" },
3395 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3396 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3397 "set the start time offset", "time_off" },
3398 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3399 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3400 "set the start time offset relative to EOF", "time_off" },
3401 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3402 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3403 "enable/disable seeking by timestamp with -ss" },
3404 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3405 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3406 "enable/disable accurate seeking with -ss" },
3407 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3408 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3409 "set the input ts offset", "time_off" },
3410 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3411 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3412 "set the input ts scale", "scale" },
3413 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3414 "set the recording timestamp ('now' to set the current time)", "time" },
3415 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3416 "add metadata", "string=string" },
3417 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3418 "add program with specified streams", "title=string:st=number..." },
3419 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3420 OPT_OUTPUT, { .func_arg = opt_data_frames },
3421 "set the number of data frames to output", "number" },
3422 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3423 "add timings for benchmarking" },
3424 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3425 "add timings for each task" },
3426 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3427 "write program-readable progress information", "url" },
3428 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3429 "enable or disable interaction on standard input" },
3430 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3431 "set max runtime in seconds", "limit" },
3432 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3433 "dump each input packet" },
3434 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3435 "when dumping packets, also dump the payload" },
3436 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3437 OPT_INPUT, { .off = OFFSET(rate_emu) },
3438 "read input at native frame rate", "" },
3439 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3440 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3441 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3442 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3443 "video sync method", "" },
3444 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3445 "frame drop threshold", "" },
3446 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3447 "audio sync method", "" },
3448 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3449 "audio drift threshold", "threshold" },
3450 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3451 "copy timestamps" },
3452 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3453 "shift input timestamps to start at 0 when using copyts" },
3454 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3455 "copy input stream time base when stream copying", "mode" },
3456 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3457 OPT_OUTPUT, { .off = OFFSET(shortest) },
3458 "finish encoding within shortest input" },
3459 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3460 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3462 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3463 OPT_OUTPUT, { .off = OFFSET(apad) },
3465 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3466 "timestamp discontinuity delta threshold", "threshold" },
3467 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3468 "timestamp error delta threshold", "threshold" },
3469 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3470 "exit on error", "error" },
3471 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3472 "abort on the specified condition flags", "flags" },
3473 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3474 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3475 "copy initial non-keyframes" },
3476 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3477 "copy or discard frames before start time" },
3478 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3479 "set the number of frames to output", "number" },
3480 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3481 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3482 "force codec tag/fourcc", "fourcc/tag" },
3483 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3484 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3485 "use fixed quality scale (VBR)", "q" },
3486 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3487 OPT_OUTPUT, { .func_arg = opt_qscale },
3488 "use fixed quality scale (VBR)", "q" },
3489 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3490 "set profile", "profile" },
3491 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3492 "set stream filtergraph", "filter_graph" },
3493 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3494 "number of non-complex filter threads" },
3495 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3496 "read stream filtergraph description from a file", "filename" },
3497 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3498 "reinit filtergraph on input parameter changes", "" },
3499 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3500 "create a complex filtergraph", "graph_description" },
3501 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3502 "number of threads for -filter_complex" },
3503 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3504 "create a complex filtergraph", "graph_description" },
3505 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3506 "read complex filtergraph description from a file", "filename" },
3507 { "stats", OPT_BOOL, { &print_stats },
3508 "print progress report during encoding", },
3509 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3510 OPT_OUTPUT, { .func_arg = opt_attach },
3511 "add an attachment to the output file", "filename" },
3512 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3513 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3514 "extract an attachment into a file", "filename" },
3515 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3516 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3517 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3518 "print timestamp debugging info" },
3519 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3520 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3521 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3522 OPT_INPUT, { .off = OFFSET(discard) },
3524 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3525 OPT_OUTPUT, { .off = OFFSET(disposition) },
3526 "disposition", "" },
3527 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3528 { .off = OFFSET(thread_queue_size) },
3529 "set the maximum number of queued packets from the demuxer" },
3530 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3531 "read and decode the streams to fill missing information with heuristics" },
3534 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3535 "set the number of video frames to output", "number" },
3536 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3537 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3538 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3539 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3540 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3541 "set frame size (WxH or abbreviation)", "size" },
3542 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3543 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3544 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3545 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3546 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3547 "set pixel format", "format" },
3548 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3549 "set the number of bits per raw sample", "number" },
3550 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3551 "deprecated use -g 1" },
3552 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3554 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3555 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3556 "rate control override for specific intervals", "override" },
3557 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3558 OPT_OUTPUT, { .func_arg = opt_video_codec },
3559 "force video codec ('copy' to copy stream)", "codec" },
3560 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3562 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3564 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3565 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3566 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3567 "select the pass number (1 to 3)", "n" },
3568 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3569 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3570 "select two pass log file name prefix", "prefix" },
3571 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3572 "this option is deprecated, use the yadif filter instead" },
3573 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3574 "calculate PSNR of compressed frames" },
3575 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3576 "dump video coding statistics to file" },
3577 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3578 "dump video coding statistics to file", "file" },
3579 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3580 "Version of the vstats format to use."},
3581 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3582 "set video filters", "filter_graph" },
3583 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3584 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3585 "specify intra matrix coeffs", "matrix" },
3586 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3587 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3588 "specify inter matrix coeffs", "matrix" },
3589 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3590 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3591 "specify intra matrix coeffs", "matrix" },
3592 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3593 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3594 "top=1/bottom=0/auto=-1 field first", "" },
3595 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3596 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3597 "force video tag/fourcc", "fourcc/tag" },
3598 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3599 "show QP histogram" },
3600 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3601 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3602 "force the selected framerate, disable the best supported framerate selection" },
3603 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3604 OPT_OUTPUT, { .func_arg = opt_streamid },
3605 "set the value of an outfile streamid", "streamIndex:value" },
3606 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3607 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3608 "force key frames at specified timestamps", "timestamps" },
3609 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3610 "audio bitrate (please use -b:a)", "bitrate" },
3611 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3612 "video bitrate (please use -b:v)", "bitrate" },
3613 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3614 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3615 "use HW accelerated decoding", "hwaccel name" },
3616 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3617 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3618 "select a device for HW acceleration", "devicename" },
3619 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3620 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3621 "select output format used with HW accelerated decoding", "format" },
3622 #if CONFIG_VIDEOTOOLBOX
3623 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3625 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3626 "show available HW acceleration methods" },
3627 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3628 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3629 "automatically insert correct rotate filters" },
3632 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3633 "set the number of audio frames to output", "number" },
3634 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3635 "set audio quality (codec-specific)", "quality", },
3636 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3637 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3638 "set audio sampling rate (in Hz)", "rate" },
3639 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3640 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3641 "set number of audio channels", "channels" },
3642 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3644 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3645 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3646 "force audio codec ('copy' to copy stream)", "codec" },
3647 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3648 OPT_OUTPUT, { .func_arg = opt_old2new },
3649 "force audio tag/fourcc", "fourcc/tag" },
3650 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3651 "change audio volume (256=normal)" , "volume" },
3652 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3653 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3654 "set sample format", "format" },
3655 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3656 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3657 "set channel layout", "layout" },
3658 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3659 "set audio filters", "filter_graph" },
3660 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3661 "set the maximum number of channels to try to guess the channel layout" },
3663 /* subtitle options */
3664 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3665 "disable subtitle" },
3666 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3667 "force subtitle codec ('copy' to copy stream)", "codec" },
3668 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3669 , "force subtitle tag/fourcc", "fourcc/tag" },
3670 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3671 "fix subtitles duration" },
3672 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3673 "set canvas size (WxH or abbreviation)", "size" },
3676 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3677 "deprecated, use -channel", "channel" },
3678 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3679 "deprecated, use -standard", "standard" },
3680 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3683 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3684 "set the maximum demux-decode delay", "seconds" },
3685 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3686 "set the initial demux-decode delay", "seconds" },
3687 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3688 "specify a file in which to print sdp information", "file" },
3690 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3691 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3692 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3693 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3694 "two special values are defined - "
3695 "0 = use frame rate (video) or sample rate (audio),"
3696 "-1 = match source time base", "ratio" },
3698 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3699 "A comma-separated list of bitstream filters", "bitstream_filters" },
3700 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3701 "deprecated", "audio bitstream_filters" },
3702 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3703 "deprecated", "video bitstream_filters" },
3705 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3706 "set the audio options to the indicated preset", "preset" },
3707 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3708 "set the video options to the indicated preset", "preset" },
3709 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3710 "set the subtitle options to the indicated preset", "preset" },
3711 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3712 "set options from indicated preset file", "filename" },
3714 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3715 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3717 /* data codec support */
3718 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3719 "force data codec ('copy' to copy stream)", "codec" },
3720 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3724 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3725 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3729 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3730 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3733 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3734 "initialise hardware device", "args" },
3735 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3736 "set hardware device used when filtering", "device" },