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;
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);
310 /* this mapping refers to lavfi output */
311 const char *c = map + 1;
312 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
313 m = &o->stream_maps[o->nb_stream_maps - 1];
314 m->linklabel = av_get_token(&c, "]");
316 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
320 if (allow_unused = strchr(map, '?'))
322 file_idx = strtol(map, &p, 0);
323 if (file_idx >= nb_input_files || file_idx < 0) {
324 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
328 /* disable some already defined maps */
329 for (i = 0; i < o->nb_stream_maps; i++) {
330 m = &o->stream_maps[i];
331 if (file_idx == m->file_index &&
332 check_stream_specifier(input_files[m->file_index]->ctx,
333 input_files[m->file_index]->ctx->streams[m->stream_index],
334 *p == ':' ? p + 1 : p) > 0)
338 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
339 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
340 *p == ':' ? p + 1 : p) <= 0)
342 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
343 m = &o->stream_maps[o->nb_stream_maps - 1];
345 m->file_index = file_idx;
348 if (sync_file_idx >= 0) {
349 m->sync_file_index = sync_file_idx;
350 m->sync_stream_index = sync_stream_idx;
352 m->sync_file_index = file_idx;
353 m->sync_stream_index = i;
360 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
362 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
363 "To ignore this, add a trailing '?' to the map.\n", arg);
372 static int opt_attach(void *optctx, const char *opt, const char *arg)
374 OptionsContext *o = optctx;
375 GROW_ARRAY(o->attachments, o->nb_attachments);
376 o->attachments[o->nb_attachments - 1] = arg;
380 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
382 OptionsContext *o = optctx;
388 mapchan = av_strdup(arg);
390 return AVERROR(ENOMEM);
392 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
393 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
395 /* muted channel syntax */
396 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
397 if ((n == 1 || n == 3) && m->channel_idx == -1) {
398 m->file_idx = m->stream_idx = -1;
400 m->ofile_idx = m->ostream_idx = -1;
406 n = sscanf(arg, "%d.%d.%d:%d.%d",
407 &m->file_idx, &m->stream_idx, &m->channel_idx,
408 &m->ofile_idx, &m->ostream_idx);
410 if (n != 3 && n != 5) {
411 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
412 "[file.stream.channel|-1][:syncfile:syncstream]\n");
416 if (n != 5) // only file.stream.channel specified
417 m->ofile_idx = m->ostream_idx = -1;
420 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
421 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
425 if (m->stream_idx < 0 ||
426 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
427 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
428 m->file_idx, m->stream_idx);
431 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
432 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
433 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
434 m->file_idx, m->stream_idx);
437 /* allow trailing ? to map_channel */
438 if (allow_unused = strchr(mapchan, '?'))
440 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
442 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
443 m->file_idx, m->stream_idx, m->channel_idx);
445 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
446 "To ignore this, add a trailing '?' to the map_channel.\n",
447 m->file_idx, m->stream_idx, m->channel_idx);
456 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
458 av_free(sdp_filename);
459 sdp_filename = av_strdup(arg);
464 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
467 const char *prefix = "vaapi:";
470 tmp = av_asprintf("%s%s", prefix, arg);
472 return AVERROR(ENOMEM);
473 err = hw_device_init_from_string(tmp, &dev);
477 hw_device_ctx = av_buffer_ref(dev->device_ref);
479 return AVERROR(ENOMEM);
484 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
486 if (!strcmp(arg, "list")) {
487 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
488 printf("Supported hardware device types:\n");
489 while ((type = av_hwdevice_iterate_types(type)) !=
490 AV_HWDEVICE_TYPE_NONE)
491 printf("%s\n", av_hwdevice_get_type_name(type));
495 return hw_device_init_from_string(arg, NULL);
499 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
501 if (filter_hw_device) {
502 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
503 return AVERROR(EINVAL);
505 filter_hw_device = hw_device_get_by_name(arg);
506 if (!filter_hw_device) {
507 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
508 return AVERROR(EINVAL);
514 * Parse a metadata specifier passed as 'arg' parameter.
515 * @param arg metadata string to parse
516 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
517 * @param index for type c/p, chapter/program index is written here
518 * @param stream_spec for type s, the stream specifier is written here
520 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
528 if (*(++arg) && *arg != ':') {
529 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
532 *stream_spec = *arg == ':' ? arg + 1 : "";
537 *index = strtol(++arg, NULL, 0);
540 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
547 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
549 AVDictionary **meta_in = NULL;
550 AVDictionary **meta_out = NULL;
552 char type_in, type_out;
553 const char *istream_spec = NULL, *ostream_spec = NULL;
554 int idx_in = 0, idx_out = 0;
556 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
557 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
560 if (type_out == 'g' || !*outspec)
561 o->metadata_global_manual = 1;
562 if (type_out == 's' || !*outspec)
563 o->metadata_streams_manual = 1;
564 if (type_out == 'c' || !*outspec)
565 o->metadata_chapters_manual = 1;
569 if (type_in == 'g' || type_out == 'g')
570 o->metadata_global_manual = 1;
571 if (type_in == 's' || type_out == 's')
572 o->metadata_streams_manual = 1;
573 if (type_in == 'c' || type_out == 'c')
574 o->metadata_chapters_manual = 1;
576 /* ic is NULL when just disabling automatic mappings */
580 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
581 if ((index) < 0 || (index) >= (nb_elems)) {\
582 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
587 #define SET_DICT(type, meta, context, index)\
590 meta = &context->metadata;\
593 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
594 meta = &context->chapters[index]->metadata;\
597 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
598 meta = &context->programs[index]->metadata;\
601 break; /* handled separately below */ \
602 default: av_assert0(0);\
605 SET_DICT(type_in, meta_in, ic, idx_in);
606 SET_DICT(type_out, meta_out, oc, idx_out);
608 /* for input streams choose first matching stream */
609 if (type_in == 's') {
610 for (i = 0; i < ic->nb_streams; i++) {
611 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
612 meta_in = &ic->streams[i]->metadata;
618 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
623 if (type_out == 's') {
624 for (i = 0; i < oc->nb_streams; i++) {
625 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
626 meta_out = &oc->streams[i]->metadata;
627 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
632 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
637 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
639 OptionsContext *o = optctx;
641 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
642 struct tm time = *gmtime((time_t*)&recording_timestamp);
643 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
645 parse_option(o, "metadata", buf, options);
647 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
648 "tag instead.\n", opt);
652 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
654 const AVCodecDescriptor *desc;
655 const char *codec_string = encoder ? "encoder" : "decoder";
659 avcodec_find_encoder_by_name(name) :
660 avcodec_find_decoder_by_name(name);
662 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
663 codec = encoder ? avcodec_find_encoder(desc->id) :
664 avcodec_find_decoder(desc->id);
666 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
667 codec_string, codec->name, desc->name);
671 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
674 if (codec->type != type) {
675 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
681 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
683 char *codec_name = NULL;
685 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
687 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
688 st->codecpar->codec_id = codec->id;
691 return avcodec_find_decoder(st->codecpar->codec_id);
694 /* Add all the streams from the given input file to the global
695 * list of input streams. */
696 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
700 for (i = 0; i < ic->nb_streams; i++) {
701 AVStream *st = ic->streams[i];
702 AVCodecParameters *par = st->codecpar;
703 InputStream *ist = av_mallocz(sizeof(*ist));
704 char *framerate = NULL, *hwaccel_device = NULL;
705 const char *hwaccel = NULL;
706 char *hwaccel_output_format = NULL;
707 char *codec_tag = NULL;
709 char *discard_str = NULL;
710 const AVClass *cc = avcodec_get_class();
711 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
716 GROW_ARRAY(input_streams, nb_input_streams);
717 input_streams[nb_input_streams - 1] = ist;
720 ist->file_index = nb_input_files;
722 st->discard = AVDISCARD_ALL;
724 ist->min_pts = INT64_MAX;
725 ist->max_pts = INT64_MIN;
728 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
731 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
733 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
735 uint32_t tag = strtol(codec_tag, &next, 0);
737 tag = AV_RL32(codec_tag);
738 st->codecpar->codec_tag = tag;
741 ist->dec = choose_decoder(o, ic, st);
742 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
744 ist->reinit_filters = -1;
745 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
747 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
748 ist->user_set_discard = AVDISCARD_NONE;
749 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
750 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
755 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
757 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
759 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
763 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
765 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
770 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
772 switch (par->codec_type) {
773 case AVMEDIA_TYPE_VIDEO:
775 ist->dec = avcodec_find_decoder(par->codec_id);
777 if (st->codec->lowres) {
778 ist->dec_ctx->lowres = st->codec->lowres;
779 ist->dec_ctx->width = st->codec->width;
780 ist->dec_ctx->height = st->codec->height;
781 ist->dec_ctx->coded_width = st->codec->coded_width;
782 ist->dec_ctx->coded_height = st->codec->coded_height;
786 // avformat_find_stream_info() doesn't set this for us anymore.
787 ist->dec_ctx->framerate = st->avg_frame_rate;
789 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
790 if (framerate && av_parse_video_rate(&ist->framerate,
792 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
797 ist->top_field_first = -1;
798 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
800 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
802 // The NVDEC hwaccels use a CUDA device, so remap the name here.
803 if (!strcmp(hwaccel, "nvdec"))
806 if (!strcmp(hwaccel, "none"))
807 ist->hwaccel_id = HWACCEL_NONE;
808 else if (!strcmp(hwaccel, "auto"))
809 ist->hwaccel_id = HWACCEL_AUTO;
811 enum AVHWDeviceType type;
813 for (i = 0; hwaccels[i].name; i++) {
814 if (!strcmp(hwaccels[i].name, hwaccel)) {
815 ist->hwaccel_id = hwaccels[i].id;
820 if (!ist->hwaccel_id) {
821 type = av_hwdevice_find_type_by_name(hwaccel);
822 if (type != AV_HWDEVICE_TYPE_NONE) {
823 ist->hwaccel_id = HWACCEL_GENERIC;
824 ist->hwaccel_device_type = type;
828 if (!ist->hwaccel_id) {
829 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
831 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
832 type = AV_HWDEVICE_TYPE_NONE;
833 while ((type = av_hwdevice_iterate_types(type)) !=
834 AV_HWDEVICE_TYPE_NONE)
835 av_log(NULL, AV_LOG_FATAL, "%s ",
836 av_hwdevice_get_type_name(type));
837 for (i = 0; hwaccels[i].name; i++)
838 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
839 av_log(NULL, AV_LOG_FATAL, "\n");
845 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
846 if (hwaccel_device) {
847 ist->hwaccel_device = av_strdup(hwaccel_device);
848 if (!ist->hwaccel_device)
852 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
853 hwaccel_output_format, ic, st);
854 if (hwaccel_output_format) {
855 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
856 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
857 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
858 "format: %s", hwaccel_output_format);
861 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
864 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
867 case AVMEDIA_TYPE_AUDIO:
868 ist->guess_layout_max = INT_MAX;
869 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
870 guess_input_channel_layout(ist);
872 case AVMEDIA_TYPE_DATA:
873 case AVMEDIA_TYPE_SUBTITLE: {
874 char *canvas_size = NULL;
876 ist->dec = avcodec_find_decoder(par->codec_id);
877 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
878 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
880 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
881 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
886 case AVMEDIA_TYPE_ATTACHMENT:
887 case AVMEDIA_TYPE_UNKNOWN:
893 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
895 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
901 static void assert_file_overwrite(const char *filename)
903 const char *proto_name = avio_find_protocol_name(filename);
905 if (file_overwrite && no_file_overwrite) {
906 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
910 if (!file_overwrite) {
911 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
912 if (stdin_interaction && !no_file_overwrite) {
913 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
916 signal(SIGINT, SIG_DFL);
918 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
924 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
930 if (proto_name && !strcmp(proto_name, "file")) {
931 for (int i = 0; i < nb_input_files; i++) {
932 InputFile *file = input_files[i];
933 if (file->ctx->iformat->flags & AVFMT_NOFILE)
935 if (!strcmp(filename, file->ctx->url)) {
936 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
937 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
944 static void dump_attachment(AVStream *st, const char *filename)
947 AVIOContext *out = NULL;
948 AVDictionaryEntry *e;
950 if (!st->codecpar->extradata_size) {
951 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
952 nb_input_files - 1, st->index);
955 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
958 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
959 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
963 assert_file_overwrite(filename);
965 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
966 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
971 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
976 static int open_input_file(OptionsContext *o, const char *filename)
980 AVInputFormat *file_iformat = NULL;
983 AVDictionary *unused_opts = NULL;
984 AVDictionaryEntry *e = NULL;
985 char * video_codec_name = NULL;
986 char * audio_codec_name = NULL;
987 char *subtitle_codec_name = NULL;
988 char * data_codec_name = NULL;
989 int scan_all_pmts_set = 0;
991 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
992 o->stop_time = INT64_MAX;
993 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
996 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
997 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
998 if (o->stop_time <= start_time) {
999 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1002 o->recording_time = o->stop_time - start_time;
1007 if (!(file_iformat = av_find_input_format(o->format))) {
1008 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1013 if (!strcmp(filename, "-"))
1016 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1017 strcmp(filename, "/dev/stdin");
1019 /* get default parameters from command line */
1020 ic = avformat_alloc_context();
1022 print_error(filename, AVERROR(ENOMEM));
1025 if (o->nb_audio_sample_rate) {
1026 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1028 if (o->nb_audio_channels) {
1029 /* because we set audio_channels based on both the "ac" and
1030 * "channel_layout" options, we need to check that the specified
1031 * demuxer actually has the "channels" option before setting it */
1032 if (file_iformat && file_iformat->priv_class &&
1033 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1034 AV_OPT_SEARCH_FAKE_OBJ)) {
1035 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1038 if (o->nb_frame_rates) {
1039 /* set the format-level framerate option;
1040 * this is important for video grabbers, e.g. x11 */
1041 if (file_iformat && file_iformat->priv_class &&
1042 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1043 AV_OPT_SEARCH_FAKE_OBJ)) {
1044 av_dict_set(&o->g->format_opts, "framerate",
1045 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1048 if (o->nb_frame_sizes) {
1049 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1051 if (o->nb_frame_pix_fmts)
1052 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1054 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1055 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1056 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1057 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1059 if (video_codec_name)
1060 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1061 if (audio_codec_name)
1062 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1063 if (subtitle_codec_name)
1064 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1065 if (data_codec_name)
1066 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1068 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1069 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1070 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1071 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1073 ic->flags |= AVFMT_FLAG_NONBLOCK;
1075 ic->flags |= AVFMT_FLAG_BITEXACT;
1076 ic->interrupt_callback = int_cb;
1078 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1079 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1080 scan_all_pmts_set = 1;
1082 /* open the input file with generic avformat function */
1083 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1085 print_error(filename, err);
1086 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1087 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1090 if (scan_all_pmts_set)
1091 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1092 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1093 assert_avoptions(o->g->format_opts);
1095 /* apply forced codec ids */
1096 for (i = 0; i < ic->nb_streams; i++)
1097 choose_decoder(o, ic, ic->streams[i]);
1099 if (find_stream_info) {
1100 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1101 int orig_nb_streams = ic->nb_streams;
1103 /* If not enough info to get the stream parameters, we decode the
1104 first frames to get it. (used in mpeg case for example) */
1105 ret = avformat_find_stream_info(ic, opts);
1107 for (i = 0; i < orig_nb_streams; i++)
1108 av_dict_free(&opts[i]);
1112 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1113 if (ic->nb_streams == 0) {
1114 avformat_close_input(&ic);
1120 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1121 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1122 o->start_time_eof = AV_NOPTS_VALUE;
1125 if (o->start_time_eof != AV_NOPTS_VALUE) {
1126 if (o->start_time_eof >= 0) {
1127 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1130 if (ic->duration > 0) {
1131 o->start_time = o->start_time_eof + ic->duration;
1132 if (o->start_time < 0) {
1133 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1134 o->start_time = AV_NOPTS_VALUE;
1137 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1139 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1140 /* add the stream start time */
1141 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1142 timestamp += ic->start_time;
1144 /* if seeking requested, we execute it */
1145 if (o->start_time != AV_NOPTS_VALUE) {
1146 int64_t seek_timestamp = timestamp;
1148 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1149 int dts_heuristic = 0;
1150 for (i=0; i<ic->nb_streams; i++) {
1151 const AVCodecParameters *par = ic->streams[i]->codecpar;
1152 if (par->video_delay) {
1157 if (dts_heuristic) {
1158 seek_timestamp -= 3*AV_TIME_BASE / 23;
1161 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1163 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1164 filename, (double)timestamp / AV_TIME_BASE);
1168 /* update the current parameters so that they match the one of the input stream */
1169 add_input_streams(o, ic);
1171 /* dump the file content */
1172 av_dump_format(ic, nb_input_files, filename, 0);
1174 GROW_ARRAY(input_files, nb_input_files);
1175 f = av_mallocz(sizeof(*f));
1178 input_files[nb_input_files - 1] = f;
1181 f->ist_index = nb_input_streams - ic->nb_streams;
1182 f->start_time = o->start_time;
1183 f->recording_time = o->recording_time;
1184 f->input_ts_offset = o->input_ts_offset;
1185 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1186 f->nb_streams = ic->nb_streams;
1187 f->rate_emu = o->rate_emu;
1188 f->accurate_seek = o->accurate_seek;
1191 f->time_base = (AVRational){ 1, 1 };
1193 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1196 /* check if all codec options have been used */
1197 unused_opts = strip_specifiers(o->g->codec_opts);
1198 for (i = f->ist_index; i < nb_input_streams; i++) {
1200 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1201 AV_DICT_IGNORE_SUFFIX)))
1202 av_dict_set(&unused_opts, e->key, NULL, 0);
1206 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1207 const AVClass *class = avcodec_get_class();
1208 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1209 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1210 const AVClass *fclass = avformat_get_class();
1211 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1212 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1213 if (!option || foption)
1217 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1218 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1219 "input file #%d (%s) is not a decoding option.\n", e->key,
1220 option->help ? option->help : "", nb_input_files - 1,
1225 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1226 "input file #%d (%s) has not been used for any stream. The most "
1227 "likely reason is either wrong type (e.g. a video option with "
1228 "no video streams) or that it is a private option of some decoder "
1229 "which was not actually used for any stream.\n", e->key,
1230 option->help ? option->help : "", nb_input_files - 1, filename);
1232 av_dict_free(&unused_opts);
1234 for (i = 0; i < o->nb_dump_attachment; i++) {
1237 for (j = 0; j < ic->nb_streams; j++) {
1238 AVStream *st = ic->streams[j];
1240 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1241 dump_attachment(st, o->dump_attachment[i].u.str);
1245 input_stream_potentially_available = 1;
1250 static uint8_t *get_line(AVIOContext *s)
1256 if (avio_open_dyn_buf(&line) < 0) {
1257 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1261 while ((c = avio_r8(s)) && c != '\n')
1264 avio_close_dyn_buf(line, &buf);
1269 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1272 char filename[1000];
1273 const char *base[3] = { getenv("AVCONV_DATADIR"),
1278 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1282 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1283 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1284 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1287 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1288 i != 1 ? "" : "/.avconv", preset_name);
1289 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1295 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1297 enum AVMediaType type = ost->st->codecpar->codec_type;
1298 char *codec_name = NULL;
1300 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1301 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1303 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1304 NULL, ost->st->codecpar->codec_type);
1305 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1307 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1308 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1309 "probably disabled. Please choose an encoder manually.\n",
1310 ost->file_index, ost->index, s->oformat->name,
1311 avcodec_get_name(ost->st->codecpar->codec_id));
1312 return AVERROR_ENCODER_NOT_FOUND;
1314 } else if (!strcmp(codec_name, "copy"))
1315 ost->stream_copy = 1;
1317 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1318 ost->st->codecpar->codec_id = ost->enc->id;
1320 ost->encoding_needed = !ost->stream_copy;
1322 /* no encoding supported for other media types */
1323 ost->stream_copy = 1;
1324 ost->encoding_needed = 0;
1330 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1333 AVStream *st = avformat_new_stream(oc, NULL);
1334 int idx = oc->nb_streams - 1, ret = 0;
1335 const char *bsfs = NULL, *time_base = NULL;
1336 char *next, *codec_tag = NULL;
1341 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1345 if (oc->nb_streams - 1 < o->nb_streamid_map)
1346 st->id = o->streamid_map[oc->nb_streams - 1];
1348 GROW_ARRAY(output_streams, nb_output_streams);
1349 if (!(ost = av_mallocz(sizeof(*ost))))
1351 output_streams[nb_output_streams - 1] = ost;
1353 ost->file_index = nb_output_files - 1;
1356 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1357 st->codecpar->codec_type = type;
1359 ret = choose_encoder(o, oc, ost);
1361 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1362 "%d:%d\n", ost->file_index, ost->index);
1366 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1367 if (!ost->enc_ctx) {
1368 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1371 ost->enc_ctx->codec_type = type;
1373 ost->ref_par = avcodec_parameters_alloc();
1374 if (!ost->ref_par) {
1375 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1380 AVIOContext *s = NULL;
1381 char *buf = NULL, *arg = NULL, *preset = NULL;
1383 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1385 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1386 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1389 if (!buf[0] || buf[0] == '#') {
1393 if (!(arg = strchr(buf, '='))) {
1394 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1398 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1400 } while (!s->eof_reached);
1404 av_log(NULL, AV_LOG_FATAL,
1405 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1406 preset, ost->file_index, ost->index);
1410 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1415 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1417 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1420 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1421 q.num <= 0 || q.den <= 0) {
1422 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1428 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1431 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1433 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1436 ost->enc_timebase = q;
1439 ost->max_frames = INT64_MAX;
1440 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1441 for (i = 0; i<o->nb_max_frames; i++) {
1442 char *p = o->max_frames[i].specifier;
1443 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1444 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1449 ost->copy_prior_start = -1;
1450 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1452 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1453 while (bsfs && *bsfs) {
1454 const AVBitStreamFilter *filter;
1455 char *bsf, *bsf_options_str, *bsf_name;
1457 bsf = av_get_token(&bsfs, ",");
1460 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1464 filter = av_bsf_get_by_name(bsf_name);
1466 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1470 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1471 ost->nb_bitstream_filters + 1,
1472 sizeof(*ost->bsf_ctx));
1476 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1478 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1482 ost->nb_bitstream_filters++;
1484 if (bsf_options_str && filter->priv_class) {
1485 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1486 const char * shorthand[2] = {NULL};
1489 shorthand[0] = opt->name;
1491 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1493 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1503 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1505 uint32_t tag = strtol(codec_tag, &next, 0);
1507 tag = AV_RL32(codec_tag);
1508 ost->st->codecpar->codec_tag =
1509 ost->enc_ctx->codec_tag = tag;
1512 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1514 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1515 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1518 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1519 ost->disposition = av_strdup(ost->disposition);
1521 ost->max_muxing_queue_size = 128;
1522 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1523 ost->max_muxing_queue_size *= sizeof(AVPacket);
1525 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1526 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1528 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1530 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1531 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1532 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1534 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1536 ost->source_index = source_index;
1537 if (source_index >= 0) {
1538 ost->sync_ist = input_streams[source_index];
1539 input_streams[source_index]->discard = 0;
1540 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1542 ost->last_mux_dts = AV_NOPTS_VALUE;
1544 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1545 if (!ost->muxing_queue)
1551 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1554 const char *p = str;
1561 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1568 /* read file contents into a string */
1569 static uint8_t *read_file(const char *filename)
1571 AVIOContext *pb = NULL;
1572 AVIOContext *dyn_buf = NULL;
1573 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1574 uint8_t buf[1024], *str;
1577 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1581 ret = avio_open_dyn_buf(&dyn_buf);
1586 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1587 avio_write(dyn_buf, buf, ret);
1588 avio_w8(dyn_buf, 0);
1591 ret = avio_close_dyn_buf(dyn_buf, &str);
1597 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1600 AVStream *st = ost->st;
1602 if (ost->filters_script && ost->filters) {
1603 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1604 "output stream #%d:%d.\n", nb_output_files, st->index);
1608 if (ost->filters_script)
1609 return read_file(ost->filters_script);
1610 else if (ost->filters)
1611 return av_strdup(ost->filters);
1613 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1617 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1618 const OutputStream *ost, enum AVMediaType type)
1620 if (ost->filters_script || ost->filters) {
1621 av_log(NULL, AV_LOG_ERROR,
1622 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1623 "Filtering and streamcopy cannot be used together.\n",
1624 ost->filters ? "Filtergraph" : "Filtergraph script",
1625 ost->filters ? ost->filters : ost->filters_script,
1626 av_get_media_type_string(type), ost->file_index, ost->index);
1631 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1635 AVCodecContext *video_enc;
1636 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1638 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1640 video_enc = ost->enc_ctx;
1642 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1643 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1644 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1647 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1648 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1650 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1651 if (frame_aspect_ratio) {
1653 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1654 q.num <= 0 || q.den <= 0) {
1655 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1658 ost->frame_aspect_ratio = q;
1661 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1662 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1664 if (!ost->stream_copy) {
1665 const char *p = NULL;
1666 char *frame_size = NULL;
1667 char *frame_pix_fmt = NULL;
1668 char *intra_matrix = NULL, *inter_matrix = NULL;
1669 char *chroma_intra_matrix = NULL;
1673 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1674 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1675 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1679 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1680 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1681 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1682 ost->keep_pix_fmt = 1;
1683 if (!*++frame_pix_fmt)
1684 frame_pix_fmt = NULL;
1686 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1687 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1690 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1693 video_enc->gop_size = 0;
1694 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1696 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1697 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1700 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1702 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1703 if (chroma_intra_matrix) {
1704 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1706 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1709 video_enc->chroma_intra_matrix = p;
1710 parse_matrix_coeffs(p, chroma_intra_matrix);
1712 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1714 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1715 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1718 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1721 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1722 for (i = 0; p; i++) {
1724 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1726 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1729 video_enc->rc_override =
1730 av_realloc_array(video_enc->rc_override,
1731 i + 1, sizeof(RcOverride));
1732 if (!video_enc->rc_override) {
1733 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1736 video_enc->rc_override[i].start_frame = start;
1737 video_enc->rc_override[i].end_frame = end;
1739 video_enc->rc_override[i].qscale = q;
1740 video_enc->rc_override[i].quality_factor = 1.0;
1743 video_enc->rc_override[i].qscale = 0;
1744 video_enc->rc_override[i].quality_factor = -q/100.0;
1749 video_enc->rc_override_count = i;
1752 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1755 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1758 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1759 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1762 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1763 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1767 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1768 if (ost->logfile_prefix &&
1769 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1773 char logfilename[1024];
1776 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1777 ost->logfile_prefix ? ost->logfile_prefix :
1778 DEFAULT_PASS_LOGFILENAME_PREFIX,
1780 if (!strcmp(ost->enc->name, "libx264")) {
1781 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1783 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1784 char *logbuffer = read_file(logfilename);
1787 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1791 video_enc->stats_in = logbuffer;
1793 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1794 f = av_fopen_utf8(logfilename, "wb");
1796 av_log(NULL, AV_LOG_FATAL,
1797 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1798 logfilename, strerror(errno));
1806 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1807 if (ost->forced_keyframes)
1808 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1810 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1812 ost->top_field_first = -1;
1813 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1816 ost->avfilter = get_ost_filters(o, oc, ost);
1820 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1823 if (ost->stream_copy)
1824 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1829 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1834 AVCodecContext *audio_enc;
1836 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1839 audio_enc = ost->enc_ctx;
1840 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1842 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1843 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1845 if (!ost->stream_copy) {
1846 char *sample_fmt = NULL;
1848 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1850 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1852 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1853 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1857 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1859 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1860 ost->apad = av_strdup(ost->apad);
1862 ost->avfilter = get_ost_filters(o, oc, ost);
1866 /* check for channel mapping for this audio stream */
1867 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1868 AudioChannelMap *map = &o->audio_channel_maps[n];
1869 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1870 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1873 if (map->channel_idx == -1) {
1875 } else if (ost->source_index < 0) {
1876 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1877 ost->file_index, ost->st->index);
1880 ist = input_streams[ost->source_index];
1883 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1884 if (av_reallocp_array(&ost->audio_channels_map,
1885 ost->audio_channels_mapped + 1,
1886 sizeof(*ost->audio_channels_map)
1890 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1896 if (ost->stream_copy)
1897 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1902 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1906 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1907 if (!ost->stream_copy) {
1908 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1915 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1919 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1920 if (!ost->stream_copy) {
1921 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1928 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1930 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1931 ost->stream_copy = 1;
1936 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1940 AVCodecContext *subtitle_enc;
1942 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1944 subtitle_enc = ost->enc_ctx;
1946 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1948 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1950 if (!ost->stream_copy) {
1951 char *frame_size = NULL;
1953 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1954 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1955 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1963 /* arg format is "output-stream-index:streamid-value". */
1964 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1966 OptionsContext *o = optctx;
1971 av_strlcpy(idx_str, arg, sizeof(idx_str));
1972 p = strchr(idx_str, ':');
1974 av_log(NULL, AV_LOG_FATAL,
1975 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1980 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1981 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1982 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1986 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1988 AVFormatContext *is = ifile->ctx;
1989 AVFormatContext *os = ofile->ctx;
1993 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1995 return AVERROR(ENOMEM);
1998 for (i = 0; i < is->nb_chapters; i++) {
1999 AVChapter *in_ch = is->chapters[i], *out_ch;
2000 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2001 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2002 AV_TIME_BASE_Q, in_ch->time_base);
2003 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2004 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2007 if (in_ch->end < ts_off)
2009 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2012 out_ch = av_mallocz(sizeof(AVChapter));
2014 return AVERROR(ENOMEM);
2016 out_ch->id = in_ch->id;
2017 out_ch->time_base = in_ch->time_base;
2018 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2019 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2022 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2024 os->chapters[os->nb_chapters++] = out_ch;
2029 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2030 AVFormatContext *oc)
2034 switch (ofilter->type) {
2035 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2036 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2038 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2043 ost->source_index = -1;
2044 ost->filter = ofilter;
2047 ofilter->format = -1;
2049 if (ost->stream_copy) {
2050 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2051 "which is fed from a complex filtergraph. Filtering and streamcopy "
2052 "cannot be used together.\n", ost->file_index, ost->index);
2056 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2057 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2058 av_log(NULL, AV_LOG_ERROR,
2059 "%s '%s' was specified through the %s option "
2060 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2061 "%s and -filter_complex cannot be used together for the same stream.\n",
2062 ost->filters ? "Filtergraph" : "Filtergraph script",
2063 ost->filters ? ost->filters : ost->filters_script,
2064 opt, ost->file_index, ost->index, opt);
2068 avfilter_inout_free(&ofilter->out_tmp);
2071 static int init_complex_filters(void)
2075 for (i = 0; i < nb_filtergraphs; i++) {
2076 ret = init_complex_filtergraph(filtergraphs[i]);
2083 static int open_output_file(OptionsContext *o, const char *filename)
2085 AVFormatContext *oc;
2090 AVDictionary *unused_opts = NULL;
2091 AVDictionaryEntry *e = NULL;
2092 int format_flags = 0;
2094 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2095 o->stop_time = INT64_MAX;
2096 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2099 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2100 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2101 if (o->stop_time <= start_time) {
2102 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2105 o->recording_time = o->stop_time - start_time;
2109 GROW_ARRAY(output_files, nb_output_files);
2110 of = av_mallocz(sizeof(*of));
2113 output_files[nb_output_files - 1] = of;
2115 of->ost_index = nb_output_streams;
2116 of->recording_time = o->recording_time;
2117 of->start_time = o->start_time;
2118 of->limit_filesize = o->limit_filesize;
2119 of->shortest = o->shortest;
2120 av_dict_copy(&of->opts, o->g->format_opts, 0);
2122 if (!strcmp(filename, "-"))
2125 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2127 print_error(filename, err);
2132 if (o->recording_time != INT64_MAX)
2133 oc->duration = o->recording_time;
2135 oc->interrupt_callback = int_cb;
2137 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2139 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2140 av_opt_eval_flags(oc, o, e->value, &format_flags);
2143 format_flags |= AVFMT_FLAG_BITEXACT;
2144 oc->flags |= AVFMT_FLAG_BITEXACT;
2147 /* create streams for all unlabeled output pads */
2148 for (i = 0; i < nb_filtergraphs; i++) {
2149 FilterGraph *fg = filtergraphs[i];
2150 for (j = 0; j < fg->nb_outputs; j++) {
2151 OutputFilter *ofilter = fg->outputs[j];
2153 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2156 switch (ofilter->type) {
2157 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2158 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2159 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2161 init_output_filter(ofilter, o, oc);
2165 if (!o->nb_stream_maps) {
2166 char *subtitle_codec_name = NULL;
2167 /* pick the "best" stream of each type */
2169 /* video: highest resolution */
2170 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2171 int area = 0, idx = -1;
2172 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2173 for (i = 0; i < nb_input_streams; i++) {
2175 ist = input_streams[i];
2176 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2177 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2179 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2181 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2188 new_video_stream(o, oc, idx);
2191 /* audio: most channels */
2192 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2193 int best_score = 0, idx = -1;
2194 for (i = 0; i < nb_input_streams; i++) {
2196 ist = input_streams[i];
2197 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2198 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2199 score > best_score) {
2205 new_audio_stream(o, oc, idx);
2208 /* subtitles: pick first */
2209 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2210 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2211 for (i = 0; i < nb_input_streams; i++)
2212 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2213 AVCodecDescriptor const *input_descriptor =
2214 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2215 AVCodecDescriptor const *output_descriptor = NULL;
2216 AVCodec const *output_codec =
2217 avcodec_find_encoder(oc->oformat->subtitle_codec);
2218 int input_props = 0, output_props = 0;
2220 output_descriptor = avcodec_descriptor_get(output_codec->id);
2221 if (input_descriptor)
2222 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2223 if (output_descriptor)
2224 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2225 if (subtitle_codec_name ||
2226 input_props & output_props ||
2227 // Map dvb teletext which has neither property to any output subtitle encoder
2228 input_descriptor && output_descriptor &&
2229 (!input_descriptor->props ||
2230 !output_descriptor->props)) {
2231 new_subtitle_stream(o, oc, i);
2236 /* Data only if codec id match */
2237 if (!o->data_disable ) {
2238 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2239 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2240 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2241 && input_streams[i]->st->codecpar->codec_id == codec_id )
2242 new_data_stream(o, oc, i);
2246 for (i = 0; i < o->nb_stream_maps; i++) {
2247 StreamMap *map = &o->stream_maps[i];
2252 if (map->linklabel) {
2254 OutputFilter *ofilter = NULL;
2257 for (j = 0; j < nb_filtergraphs; j++) {
2258 fg = filtergraphs[j];
2259 for (k = 0; k < fg->nb_outputs; k++) {
2260 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2261 if (out && !strcmp(out->name, map->linklabel)) {
2262 ofilter = fg->outputs[k];
2269 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2270 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2273 init_output_filter(ofilter, o, oc);
2275 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2277 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2278 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2280 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2282 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2284 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2288 switch (ist->st->codecpar->codec_type) {
2289 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2290 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2291 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2292 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2293 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2294 case AVMEDIA_TYPE_UNKNOWN:
2295 if (copy_unknown_streams) {
2296 ost = new_unknown_stream (o, oc, src_idx);
2300 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2301 "Cannot map stream #%d:%d - unsupported type.\n",
2302 map->file_index, map->stream_index);
2303 if (!ignore_unknown_streams) {
2304 av_log(NULL, AV_LOG_FATAL,
2305 "If you want unsupported types ignored instead "
2306 "of failing, please use the -ignore_unknown option\n"
2307 "If you want them copied, please use -copy_unknown\n");
2312 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2313 + map->sync_stream_index];
2318 /* handle attached files */
2319 for (i = 0; i < o->nb_attachments; i++) {
2321 uint8_t *attachment;
2325 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2326 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2330 if ((len = avio_size(pb)) <= 0) {
2331 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2335 if (!(attachment = av_malloc(len))) {
2336 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2340 avio_read(pb, attachment, len);
2342 ost = new_attachment_stream(o, oc, -1);
2343 ost->stream_copy = 0;
2344 ost->attachment_filename = o->attachments[i];
2345 ost->st->codecpar->extradata = attachment;
2346 ost->st->codecpar->extradata_size = len;
2348 p = strrchr(o->attachments[i], '/');
2349 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2353 #if FF_API_LAVF_AVCTX
2354 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2355 AVDictionaryEntry *e;
2356 ost = output_streams[i];
2358 if ((ost->stream_copy || ost->attachment_filename)
2359 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2360 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2361 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2366 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2367 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2368 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2372 /* check if all codec options have been used */
2373 unused_opts = strip_specifiers(o->g->codec_opts);
2374 for (i = of->ost_index; i < nb_output_streams; i++) {
2376 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2377 AV_DICT_IGNORE_SUFFIX)))
2378 av_dict_set(&unused_opts, e->key, NULL, 0);
2382 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2383 const AVClass *class = avcodec_get_class();
2384 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2385 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2386 const AVClass *fclass = avformat_get_class();
2387 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2388 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2389 if (!option || foption)
2393 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2394 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2395 "output file #%d (%s) is not an encoding option.\n", e->key,
2396 option->help ? option->help : "", nb_output_files - 1,
2401 // gop_timecode is injected by generic code but not always used
2402 if (!strcmp(e->key, "gop_timecode"))
2405 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2406 "output file #%d (%s) has not been used for any stream. The most "
2407 "likely reason is either wrong type (e.g. a video option with "
2408 "no video streams) or that it is a private option of some encoder "
2409 "which was not actually used for any stream.\n", e->key,
2410 option->help ? option->help : "", nb_output_files - 1, filename);
2412 av_dict_free(&unused_opts);
2414 /* set the decoding_needed flags and create simple filtergraphs */
2415 for (i = of->ost_index; i < nb_output_streams; i++) {
2416 OutputStream *ost = output_streams[i];
2418 if (ost->encoding_needed && ost->source_index >= 0) {
2419 InputStream *ist = input_streams[ost->source_index];
2420 ist->decoding_needed |= DECODING_FOR_OST;
2422 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2423 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2424 err = init_simple_filtergraph(ist, ost);
2426 av_log(NULL, AV_LOG_ERROR,
2427 "Error initializing a simple filtergraph between streams "
2428 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2429 nb_output_files - 1, ost->st->index);
2435 /* set the filter output constraints */
2437 OutputFilter *f = ost->filter;
2439 switch (ost->enc_ctx->codec_type) {
2440 case AVMEDIA_TYPE_VIDEO:
2441 f->frame_rate = ost->frame_rate;
2442 f->width = ost->enc_ctx->width;
2443 f->height = ost->enc_ctx->height;
2444 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2445 f->format = ost->enc_ctx->pix_fmt;
2446 } else if (ost->enc->pix_fmts) {
2448 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2450 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2453 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2456 case AVMEDIA_TYPE_AUDIO:
2457 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2458 f->format = ost->enc_ctx->sample_fmt;
2459 } else if (ost->enc->sample_fmts) {
2461 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2463 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2466 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2468 if (ost->enc_ctx->sample_rate) {
2469 f->sample_rate = ost->enc_ctx->sample_rate;
2470 } else if (ost->enc->supported_samplerates) {
2472 while (ost->enc->supported_samplerates[count])
2474 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2475 if (!f->sample_rates)
2477 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2478 (count + 1) * sizeof(*f->sample_rates));
2480 if (ost->enc_ctx->channels) {
2481 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2482 } else if (ost->enc->channel_layouts) {
2484 while (ost->enc->channel_layouts[count])
2486 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2487 if (!f->channel_layouts)
2489 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2490 (count + 1) * sizeof(*f->channel_layouts));
2497 /* check filename in case of an image number is expected */
2498 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2499 if (!av_filename_number_test(oc->url)) {
2500 print_error(oc->url, AVERROR(EINVAL));
2505 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2506 av_log(NULL, AV_LOG_ERROR,
2507 "No input streams but output needs an input stream\n");
2511 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2512 /* test if it already exists to avoid losing precious files */
2513 assert_file_overwrite(filename);
2516 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2517 &oc->interrupt_callback,
2519 print_error(filename, err);
2522 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2523 assert_file_overwrite(filename);
2525 if (o->mux_preload) {
2526 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2528 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2531 for (i = 0; i < o->nb_metadata_map; i++) {
2533 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2535 if (in_file_index >= nb_input_files) {
2536 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2539 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2540 in_file_index >= 0 ?
2541 input_files[in_file_index]->ctx : NULL, o);
2545 if (o->chapters_input_file >= nb_input_files) {
2546 if (o->chapters_input_file == INT_MAX) {
2547 /* copy chapters from the first input file that has them*/
2548 o->chapters_input_file = -1;
2549 for (i = 0; i < nb_input_files; i++)
2550 if (input_files[i]->ctx->nb_chapters) {
2551 o->chapters_input_file = i;
2555 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2556 o->chapters_input_file);
2560 if (o->chapters_input_file >= 0)
2561 copy_chapters(input_files[o->chapters_input_file], of,
2562 !o->metadata_chapters_manual);
2564 /* copy global metadata by default */
2565 if (!o->metadata_global_manual && nb_input_files){
2566 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2567 AV_DICT_DONT_OVERWRITE);
2568 if(o->recording_time != INT64_MAX)
2569 av_dict_set(&oc->metadata, "duration", NULL, 0);
2570 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2572 if (!o->metadata_streams_manual)
2573 for (i = of->ost_index; i < nb_output_streams; i++) {
2575 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2577 ist = input_streams[output_streams[i]->source_index];
2578 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2579 if (!output_streams[i]->stream_copy) {
2580 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2584 /* process manually set programs */
2585 for (i = 0; i < o->nb_program; i++) {
2586 const char *p = o->program[i].u.str;
2591 const char *p2 = av_get_token(&p, ":");
2592 const char *to_dealloc = p2;
2599 key = av_get_token(&p2, "=");
2601 av_freep(&to_dealloc);
2607 if (!strcmp(key, "program_num"))
2608 progid = strtol(p2, NULL, 0);
2609 av_freep(&to_dealloc);
2613 program = av_new_program(oc, progid);
2615 p = o->program[i].u.str;
2617 const char *p2 = av_get_token(&p, ":");
2618 const char *to_dealloc = p2;
2624 key = av_get_token(&p2, "=");
2626 av_log(NULL, AV_LOG_FATAL,
2627 "No '=' character in program string %s.\n",
2635 if (!strcmp(key, "title")) {
2636 av_dict_set(&program->metadata, "title", p2, 0);
2637 } else if (!strcmp(key, "program_num")) {
2638 } else if (!strcmp(key, "st")) {
2639 int st_num = strtol(p2, NULL, 0);
2640 av_program_add_stream_index(oc, progid, st_num);
2642 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2645 av_freep(&to_dealloc);
2650 /* process manually set metadata */
2651 for (i = 0; i < o->nb_metadata; i++) {
2654 const char *stream_spec;
2655 int index = 0, j, ret = 0;
2657 val = strchr(o->metadata[i].u.str, '=');
2659 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2660 o->metadata[i].u.str);
2665 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2667 for (j = 0; j < oc->nb_streams; j++) {
2668 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2669 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2670 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2672 double theta = av_strtod(val, &tail);
2674 ost->rotate_overridden = 1;
2675 ost->rotate_override_value = theta;
2678 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2690 if (index < 0 || index >= oc->nb_chapters) {
2691 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2694 m = &oc->chapters[index]->metadata;
2697 if (index < 0 || index >= oc->nb_programs) {
2698 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2701 m = &oc->programs[index]->metadata;
2704 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2707 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2714 static int opt_target(void *optctx, const char *opt, const char *arg)
2716 OptionsContext *o = optctx;
2717 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2718 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2720 if (!strncmp(arg, "pal-", 4)) {
2723 } else if (!strncmp(arg, "ntsc-", 5)) {
2726 } else if (!strncmp(arg, "film-", 5)) {
2730 /* Try to determine PAL/NTSC by peeking in the input files */
2731 if (nb_input_files) {
2733 for (j = 0; j < nb_input_files; j++) {
2734 for (i = 0; i < input_files[j]->nb_streams; i++) {
2735 AVStream *st = input_files[j]->ctx->streams[i];
2736 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2738 fr = st->time_base.den * 1000 / st->time_base.num;
2742 } else if ((fr == 29970) || (fr == 23976)) {
2747 if (norm != UNKNOWN)
2751 if (norm != UNKNOWN)
2752 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2755 if (norm == UNKNOWN) {
2756 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2757 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2758 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2762 if (!strcmp(arg, "vcd")) {
2763 opt_video_codec(o, "c:v", "mpeg1video");
2764 opt_audio_codec(o, "c:a", "mp2");
2765 parse_option(o, "f", "vcd", options);
2767 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2768 parse_option(o, "r", frame_rates[norm], options);
2769 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2771 opt_default(NULL, "b:v", "1150000");
2772 opt_default(NULL, "maxrate:v", "1150000");
2773 opt_default(NULL, "minrate:v", "1150000");
2774 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2776 opt_default(NULL, "b:a", "224000");
2777 parse_option(o, "ar", "44100", options);
2778 parse_option(o, "ac", "2", options);
2780 opt_default(NULL, "packetsize", "2324");
2781 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2783 /* We have to offset the PTS, so that it is consistent with the SCR.
2784 SCR starts at 36000, but the first two packs contain only padding
2785 and the first pack from the other stream, respectively, may also have
2786 been written before.
2787 So the real data starts at SCR 36000+3*1200. */
2788 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2789 } else if (!strcmp(arg, "svcd")) {
2791 opt_video_codec(o, "c:v", "mpeg2video");
2792 opt_audio_codec(o, "c:a", "mp2");
2793 parse_option(o, "f", "svcd", options);
2795 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2796 parse_option(o, "r", frame_rates[norm], options);
2797 parse_option(o, "pix_fmt", "yuv420p", options);
2798 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2800 opt_default(NULL, "b:v", "2040000");
2801 opt_default(NULL, "maxrate:v", "2516000");
2802 opt_default(NULL, "minrate:v", "0"); // 1145000;
2803 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2804 opt_default(NULL, "scan_offset", "1");
2806 opt_default(NULL, "b:a", "224000");
2807 parse_option(o, "ar", "44100", options);
2809 opt_default(NULL, "packetsize", "2324");
2811 } else if (!strcmp(arg, "dvd")) {
2813 opt_video_codec(o, "c:v", "mpeg2video");
2814 opt_audio_codec(o, "c:a", "ac3");
2815 parse_option(o, "f", "dvd", options);
2817 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2818 parse_option(o, "r", frame_rates[norm], options);
2819 parse_option(o, "pix_fmt", "yuv420p", options);
2820 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2822 opt_default(NULL, "b:v", "6000000");
2823 opt_default(NULL, "maxrate:v", "9000000");
2824 opt_default(NULL, "minrate:v", "0"); // 1500000;
2825 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2827 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2828 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2830 opt_default(NULL, "b:a", "448000");
2831 parse_option(o, "ar", "48000", options);
2833 } else if (!strncmp(arg, "dv", 2)) {
2835 parse_option(o, "f", "dv", options);
2837 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2838 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2839 norm == PAL ? "yuv420p" : "yuv411p", options);
2840 parse_option(o, "r", frame_rates[norm], options);
2842 parse_option(o, "ar", "48000", options);
2843 parse_option(o, "ac", "2", options);
2846 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2847 return AVERROR(EINVAL);
2850 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2851 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2856 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2858 av_free (vstats_filename);
2859 vstats_filename = av_strdup (arg);
2863 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2866 time_t today2 = time(NULL);
2867 struct tm *today = localtime(&today2);
2869 if (!today) { // maybe tomorrow
2870 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2874 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2876 return opt_vstats_file(NULL, opt, filename);
2879 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2881 OptionsContext *o = optctx;
2882 return parse_option(o, "frames:v", arg, options);
2885 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2887 OptionsContext *o = optctx;
2888 return parse_option(o, "frames:a", arg, options);
2891 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2893 OptionsContext *o = optctx;
2894 return parse_option(o, "frames:d", arg, options);
2897 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2900 AVDictionary *cbak = codec_opts;
2901 AVDictionary *fbak = format_opts;
2905 ret = opt_default(NULL, opt, arg);
2907 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2908 av_dict_copy(&o->g->format_opts, format_opts, 0);
2909 av_dict_free(&codec_opts);
2910 av_dict_free(&format_opts);
2917 static int opt_preset(void *optctx, const char *opt, const char *arg)
2919 OptionsContext *o = optctx;
2921 char filename[1000], line[1000], tmp_line[1000];
2922 const char *codec_name = NULL;
2926 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2928 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2929 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2930 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2932 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2936 while (fgets(line, sizeof(line), f)) {
2937 char *key = tmp_line, *value, *endptr;
2939 if (strcspn(line, "#\n\r") == 0)
2941 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2942 if (!av_strtok(key, "=", &value) ||
2943 !av_strtok(value, "\r\n", &endptr)) {
2944 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2947 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2949 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2950 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2951 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2952 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2953 else if (opt_default_new(o, key, value) < 0) {
2954 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2955 filename, line, key, value);
2965 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2967 OptionsContext *o = optctx;
2968 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2969 int ret = parse_option(o, s, arg, options);
2974 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2976 OptionsContext *o = optctx;
2978 if(!strcmp(opt, "ab")){
2979 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2981 } else if(!strcmp(opt, "b")){
2982 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2983 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2986 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2990 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2992 OptionsContext *o = optctx;
2995 if(!strcmp(opt, "qscale")){
2996 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2997 return parse_option(o, "q:v", arg, options);
2999 s = av_asprintf("q%s", opt + 6);
3000 ret = parse_option(o, s, arg, options);
3005 static int opt_profile(void *optctx, const char *opt, const char *arg)
3007 OptionsContext *o = optctx;
3008 if(!strcmp(opt, "profile")){
3009 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3010 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3013 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3017 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3019 OptionsContext *o = optctx;
3020 return parse_option(o, "filter:v", arg, options);
3023 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3025 OptionsContext *o = optctx;
3026 return parse_option(o, "filter:a", arg, options);
3029 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3031 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3032 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3033 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3034 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3036 if (video_sync_method == VSYNC_AUTO)
3037 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3041 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3043 OptionsContext *o = optctx;
3044 char *tcr = av_asprintf("timecode=%s", arg);
3045 int ret = parse_option(o, "metadata:g", tcr, options);
3047 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3052 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3054 OptionsContext *o = optctx;
3055 char layout_str[32];
3058 int ret, channels, ac_str_size;
3061 layout = av_get_channel_layout(arg);
3063 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3064 return AVERROR(EINVAL);
3066 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3067 ret = opt_default_new(o, opt, layout_str);
3071 /* set 'ac' option based on channel layout */
3072 channels = av_get_channel_layout_nb_channels(layout);
3073 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3074 stream_str = strchr(opt, ':');
3075 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3076 ac_str = av_mallocz(ac_str_size);
3078 return AVERROR(ENOMEM);
3079 av_strlcpy(ac_str, "ac", 3);
3081 av_strlcat(ac_str, stream_str, ac_str_size);
3082 ret = parse_option(o, ac_str, layout_str, options);
3088 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3090 OptionsContext *o = optctx;
3091 return parse_option(o, "q:a", arg, options);
3094 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3096 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3097 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3098 return AVERROR(ENOMEM);
3099 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3100 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3101 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3102 return AVERROR(ENOMEM);
3104 input_stream_potentially_available = 1;
3109 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3111 uint8_t *graph_desc = read_file(arg);
3113 return AVERROR(EINVAL);
3115 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3116 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3117 return AVERROR(ENOMEM);
3118 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3119 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3121 input_stream_potentially_available = 1;
3126 void show_help_default(const char *opt, const char *arg)
3128 /* per-file options have at least one of those set */
3129 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3130 int show_advanced = 0, show_avoptions = 0;
3133 if (!strcmp(opt, "long"))
3135 else if (!strcmp(opt, "full"))
3136 show_advanced = show_avoptions = 1;
3138 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3143 printf("Getting help:\n"
3144 " -h -- print basic options\n"
3145 " -h long -- print more options\n"
3146 " -h full -- print all options (including all format and codec specific options, very long)\n"
3147 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3148 " See man %s for detailed description of the options.\n"
3149 "\n", program_name);
3151 show_help_options(options, "Print help / information / capabilities:",
3154 show_help_options(options, "Global options (affect whole program "
3155 "instead of just one file:",
3156 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3158 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3159 per_file | OPT_EXIT, 0);
3161 show_help_options(options, "Per-file main options:", 0,
3162 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3163 OPT_EXIT, per_file);
3165 show_help_options(options, "Advanced per-file options:",
3166 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3168 show_help_options(options, "Video options:",
3169 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3171 show_help_options(options, "Advanced Video options:",
3172 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3174 show_help_options(options, "Audio options:",
3175 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3177 show_help_options(options, "Advanced Audio options:",
3178 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3179 show_help_options(options, "Subtitle options:",
3180 OPT_SUBTITLE, 0, 0);
3183 if (show_avoptions) {
3184 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3185 show_help_children(avcodec_get_class(), flags);
3186 show_help_children(avformat_get_class(), flags);
3188 show_help_children(sws_get_class(), flags);
3190 #if CONFIG_SWRESAMPLE
3191 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3193 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3194 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3198 void show_usage(void)
3200 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3201 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3202 av_log(NULL, AV_LOG_INFO, "\n");
3210 static const OptionGroupDef groups[] = {
3211 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3212 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3215 static int open_files(OptionGroupList *l, const char *inout,
3216 int (*open_file)(OptionsContext*, const char*))
3220 for (i = 0; i < l->nb_groups; i++) {
3221 OptionGroup *g = &l->groups[i];
3227 ret = parse_optgroup(&o, g);
3229 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3230 "%s.\n", inout, g->arg);
3234 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3235 ret = open_file(&o, g->arg);
3238 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3242 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3248 int ffmpeg_parse_options(int argc, char **argv)
3250 OptionParseContext octx;
3254 memset(&octx, 0, sizeof(octx));
3256 /* split the commandline into an internal representation */
3257 ret = split_commandline(&octx, argc, argv, options, groups,
3258 FF_ARRAY_ELEMS(groups));
3260 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3264 /* apply global options */
3265 ret = parse_optgroup(NULL, &octx.global_opts);
3267 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3271 /* configure terminal and setup signal handlers */
3274 /* open input files */
3275 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3277 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3281 /* create the complex filtergraphs */
3282 ret = init_complex_filters();
3284 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3288 /* open output files */
3289 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3291 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3295 check_filter_outputs();
3298 uninit_parse_context(&octx);
3300 av_strerror(ret, error, sizeof(error));
3301 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3306 static int opt_progress(void *optctx, const char *opt, const char *arg)
3308 AVIOContext *avio = NULL;
3311 if (!strcmp(arg, "-"))
3313 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3315 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3316 arg, av_err2str(ret));
3319 progress_avio = avio;
3323 #define OFFSET(x) offsetof(OptionsContext, x)
3324 const OptionDef options[] = {
3326 CMDUTILS_COMMON_OPTIONS
3327 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3328 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3329 "force format", "fmt" },
3330 { "y", OPT_BOOL, { &file_overwrite },
3331 "overwrite output files" },
3332 { "n", OPT_BOOL, { &no_file_overwrite },
3333 "never overwrite output files" },
3334 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3335 "Ignore unknown stream types" },
3336 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3337 "Copy unknown stream types" },
3338 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3339 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3340 "codec name", "codec" },
3341 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3342 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3343 "codec name", "codec" },
3344 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3345 OPT_OUTPUT, { .off = OFFSET(presets) },
3346 "preset name", "preset" },
3347 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3348 OPT_OUTPUT, { .func_arg = opt_map },
3349 "set input stream mapping",
3350 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3351 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3352 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3353 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3354 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3355 "set metadata information of outfile from infile",
3356 "outfile[,metadata]:infile[,metadata]" },
3357 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3358 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3359 "set chapters mapping", "input_file_index" },
3360 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3361 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3362 "record or transcode \"duration\" seconds of audio/video",
3364 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3365 "record or transcode stop time", "time_stop" },
3366 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3367 "set the limit file size in bytes", "limit_size" },
3368 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3369 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3370 "set the start time offset", "time_off" },
3371 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3372 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3373 "set the start time offset relative to EOF", "time_off" },
3374 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3375 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3376 "enable/disable seeking by timestamp with -ss" },
3377 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3378 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3379 "enable/disable accurate seeking with -ss" },
3380 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3381 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3382 "set the input ts offset", "time_off" },
3383 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3384 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3385 "set the input ts scale", "scale" },
3386 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3387 "set the recording timestamp ('now' to set the current time)", "time" },
3388 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3389 "add metadata", "string=string" },
3390 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3391 "add program with specified streams", "title=string:st=number..." },
3392 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3393 OPT_OUTPUT, { .func_arg = opt_data_frames },
3394 "set the number of data frames to output", "number" },
3395 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3396 "add timings for benchmarking" },
3397 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3398 "add timings for each task" },
3399 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3400 "write program-readable progress information", "url" },
3401 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3402 "enable or disable interaction on standard input" },
3403 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3404 "set max runtime in seconds", "limit" },
3405 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3406 "dump each input packet" },
3407 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3408 "when dumping packets, also dump the payload" },
3409 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3410 OPT_INPUT, { .off = OFFSET(rate_emu) },
3411 "read input at native frame rate", "" },
3412 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3413 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3414 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3415 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3416 "video sync method", "" },
3417 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3418 "frame drop threshold", "" },
3419 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3420 "audio sync method", "" },
3421 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3422 "audio drift threshold", "threshold" },
3423 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3424 "copy timestamps" },
3425 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3426 "shift input timestamps to start at 0 when using copyts" },
3427 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3428 "copy input stream time base when stream copying", "mode" },
3429 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3430 OPT_OUTPUT, { .off = OFFSET(shortest) },
3431 "finish encoding within shortest input" },
3432 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3433 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3435 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3436 OPT_OUTPUT, { .off = OFFSET(apad) },
3438 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3439 "timestamp discontinuity delta threshold", "threshold" },
3440 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3441 "timestamp error delta threshold", "threshold" },
3442 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3443 "exit on error", "error" },
3444 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3445 "abort on the specified condition flags", "flags" },
3446 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3447 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3448 "copy initial non-keyframes" },
3449 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3450 "copy or discard frames before start time" },
3451 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3452 "set the number of frames to output", "number" },
3453 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3454 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3455 "force codec tag/fourcc", "fourcc/tag" },
3456 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3457 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3458 "use fixed quality scale (VBR)", "q" },
3459 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3460 OPT_OUTPUT, { .func_arg = opt_qscale },
3461 "use fixed quality scale (VBR)", "q" },
3462 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3463 "set profile", "profile" },
3464 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3465 "set stream filtergraph", "filter_graph" },
3466 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3467 "number of non-complex filter threads" },
3468 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3469 "read stream filtergraph description from a file", "filename" },
3470 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3471 "reinit filtergraph on input parameter changes", "" },
3472 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3473 "create a complex filtergraph", "graph_description" },
3474 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3475 "number of threads for -filter_complex" },
3476 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3477 "create a complex filtergraph", "graph_description" },
3478 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3479 "read complex filtergraph description from a file", "filename" },
3480 { "stats", OPT_BOOL, { &print_stats },
3481 "print progress report during encoding", },
3482 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3483 OPT_OUTPUT, { .func_arg = opt_attach },
3484 "add an attachment to the output file", "filename" },
3485 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3486 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3487 "extract an attachment into a file", "filename" },
3488 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3489 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3490 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3491 "print timestamp debugging info" },
3492 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3493 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3494 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3495 OPT_INPUT, { .off = OFFSET(discard) },
3497 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3498 OPT_OUTPUT, { .off = OFFSET(disposition) },
3499 "disposition", "" },
3500 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3501 { .off = OFFSET(thread_queue_size) },
3502 "set the maximum number of queued packets from the demuxer" },
3503 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3504 "read and decode the streams to fill missing information with heuristics" },
3507 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3508 "set the number of video frames to output", "number" },
3509 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3510 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3511 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3512 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3513 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3514 "set frame size (WxH or abbreviation)", "size" },
3515 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3516 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3517 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3518 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3519 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3520 "set pixel format", "format" },
3521 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3522 "set the number of bits per raw sample", "number" },
3523 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3524 "deprecated use -g 1" },
3525 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3527 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3528 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3529 "rate control override for specific intervals", "override" },
3530 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3531 OPT_OUTPUT, { .func_arg = opt_video_codec },
3532 "force video codec ('copy' to copy stream)", "codec" },
3533 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3535 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3537 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3538 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3539 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3540 "select the pass number (1 to 3)", "n" },
3541 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3542 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3543 "select two pass log file name prefix", "prefix" },
3544 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3545 "this option is deprecated, use the yadif filter instead" },
3546 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3547 "calculate PSNR of compressed frames" },
3548 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3549 "dump video coding statistics to file" },
3550 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3551 "dump video coding statistics to file", "file" },
3552 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3553 "Version of the vstats format to use."},
3554 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3555 "set video filters", "filter_graph" },
3556 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3557 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3558 "specify intra matrix coeffs", "matrix" },
3559 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3560 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3561 "specify inter matrix coeffs", "matrix" },
3562 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3563 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3564 "specify intra matrix coeffs", "matrix" },
3565 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3566 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3567 "top=1/bottom=0/auto=-1 field first", "" },
3568 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3569 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3570 "force video tag/fourcc", "fourcc/tag" },
3571 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3572 "show QP histogram" },
3573 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3574 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3575 "force the selected framerate, disable the best supported framerate selection" },
3576 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3577 OPT_OUTPUT, { .func_arg = opt_streamid },
3578 "set the value of an outfile streamid", "streamIndex:value" },
3579 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3580 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3581 "force key frames at specified timestamps", "timestamps" },
3582 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3583 "audio bitrate (please use -b:a)", "bitrate" },
3584 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3585 "video bitrate (please use -b:v)", "bitrate" },
3586 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3587 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3588 "use HW accelerated decoding", "hwaccel name" },
3589 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3590 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3591 "select a device for HW acceleration", "devicename" },
3592 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3593 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3594 "select output format used with HW accelerated decoding", "format" },
3595 #if CONFIG_VIDEOTOOLBOX
3596 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3598 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3599 "show available HW acceleration methods" },
3600 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3601 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3602 "automatically insert correct rotate filters" },
3605 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3606 "set the number of audio frames to output", "number" },
3607 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3608 "set audio quality (codec-specific)", "quality", },
3609 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3610 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3611 "set audio sampling rate (in Hz)", "rate" },
3612 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3613 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3614 "set number of audio channels", "channels" },
3615 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3617 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3618 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3619 "force audio codec ('copy' to copy stream)", "codec" },
3620 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3621 OPT_OUTPUT, { .func_arg = opt_old2new },
3622 "force audio tag/fourcc", "fourcc/tag" },
3623 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3624 "change audio volume (256=normal)" , "volume" },
3625 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3626 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3627 "set sample format", "format" },
3628 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3629 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3630 "set channel layout", "layout" },
3631 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3632 "set audio filters", "filter_graph" },
3633 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3634 "set the maximum number of channels to try to guess the channel layout" },
3636 /* subtitle options */
3637 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3638 "disable subtitle" },
3639 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3640 "force subtitle codec ('copy' to copy stream)", "codec" },
3641 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3642 , "force subtitle tag/fourcc", "fourcc/tag" },
3643 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3644 "fix subtitles duration" },
3645 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3646 "set canvas size (WxH or abbreviation)", "size" },
3649 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3650 "deprecated, use -channel", "channel" },
3651 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3652 "deprecated, use -standard", "standard" },
3653 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3656 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3657 "set the maximum demux-decode delay", "seconds" },
3658 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3659 "set the initial demux-decode delay", "seconds" },
3660 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3661 "specify a file in which to print sdp information", "file" },
3663 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3664 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3665 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3666 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3667 "two special values are defined - "
3668 "0 = use frame rate (video) or sample rate (audio),"
3669 "-1 = match source time base", "ratio" },
3671 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3672 "A comma-separated list of bitstream filters", "bitstream_filters" },
3673 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3674 "deprecated", "audio bitstream_filters" },
3675 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3676 "deprecated", "video bitstream_filters" },
3678 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3679 "set the audio options to the indicated preset", "preset" },
3680 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3681 "set the video options to the indicated preset", "preset" },
3682 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3683 "set the subtitle options to the indicated preset", "preset" },
3684 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3685 "set options from indicated preset file", "filename" },
3687 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3688 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3690 /* data codec support */
3691 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3692 "force data codec ('copy' to copy stream)", "codec" },
3693 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3697 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3698 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3702 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3703 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3706 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3707 "initialise hardware device", "args" },
3708 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3709 "set hardware device used when filtering", "device" },