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)
1155 if (dts_heuristic) {
1156 seek_timestamp -= 3*AV_TIME_BASE / 23;
1159 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1161 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1162 filename, (double)timestamp / AV_TIME_BASE);
1166 /* update the current parameters so that they match the one of the input stream */
1167 add_input_streams(o, ic);
1169 /* dump the file content */
1170 av_dump_format(ic, nb_input_files, filename, 0);
1172 GROW_ARRAY(input_files, nb_input_files);
1173 f = av_mallocz(sizeof(*f));
1176 input_files[nb_input_files - 1] = f;
1179 f->ist_index = nb_input_streams - ic->nb_streams;
1180 f->start_time = o->start_time;
1181 f->recording_time = o->recording_time;
1182 f->input_ts_offset = o->input_ts_offset;
1183 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1184 f->nb_streams = ic->nb_streams;
1185 f->rate_emu = o->rate_emu;
1186 f->accurate_seek = o->accurate_seek;
1189 f->time_base = (AVRational){ 1, 1 };
1191 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1194 /* check if all codec options have been used */
1195 unused_opts = strip_specifiers(o->g->codec_opts);
1196 for (i = f->ist_index; i < nb_input_streams; i++) {
1198 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1199 AV_DICT_IGNORE_SUFFIX)))
1200 av_dict_set(&unused_opts, e->key, NULL, 0);
1204 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1205 const AVClass *class = avcodec_get_class();
1206 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1207 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1208 const AVClass *fclass = avformat_get_class();
1209 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1210 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1211 if (!option || foption)
1215 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1216 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1217 "input file #%d (%s) is not a decoding option.\n", e->key,
1218 option->help ? option->help : "", nb_input_files - 1,
1223 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1224 "input file #%d (%s) has not been used for any stream. The most "
1225 "likely reason is either wrong type (e.g. a video option with "
1226 "no video streams) or that it is a private option of some decoder "
1227 "which was not actually used for any stream.\n", e->key,
1228 option->help ? option->help : "", nb_input_files - 1, filename);
1230 av_dict_free(&unused_opts);
1232 for (i = 0; i < o->nb_dump_attachment; i++) {
1235 for (j = 0; j < ic->nb_streams; j++) {
1236 AVStream *st = ic->streams[j];
1238 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1239 dump_attachment(st, o->dump_attachment[i].u.str);
1243 input_stream_potentially_available = 1;
1248 static uint8_t *get_line(AVIOContext *s)
1254 if (avio_open_dyn_buf(&line) < 0) {
1255 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1259 while ((c = avio_r8(s)) && c != '\n')
1262 avio_close_dyn_buf(line, &buf);
1267 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1270 char filename[1000];
1271 const char *base[3] = { getenv("AVCONV_DATADIR"),
1276 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1280 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1281 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1282 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1285 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1286 i != 1 ? "" : "/.avconv", preset_name);
1287 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1293 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1295 enum AVMediaType type = ost->st->codecpar->codec_type;
1296 char *codec_name = NULL;
1298 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1299 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1301 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1302 NULL, ost->st->codecpar->codec_type);
1303 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1305 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1306 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1307 "probably disabled. Please choose an encoder manually.\n",
1308 ost->file_index, ost->index, s->oformat->name,
1309 avcodec_get_name(ost->st->codecpar->codec_id));
1310 return AVERROR_ENCODER_NOT_FOUND;
1312 } else if (!strcmp(codec_name, "copy"))
1313 ost->stream_copy = 1;
1315 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1316 ost->st->codecpar->codec_id = ost->enc->id;
1318 ost->encoding_needed = !ost->stream_copy;
1320 /* no encoding supported for other media types */
1321 ost->stream_copy = 1;
1322 ost->encoding_needed = 0;
1328 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1331 AVStream *st = avformat_new_stream(oc, NULL);
1332 int idx = oc->nb_streams - 1, ret = 0;
1333 const char *bsfs = NULL, *time_base = NULL;
1334 char *next, *codec_tag = NULL;
1339 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1343 if (oc->nb_streams - 1 < o->nb_streamid_map)
1344 st->id = o->streamid_map[oc->nb_streams - 1];
1346 GROW_ARRAY(output_streams, nb_output_streams);
1347 if (!(ost = av_mallocz(sizeof(*ost))))
1349 output_streams[nb_output_streams - 1] = ost;
1351 ost->file_index = nb_output_files - 1;
1354 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1355 st->codecpar->codec_type = type;
1357 ret = choose_encoder(o, oc, ost);
1359 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1360 "%d:%d\n", ost->file_index, ost->index);
1364 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1365 if (!ost->enc_ctx) {
1366 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1369 ost->enc_ctx->codec_type = type;
1371 ost->ref_par = avcodec_parameters_alloc();
1372 if (!ost->ref_par) {
1373 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1378 AVIOContext *s = NULL;
1379 char *buf = NULL, *arg = NULL, *preset = NULL;
1381 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1383 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1384 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1387 if (!buf[0] || buf[0] == '#') {
1391 if (!(arg = strchr(buf, '='))) {
1392 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1396 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1398 } while (!s->eof_reached);
1402 av_log(NULL, AV_LOG_FATAL,
1403 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1404 preset, ost->file_index, ost->index);
1408 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1413 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1415 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1418 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1419 q.num <= 0 || q.den <= 0) {
1420 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1426 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1429 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1431 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1434 ost->enc_timebase = q;
1437 ost->max_frames = INT64_MAX;
1438 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1439 for (i = 0; i<o->nb_max_frames; i++) {
1440 char *p = o->max_frames[i].specifier;
1441 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1442 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1447 ost->copy_prior_start = -1;
1448 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1450 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1451 while (bsfs && *bsfs) {
1452 const AVBitStreamFilter *filter;
1453 char *bsf, *bsf_options_str, *bsf_name;
1455 bsf = av_get_token(&bsfs, ",");
1458 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1462 filter = av_bsf_get_by_name(bsf_name);
1464 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1468 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1469 ost->nb_bitstream_filters + 1,
1470 sizeof(*ost->bsf_ctx));
1474 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1476 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1480 ost->nb_bitstream_filters++;
1482 if (bsf_options_str && filter->priv_class) {
1483 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1484 const char * shorthand[2] = {NULL};
1487 shorthand[0] = opt->name;
1489 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1491 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1501 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1503 uint32_t tag = strtol(codec_tag, &next, 0);
1505 tag = AV_RL32(codec_tag);
1506 ost->st->codecpar->codec_tag =
1507 ost->enc_ctx->codec_tag = tag;
1510 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1512 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1513 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1516 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1517 ost->disposition = av_strdup(ost->disposition);
1519 ost->max_muxing_queue_size = 128;
1520 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1521 ost->max_muxing_queue_size *= sizeof(AVPacket);
1523 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1524 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1526 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1528 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1529 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1530 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1532 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1534 ost->source_index = source_index;
1535 if (source_index >= 0) {
1536 ost->sync_ist = input_streams[source_index];
1537 input_streams[source_index]->discard = 0;
1538 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1540 ost->last_mux_dts = AV_NOPTS_VALUE;
1542 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1543 if (!ost->muxing_queue)
1549 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1552 const char *p = str;
1559 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1566 /* read file contents into a string */
1567 static uint8_t *read_file(const char *filename)
1569 AVIOContext *pb = NULL;
1570 AVIOContext *dyn_buf = NULL;
1571 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1572 uint8_t buf[1024], *str;
1575 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1579 ret = avio_open_dyn_buf(&dyn_buf);
1584 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1585 avio_write(dyn_buf, buf, ret);
1586 avio_w8(dyn_buf, 0);
1589 ret = avio_close_dyn_buf(dyn_buf, &str);
1595 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1598 AVStream *st = ost->st;
1600 if (ost->filters_script && ost->filters) {
1601 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1602 "output stream #%d:%d.\n", nb_output_files, st->index);
1606 if (ost->filters_script)
1607 return read_file(ost->filters_script);
1608 else if (ost->filters)
1609 return av_strdup(ost->filters);
1611 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1615 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1616 const OutputStream *ost, enum AVMediaType type)
1618 if (ost->filters_script || ost->filters) {
1619 av_log(NULL, AV_LOG_ERROR,
1620 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1621 "Filtering and streamcopy cannot be used together.\n",
1622 ost->filters ? "Filtergraph" : "Filtergraph script",
1623 ost->filters ? ost->filters : ost->filters_script,
1624 av_get_media_type_string(type), ost->file_index, ost->index);
1629 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1633 AVCodecContext *video_enc;
1634 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1636 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1638 video_enc = ost->enc_ctx;
1640 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1641 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1642 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1645 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1646 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1648 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1649 if (frame_aspect_ratio) {
1651 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1652 q.num <= 0 || q.den <= 0) {
1653 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1656 ost->frame_aspect_ratio = q;
1659 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1660 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1662 if (!ost->stream_copy) {
1663 const char *p = NULL;
1664 char *frame_size = NULL;
1665 char *frame_pix_fmt = NULL;
1666 char *intra_matrix = NULL, *inter_matrix = NULL;
1667 char *chroma_intra_matrix = NULL;
1671 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1672 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1673 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1677 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1678 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1679 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1680 ost->keep_pix_fmt = 1;
1681 if (!*++frame_pix_fmt)
1682 frame_pix_fmt = NULL;
1684 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1685 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1688 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1691 video_enc->gop_size = 0;
1692 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1694 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1695 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1698 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1700 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1701 if (chroma_intra_matrix) {
1702 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1704 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1707 video_enc->chroma_intra_matrix = p;
1708 parse_matrix_coeffs(p, chroma_intra_matrix);
1710 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1712 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1713 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1716 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1719 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1720 for (i = 0; p; i++) {
1722 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1724 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1727 video_enc->rc_override =
1728 av_realloc_array(video_enc->rc_override,
1729 i + 1, sizeof(RcOverride));
1730 if (!video_enc->rc_override) {
1731 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1734 video_enc->rc_override[i].start_frame = start;
1735 video_enc->rc_override[i].end_frame = end;
1737 video_enc->rc_override[i].qscale = q;
1738 video_enc->rc_override[i].quality_factor = 1.0;
1741 video_enc->rc_override[i].qscale = 0;
1742 video_enc->rc_override[i].quality_factor = -q/100.0;
1747 video_enc->rc_override_count = i;
1750 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1753 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1756 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1757 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1760 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1761 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1765 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1766 if (ost->logfile_prefix &&
1767 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1771 char logfilename[1024];
1774 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1775 ost->logfile_prefix ? ost->logfile_prefix :
1776 DEFAULT_PASS_LOGFILENAME_PREFIX,
1778 if (!strcmp(ost->enc->name, "libx264")) {
1779 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1781 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1782 char *logbuffer = read_file(logfilename);
1785 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1789 video_enc->stats_in = logbuffer;
1791 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1792 f = av_fopen_utf8(logfilename, "wb");
1794 av_log(NULL, AV_LOG_FATAL,
1795 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1796 logfilename, strerror(errno));
1804 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1805 if (ost->forced_keyframes)
1806 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1808 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1810 ost->top_field_first = -1;
1811 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1814 ost->avfilter = get_ost_filters(o, oc, ost);
1818 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1821 if (ost->stream_copy)
1822 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1827 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1832 AVCodecContext *audio_enc;
1834 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1837 audio_enc = ost->enc_ctx;
1838 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1840 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1841 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1843 if (!ost->stream_copy) {
1844 char *sample_fmt = NULL;
1846 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1848 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1850 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1851 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1855 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1857 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1858 ost->apad = av_strdup(ost->apad);
1860 ost->avfilter = get_ost_filters(o, oc, ost);
1864 /* check for channel mapping for this audio stream */
1865 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1866 AudioChannelMap *map = &o->audio_channel_maps[n];
1867 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1868 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1871 if (map->channel_idx == -1) {
1873 } else if (ost->source_index < 0) {
1874 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1875 ost->file_index, ost->st->index);
1878 ist = input_streams[ost->source_index];
1881 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1882 if (av_reallocp_array(&ost->audio_channels_map,
1883 ost->audio_channels_mapped + 1,
1884 sizeof(*ost->audio_channels_map)
1888 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1894 if (ost->stream_copy)
1895 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1900 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1904 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1905 if (!ost->stream_copy) {
1906 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1913 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1917 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1918 if (!ost->stream_copy) {
1919 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1926 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1928 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1929 ost->stream_copy = 1;
1934 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1938 AVCodecContext *subtitle_enc;
1940 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1942 subtitle_enc = ost->enc_ctx;
1944 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1946 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1948 if (!ost->stream_copy) {
1949 char *frame_size = NULL;
1951 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1952 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1953 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1961 /* arg format is "output-stream-index:streamid-value". */
1962 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1964 OptionsContext *o = optctx;
1969 av_strlcpy(idx_str, arg, sizeof(idx_str));
1970 p = strchr(idx_str, ':');
1972 av_log(NULL, AV_LOG_FATAL,
1973 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1978 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1979 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1980 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1984 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1986 AVFormatContext *is = ifile->ctx;
1987 AVFormatContext *os = ofile->ctx;
1991 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1993 return AVERROR(ENOMEM);
1996 for (i = 0; i < is->nb_chapters; i++) {
1997 AVChapter *in_ch = is->chapters[i], *out_ch;
1998 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1999 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2000 AV_TIME_BASE_Q, in_ch->time_base);
2001 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2002 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2005 if (in_ch->end < ts_off)
2007 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2010 out_ch = av_mallocz(sizeof(AVChapter));
2012 return AVERROR(ENOMEM);
2014 out_ch->id = in_ch->id;
2015 out_ch->time_base = in_ch->time_base;
2016 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2017 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2020 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2022 os->chapters[os->nb_chapters++] = out_ch;
2027 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2028 AVFormatContext *oc)
2032 switch (ofilter->type) {
2033 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2034 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2036 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2041 ost->source_index = -1;
2042 ost->filter = ofilter;
2045 ofilter->format = -1;
2047 if (ost->stream_copy) {
2048 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2049 "which is fed from a complex filtergraph. Filtering and streamcopy "
2050 "cannot be used together.\n", ost->file_index, ost->index);
2054 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2055 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2056 av_log(NULL, AV_LOG_ERROR,
2057 "%s '%s' was specified through the %s option "
2058 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2059 "%s and -filter_complex cannot be used together for the same stream.\n",
2060 ost->filters ? "Filtergraph" : "Filtergraph script",
2061 ost->filters ? ost->filters : ost->filters_script,
2062 opt, ost->file_index, ost->index, opt);
2066 avfilter_inout_free(&ofilter->out_tmp);
2069 static int init_complex_filters(void)
2073 for (i = 0; i < nb_filtergraphs; i++) {
2074 ret = init_complex_filtergraph(filtergraphs[i]);
2081 static int open_output_file(OptionsContext *o, const char *filename)
2083 AVFormatContext *oc;
2088 AVDictionary *unused_opts = NULL;
2089 AVDictionaryEntry *e = NULL;
2090 int format_flags = 0;
2092 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2093 o->stop_time = INT64_MAX;
2094 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2097 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2098 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2099 if (o->stop_time <= start_time) {
2100 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2103 o->recording_time = o->stop_time - start_time;
2107 GROW_ARRAY(output_files, nb_output_files);
2108 of = av_mallocz(sizeof(*of));
2111 output_files[nb_output_files - 1] = of;
2113 of->ost_index = nb_output_streams;
2114 of->recording_time = o->recording_time;
2115 of->start_time = o->start_time;
2116 of->limit_filesize = o->limit_filesize;
2117 of->shortest = o->shortest;
2118 av_dict_copy(&of->opts, o->g->format_opts, 0);
2120 if (!strcmp(filename, "-"))
2123 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2125 print_error(filename, err);
2130 if (o->recording_time != INT64_MAX)
2131 oc->duration = o->recording_time;
2133 oc->interrupt_callback = int_cb;
2135 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2137 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2138 av_opt_eval_flags(oc, o, e->value, &format_flags);
2141 format_flags |= AVFMT_FLAG_BITEXACT;
2142 oc->flags |= AVFMT_FLAG_BITEXACT;
2145 /* create streams for all unlabeled output pads */
2146 for (i = 0; i < nb_filtergraphs; i++) {
2147 FilterGraph *fg = filtergraphs[i];
2148 for (j = 0; j < fg->nb_outputs; j++) {
2149 OutputFilter *ofilter = fg->outputs[j];
2151 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2154 switch (ofilter->type) {
2155 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2156 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2157 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2159 init_output_filter(ofilter, o, oc);
2163 if (!o->nb_stream_maps) {
2164 char *subtitle_codec_name = NULL;
2165 /* pick the "best" stream of each type */
2167 /* video: highest resolution */
2168 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2169 int area = 0, idx = -1;
2170 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2171 for (i = 0; i < nb_input_streams; i++) {
2173 ist = input_streams[i];
2174 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2175 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2177 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2179 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2186 new_video_stream(o, oc, idx);
2189 /* audio: most channels */
2190 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2191 int best_score = 0, idx = -1;
2192 for (i = 0; i < nb_input_streams; i++) {
2194 ist = input_streams[i];
2195 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2196 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2197 score > best_score) {
2203 new_audio_stream(o, oc, idx);
2206 /* subtitles: pick first */
2207 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2208 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2209 for (i = 0; i < nb_input_streams; i++)
2210 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2211 AVCodecDescriptor const *input_descriptor =
2212 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2213 AVCodecDescriptor const *output_descriptor = NULL;
2214 AVCodec const *output_codec =
2215 avcodec_find_encoder(oc->oformat->subtitle_codec);
2216 int input_props = 0, output_props = 0;
2218 output_descriptor = avcodec_descriptor_get(output_codec->id);
2219 if (input_descriptor)
2220 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2221 if (output_descriptor)
2222 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2223 if (subtitle_codec_name ||
2224 input_props & output_props ||
2225 // Map dvb teletext which has neither property to any output subtitle encoder
2226 input_descriptor && output_descriptor &&
2227 (!input_descriptor->props ||
2228 !output_descriptor->props)) {
2229 new_subtitle_stream(o, oc, i);
2234 /* Data only if codec id match */
2235 if (!o->data_disable ) {
2236 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2237 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2238 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2239 && input_streams[i]->st->codecpar->codec_id == codec_id )
2240 new_data_stream(o, oc, i);
2244 for (i = 0; i < o->nb_stream_maps; i++) {
2245 StreamMap *map = &o->stream_maps[i];
2250 if (map->linklabel) {
2252 OutputFilter *ofilter = NULL;
2255 for (j = 0; j < nb_filtergraphs; j++) {
2256 fg = filtergraphs[j];
2257 for (k = 0; k < fg->nb_outputs; k++) {
2258 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2259 if (out && !strcmp(out->name, map->linklabel)) {
2260 ofilter = fg->outputs[k];
2267 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2268 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2271 init_output_filter(ofilter, o, oc);
2273 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2275 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2276 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2278 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2280 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2282 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2286 switch (ist->st->codecpar->codec_type) {
2287 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2288 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2289 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2290 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2291 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2292 case AVMEDIA_TYPE_UNKNOWN:
2293 if (copy_unknown_streams) {
2294 ost = new_unknown_stream (o, oc, src_idx);
2298 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2299 "Cannot map stream #%d:%d - unsupported type.\n",
2300 map->file_index, map->stream_index);
2301 if (!ignore_unknown_streams) {
2302 av_log(NULL, AV_LOG_FATAL,
2303 "If you want unsupported types ignored instead "
2304 "of failing, please use the -ignore_unknown option\n"
2305 "If you want them copied, please use -copy_unknown\n");
2310 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2311 + map->sync_stream_index];
2316 /* handle attached files */
2317 for (i = 0; i < o->nb_attachments; i++) {
2319 uint8_t *attachment;
2323 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2324 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2328 if ((len = avio_size(pb)) <= 0) {
2329 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2333 if (!(attachment = av_malloc(len))) {
2334 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2338 avio_read(pb, attachment, len);
2340 ost = new_attachment_stream(o, oc, -1);
2341 ost->stream_copy = 0;
2342 ost->attachment_filename = o->attachments[i];
2343 ost->st->codecpar->extradata = attachment;
2344 ost->st->codecpar->extradata_size = len;
2346 p = strrchr(o->attachments[i], '/');
2347 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2351 #if FF_API_LAVF_AVCTX
2352 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2353 AVDictionaryEntry *e;
2354 ost = output_streams[i];
2356 if ((ost->stream_copy || ost->attachment_filename)
2357 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2358 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2359 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2364 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2365 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2366 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2370 /* check if all codec options have been used */
2371 unused_opts = strip_specifiers(o->g->codec_opts);
2372 for (i = of->ost_index; i < nb_output_streams; i++) {
2374 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2375 AV_DICT_IGNORE_SUFFIX)))
2376 av_dict_set(&unused_opts, e->key, NULL, 0);
2380 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2381 const AVClass *class = avcodec_get_class();
2382 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2383 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2384 const AVClass *fclass = avformat_get_class();
2385 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2386 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2387 if (!option || foption)
2391 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2392 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2393 "output file #%d (%s) is not an encoding option.\n", e->key,
2394 option->help ? option->help : "", nb_output_files - 1,
2399 // gop_timecode is injected by generic code but not always used
2400 if (!strcmp(e->key, "gop_timecode"))
2403 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2404 "output file #%d (%s) has not been used for any stream. The most "
2405 "likely reason is either wrong type (e.g. a video option with "
2406 "no video streams) or that it is a private option of some encoder "
2407 "which was not actually used for any stream.\n", e->key,
2408 option->help ? option->help : "", nb_output_files - 1, filename);
2410 av_dict_free(&unused_opts);
2412 /* set the decoding_needed flags and create simple filtergraphs */
2413 for (i = of->ost_index; i < nb_output_streams; i++) {
2414 OutputStream *ost = output_streams[i];
2416 if (ost->encoding_needed && ost->source_index >= 0) {
2417 InputStream *ist = input_streams[ost->source_index];
2418 ist->decoding_needed |= DECODING_FOR_OST;
2420 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2421 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2422 err = init_simple_filtergraph(ist, ost);
2424 av_log(NULL, AV_LOG_ERROR,
2425 "Error initializing a simple filtergraph between streams "
2426 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2427 nb_output_files - 1, ost->st->index);
2433 /* set the filter output constraints */
2435 OutputFilter *f = ost->filter;
2437 switch (ost->enc_ctx->codec_type) {
2438 case AVMEDIA_TYPE_VIDEO:
2439 f->frame_rate = ost->frame_rate;
2440 f->width = ost->enc_ctx->width;
2441 f->height = ost->enc_ctx->height;
2442 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2443 f->format = ost->enc_ctx->pix_fmt;
2444 } else if (ost->enc->pix_fmts) {
2446 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2448 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2451 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2454 case AVMEDIA_TYPE_AUDIO:
2455 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2456 f->format = ost->enc_ctx->sample_fmt;
2457 } else if (ost->enc->sample_fmts) {
2459 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2461 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2464 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2466 if (ost->enc_ctx->sample_rate) {
2467 f->sample_rate = ost->enc_ctx->sample_rate;
2468 } else if (ost->enc->supported_samplerates) {
2470 while (ost->enc->supported_samplerates[count])
2472 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2473 if (!f->sample_rates)
2475 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2476 (count + 1) * sizeof(*f->sample_rates));
2478 if (ost->enc_ctx->channels) {
2479 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2480 } else if (ost->enc->channel_layouts) {
2482 while (ost->enc->channel_layouts[count])
2484 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2485 if (!f->channel_layouts)
2487 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2488 (count + 1) * sizeof(*f->channel_layouts));
2495 /* check filename in case of an image number is expected */
2496 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2497 if (!av_filename_number_test(oc->url)) {
2498 print_error(oc->url, AVERROR(EINVAL));
2503 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2504 av_log(NULL, AV_LOG_ERROR,
2505 "No input streams but output needs an input stream\n");
2509 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2510 /* test if it already exists to avoid losing precious files */
2511 assert_file_overwrite(filename);
2514 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2515 &oc->interrupt_callback,
2517 print_error(filename, err);
2520 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2521 assert_file_overwrite(filename);
2523 if (o->mux_preload) {
2524 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2526 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2529 for (i = 0; i < o->nb_metadata_map; i++) {
2531 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2533 if (in_file_index >= nb_input_files) {
2534 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2537 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2538 in_file_index >= 0 ?
2539 input_files[in_file_index]->ctx : NULL, o);
2543 if (o->chapters_input_file >= nb_input_files) {
2544 if (o->chapters_input_file == INT_MAX) {
2545 /* copy chapters from the first input file that has them*/
2546 o->chapters_input_file = -1;
2547 for (i = 0; i < nb_input_files; i++)
2548 if (input_files[i]->ctx->nb_chapters) {
2549 o->chapters_input_file = i;
2553 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2554 o->chapters_input_file);
2558 if (o->chapters_input_file >= 0)
2559 copy_chapters(input_files[o->chapters_input_file], of,
2560 !o->metadata_chapters_manual);
2562 /* copy global metadata by default */
2563 if (!o->metadata_global_manual && nb_input_files){
2564 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2565 AV_DICT_DONT_OVERWRITE);
2566 if(o->recording_time != INT64_MAX)
2567 av_dict_set(&oc->metadata, "duration", NULL, 0);
2568 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2570 if (!o->metadata_streams_manual)
2571 for (i = of->ost_index; i < nb_output_streams; i++) {
2573 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2575 ist = input_streams[output_streams[i]->source_index];
2576 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2577 if (!output_streams[i]->stream_copy) {
2578 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2582 /* process manually set programs */
2583 for (i = 0; i < o->nb_program; i++) {
2584 const char *p = o->program[i].u.str;
2589 const char *p2 = av_get_token(&p, ":");
2590 const char *to_dealloc = p2;
2597 key = av_get_token(&p2, "=");
2599 av_freep(&to_dealloc);
2605 if (!strcmp(key, "program_num"))
2606 progid = strtol(p2, NULL, 0);
2607 av_freep(&to_dealloc);
2611 program = av_new_program(oc, progid);
2613 p = o->program[i].u.str;
2615 const char *p2 = av_get_token(&p, ":");
2616 const char *to_dealloc = p2;
2622 key = av_get_token(&p2, "=");
2624 av_log(NULL, AV_LOG_FATAL,
2625 "No '=' character in program string %s.\n",
2633 if (!strcmp(key, "title")) {
2634 av_dict_set(&program->metadata, "title", p2, 0);
2635 } else if (!strcmp(key, "program_num")) {
2636 } else if (!strcmp(key, "st")) {
2637 int st_num = strtol(p2, NULL, 0);
2638 av_program_add_stream_index(oc, progid, st_num);
2640 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2643 av_freep(&to_dealloc);
2648 /* process manually set metadata */
2649 for (i = 0; i < o->nb_metadata; i++) {
2652 const char *stream_spec;
2653 int index = 0, j, ret = 0;
2655 val = strchr(o->metadata[i].u.str, '=');
2657 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2658 o->metadata[i].u.str);
2663 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2665 for (j = 0; j < oc->nb_streams; j++) {
2666 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2667 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2668 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2670 double theta = av_strtod(val, &tail);
2672 ost->rotate_overridden = 1;
2673 ost->rotate_override_value = theta;
2676 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2688 if (index < 0 || index >= oc->nb_chapters) {
2689 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2692 m = &oc->chapters[index]->metadata;
2695 if (index < 0 || index >= oc->nb_programs) {
2696 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2699 m = &oc->programs[index]->metadata;
2702 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2705 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2712 static int opt_target(void *optctx, const char *opt, const char *arg)
2714 OptionsContext *o = optctx;
2715 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2716 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2718 if (!strncmp(arg, "pal-", 4)) {
2721 } else if (!strncmp(arg, "ntsc-", 5)) {
2724 } else if (!strncmp(arg, "film-", 5)) {
2728 /* Try to determine PAL/NTSC by peeking in the input files */
2729 if (nb_input_files) {
2731 for (j = 0; j < nb_input_files; j++) {
2732 for (i = 0; i < input_files[j]->nb_streams; i++) {
2733 AVStream *st = input_files[j]->ctx->streams[i];
2734 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2736 fr = st->time_base.den * 1000 / st->time_base.num;
2740 } else if ((fr == 29970) || (fr == 23976)) {
2745 if (norm != UNKNOWN)
2749 if (norm != UNKNOWN)
2750 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2753 if (norm == UNKNOWN) {
2754 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2755 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2756 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2760 if (!strcmp(arg, "vcd")) {
2761 opt_video_codec(o, "c:v", "mpeg1video");
2762 opt_audio_codec(o, "c:a", "mp2");
2763 parse_option(o, "f", "vcd", options);
2765 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2766 parse_option(o, "r", frame_rates[norm], options);
2767 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2769 opt_default(NULL, "b:v", "1150000");
2770 opt_default(NULL, "maxrate:v", "1150000");
2771 opt_default(NULL, "minrate:v", "1150000");
2772 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2774 opt_default(NULL, "b:a", "224000");
2775 parse_option(o, "ar", "44100", options);
2776 parse_option(o, "ac", "2", options);
2778 opt_default(NULL, "packetsize", "2324");
2779 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2781 /* We have to offset the PTS, so that it is consistent with the SCR.
2782 SCR starts at 36000, but the first two packs contain only padding
2783 and the first pack from the other stream, respectively, may also have
2784 been written before.
2785 So the real data starts at SCR 36000+3*1200. */
2786 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2787 } else if (!strcmp(arg, "svcd")) {
2789 opt_video_codec(o, "c:v", "mpeg2video");
2790 opt_audio_codec(o, "c:a", "mp2");
2791 parse_option(o, "f", "svcd", options);
2793 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2794 parse_option(o, "r", frame_rates[norm], options);
2795 parse_option(o, "pix_fmt", "yuv420p", options);
2796 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2798 opt_default(NULL, "b:v", "2040000");
2799 opt_default(NULL, "maxrate:v", "2516000");
2800 opt_default(NULL, "minrate:v", "0"); // 1145000;
2801 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2802 opt_default(NULL, "scan_offset", "1");
2804 opt_default(NULL, "b:a", "224000");
2805 parse_option(o, "ar", "44100", options);
2807 opt_default(NULL, "packetsize", "2324");
2809 } else if (!strcmp(arg, "dvd")) {
2811 opt_video_codec(o, "c:v", "mpeg2video");
2812 opt_audio_codec(o, "c:a", "ac3");
2813 parse_option(o, "f", "dvd", options);
2815 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2816 parse_option(o, "r", frame_rates[norm], options);
2817 parse_option(o, "pix_fmt", "yuv420p", options);
2818 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2820 opt_default(NULL, "b:v", "6000000");
2821 opt_default(NULL, "maxrate:v", "9000000");
2822 opt_default(NULL, "minrate:v", "0"); // 1500000;
2823 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2825 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2826 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2828 opt_default(NULL, "b:a", "448000");
2829 parse_option(o, "ar", "48000", options);
2831 } else if (!strncmp(arg, "dv", 2)) {
2833 parse_option(o, "f", "dv", options);
2835 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2836 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2837 norm == PAL ? "yuv420p" : "yuv411p", options);
2838 parse_option(o, "r", frame_rates[norm], options);
2840 parse_option(o, "ar", "48000", options);
2841 parse_option(o, "ac", "2", options);
2844 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2845 return AVERROR(EINVAL);
2848 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2849 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2854 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2856 av_free (vstats_filename);
2857 vstats_filename = av_strdup (arg);
2861 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2864 time_t today2 = time(NULL);
2865 struct tm *today = localtime(&today2);
2867 if (!today) { // maybe tomorrow
2868 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2872 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2874 return opt_vstats_file(NULL, opt, filename);
2877 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2879 OptionsContext *o = optctx;
2880 return parse_option(o, "frames:v", arg, options);
2883 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2885 OptionsContext *o = optctx;
2886 return parse_option(o, "frames:a", arg, options);
2889 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2891 OptionsContext *o = optctx;
2892 return parse_option(o, "frames:d", arg, options);
2895 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2898 AVDictionary *cbak = codec_opts;
2899 AVDictionary *fbak = format_opts;
2903 ret = opt_default(NULL, opt, arg);
2905 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2906 av_dict_copy(&o->g->format_opts, format_opts, 0);
2907 av_dict_free(&codec_opts);
2908 av_dict_free(&format_opts);
2915 static int opt_preset(void *optctx, const char *opt, const char *arg)
2917 OptionsContext *o = optctx;
2919 char filename[1000], line[1000], tmp_line[1000];
2920 const char *codec_name = NULL;
2924 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2926 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2927 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2928 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2930 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2934 while (fgets(line, sizeof(line), f)) {
2935 char *key = tmp_line, *value, *endptr;
2937 if (strcspn(line, "#\n\r") == 0)
2939 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2940 if (!av_strtok(key, "=", &value) ||
2941 !av_strtok(value, "\r\n", &endptr)) {
2942 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2945 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2947 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2948 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2949 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2950 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2951 else if (opt_default_new(o, key, value) < 0) {
2952 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2953 filename, line, key, value);
2963 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2965 OptionsContext *o = optctx;
2966 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2967 int ret = parse_option(o, s, arg, options);
2972 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2974 OptionsContext *o = optctx;
2976 if(!strcmp(opt, "ab")){
2977 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2979 } else if(!strcmp(opt, "b")){
2980 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2981 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2984 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2988 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2990 OptionsContext *o = optctx;
2993 if(!strcmp(opt, "qscale")){
2994 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2995 return parse_option(o, "q:v", arg, options);
2997 s = av_asprintf("q%s", opt + 6);
2998 ret = parse_option(o, s, arg, options);
3003 static int opt_profile(void *optctx, const char *opt, const char *arg)
3005 OptionsContext *o = optctx;
3006 if(!strcmp(opt, "profile")){
3007 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3008 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3011 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3015 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3017 OptionsContext *o = optctx;
3018 return parse_option(o, "filter:v", arg, options);
3021 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3023 OptionsContext *o = optctx;
3024 return parse_option(o, "filter:a", arg, options);
3027 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3029 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3030 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3031 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3032 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3034 if (video_sync_method == VSYNC_AUTO)
3035 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3039 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3041 OptionsContext *o = optctx;
3042 char *tcr = av_asprintf("timecode=%s", arg);
3043 int ret = parse_option(o, "metadata:g", tcr, options);
3045 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3050 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3052 OptionsContext *o = optctx;
3053 char layout_str[32];
3056 int ret, channels, ac_str_size;
3059 layout = av_get_channel_layout(arg);
3061 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3062 return AVERROR(EINVAL);
3064 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3065 ret = opt_default_new(o, opt, layout_str);
3069 /* set 'ac' option based on channel layout */
3070 channels = av_get_channel_layout_nb_channels(layout);
3071 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3072 stream_str = strchr(opt, ':');
3073 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3074 ac_str = av_mallocz(ac_str_size);
3076 return AVERROR(ENOMEM);
3077 av_strlcpy(ac_str, "ac", 3);
3079 av_strlcat(ac_str, stream_str, ac_str_size);
3080 ret = parse_option(o, ac_str, layout_str, options);
3086 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3088 OptionsContext *o = optctx;
3089 return parse_option(o, "q:a", arg, options);
3092 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3094 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3095 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3096 return AVERROR(ENOMEM);
3097 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3098 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3099 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3100 return AVERROR(ENOMEM);
3102 input_stream_potentially_available = 1;
3107 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3109 uint8_t *graph_desc = read_file(arg);
3111 return AVERROR(EINVAL);
3113 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3114 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3115 return AVERROR(ENOMEM);
3116 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3117 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3119 input_stream_potentially_available = 1;
3124 void show_help_default(const char *opt, const char *arg)
3126 /* per-file options have at least one of those set */
3127 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3128 int show_advanced = 0, show_avoptions = 0;
3131 if (!strcmp(opt, "long"))
3133 else if (!strcmp(opt, "full"))
3134 show_advanced = show_avoptions = 1;
3136 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3141 printf("Getting help:\n"
3142 " -h -- print basic options\n"
3143 " -h long -- print more options\n"
3144 " -h full -- print all options (including all format and codec specific options, very long)\n"
3145 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3146 " See man %s for detailed description of the options.\n"
3147 "\n", program_name);
3149 show_help_options(options, "Print help / information / capabilities:",
3152 show_help_options(options, "Global options (affect whole program "
3153 "instead of just one file:",
3154 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3156 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3157 per_file | OPT_EXIT, 0);
3159 show_help_options(options, "Per-file main options:", 0,
3160 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3161 OPT_EXIT, per_file);
3163 show_help_options(options, "Advanced per-file options:",
3164 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3166 show_help_options(options, "Video options:",
3167 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3169 show_help_options(options, "Advanced Video options:",
3170 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3172 show_help_options(options, "Audio options:",
3173 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3175 show_help_options(options, "Advanced Audio options:",
3176 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3177 show_help_options(options, "Subtitle options:",
3178 OPT_SUBTITLE, 0, 0);
3181 if (show_avoptions) {
3182 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3183 show_help_children(avcodec_get_class(), flags);
3184 show_help_children(avformat_get_class(), flags);
3186 show_help_children(sws_get_class(), flags);
3188 #if CONFIG_SWRESAMPLE
3189 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3191 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3192 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3196 void show_usage(void)
3198 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3199 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3200 av_log(NULL, AV_LOG_INFO, "\n");
3208 static const OptionGroupDef groups[] = {
3209 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3210 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3213 static int open_files(OptionGroupList *l, const char *inout,
3214 int (*open_file)(OptionsContext*, const char*))
3218 for (i = 0; i < l->nb_groups; i++) {
3219 OptionGroup *g = &l->groups[i];
3225 ret = parse_optgroup(&o, g);
3227 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3228 "%s.\n", inout, g->arg);
3232 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3233 ret = open_file(&o, g->arg);
3236 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3240 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3246 int ffmpeg_parse_options(int argc, char **argv)
3248 OptionParseContext octx;
3252 memset(&octx, 0, sizeof(octx));
3254 /* split the commandline into an internal representation */
3255 ret = split_commandline(&octx, argc, argv, options, groups,
3256 FF_ARRAY_ELEMS(groups));
3258 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3262 /* apply global options */
3263 ret = parse_optgroup(NULL, &octx.global_opts);
3265 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3269 /* configure terminal and setup signal handlers */
3272 /* open input files */
3273 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3275 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3279 /* create the complex filtergraphs */
3280 ret = init_complex_filters();
3282 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3286 /* open output files */
3287 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3289 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3293 check_filter_outputs();
3296 uninit_parse_context(&octx);
3298 av_strerror(ret, error, sizeof(error));
3299 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3304 static int opt_progress(void *optctx, const char *opt, const char *arg)
3306 AVIOContext *avio = NULL;
3309 if (!strcmp(arg, "-"))
3311 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3313 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3314 arg, av_err2str(ret));
3317 progress_avio = avio;
3321 #define OFFSET(x) offsetof(OptionsContext, x)
3322 const OptionDef options[] = {
3324 CMDUTILS_COMMON_OPTIONS
3325 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3326 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3327 "force format", "fmt" },
3328 { "y", OPT_BOOL, { &file_overwrite },
3329 "overwrite output files" },
3330 { "n", OPT_BOOL, { &no_file_overwrite },
3331 "never overwrite output files" },
3332 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3333 "Ignore unknown stream types" },
3334 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3335 "Copy unknown stream types" },
3336 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3337 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3338 "codec name", "codec" },
3339 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3340 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3341 "codec name", "codec" },
3342 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3343 OPT_OUTPUT, { .off = OFFSET(presets) },
3344 "preset name", "preset" },
3345 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3346 OPT_OUTPUT, { .func_arg = opt_map },
3347 "set input stream mapping",
3348 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3349 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3350 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3351 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3352 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3353 "set metadata information of outfile from infile",
3354 "outfile[,metadata]:infile[,metadata]" },
3355 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3356 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3357 "set chapters mapping", "input_file_index" },
3358 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3359 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3360 "record or transcode \"duration\" seconds of audio/video",
3362 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3363 "record or transcode stop time", "time_stop" },
3364 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3365 "set the limit file size in bytes", "limit_size" },
3366 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3367 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3368 "set the start time offset", "time_off" },
3369 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3370 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3371 "set the start time offset relative to EOF", "time_off" },
3372 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3373 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3374 "enable/disable seeking by timestamp with -ss" },
3375 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3376 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3377 "enable/disable accurate seeking with -ss" },
3378 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3379 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3380 "set the input ts offset", "time_off" },
3381 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3382 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3383 "set the input ts scale", "scale" },
3384 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3385 "set the recording timestamp ('now' to set the current time)", "time" },
3386 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3387 "add metadata", "string=string" },
3388 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3389 "add program with specified streams", "title=string:st=number..." },
3390 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3391 OPT_OUTPUT, { .func_arg = opt_data_frames },
3392 "set the number of data frames to output", "number" },
3393 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3394 "add timings for benchmarking" },
3395 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3396 "add timings for each task" },
3397 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3398 "write program-readable progress information", "url" },
3399 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3400 "enable or disable interaction on standard input" },
3401 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3402 "set max runtime in seconds", "limit" },
3403 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3404 "dump each input packet" },
3405 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3406 "when dumping packets, also dump the payload" },
3407 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3408 OPT_INPUT, { .off = OFFSET(rate_emu) },
3409 "read input at native frame rate", "" },
3410 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3411 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3412 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3413 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3414 "video sync method", "" },
3415 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3416 "frame drop threshold", "" },
3417 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3418 "audio sync method", "" },
3419 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3420 "audio drift threshold", "threshold" },
3421 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3422 "copy timestamps" },
3423 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3424 "shift input timestamps to start at 0 when using copyts" },
3425 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3426 "copy input stream time base when stream copying", "mode" },
3427 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3428 OPT_OUTPUT, { .off = OFFSET(shortest) },
3429 "finish encoding within shortest input" },
3430 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3431 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3433 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3434 OPT_OUTPUT, { .off = OFFSET(apad) },
3436 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3437 "timestamp discontinuity delta threshold", "threshold" },
3438 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3439 "timestamp error delta threshold", "threshold" },
3440 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3441 "exit on error", "error" },
3442 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3443 "abort on the specified condition flags", "flags" },
3444 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3445 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3446 "copy initial non-keyframes" },
3447 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3448 "copy or discard frames before start time" },
3449 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3450 "set the number of frames to output", "number" },
3451 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3452 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3453 "force codec tag/fourcc", "fourcc/tag" },
3454 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3455 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3456 "use fixed quality scale (VBR)", "q" },
3457 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3458 OPT_OUTPUT, { .func_arg = opt_qscale },
3459 "use fixed quality scale (VBR)", "q" },
3460 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3461 "set profile", "profile" },
3462 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3463 "set stream filtergraph", "filter_graph" },
3464 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3465 "number of non-complex filter threads" },
3466 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3467 "read stream filtergraph description from a file", "filename" },
3468 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3469 "reinit filtergraph on input parameter changes", "" },
3470 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3471 "create a complex filtergraph", "graph_description" },
3472 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3473 "number of threads for -filter_complex" },
3474 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3475 "create a complex filtergraph", "graph_description" },
3476 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3477 "read complex filtergraph description from a file", "filename" },
3478 { "stats", OPT_BOOL, { &print_stats },
3479 "print progress report during encoding", },
3480 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3481 OPT_OUTPUT, { .func_arg = opt_attach },
3482 "add an attachment to the output file", "filename" },
3483 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3484 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3485 "extract an attachment into a file", "filename" },
3486 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3487 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3488 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3489 "print timestamp debugging info" },
3490 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3491 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3492 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3493 OPT_INPUT, { .off = OFFSET(discard) },
3495 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3496 OPT_OUTPUT, { .off = OFFSET(disposition) },
3497 "disposition", "" },
3498 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3499 { .off = OFFSET(thread_queue_size) },
3500 "set the maximum number of queued packets from the demuxer" },
3501 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3502 "read and decode the streams to fill missing information with heuristics" },
3505 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3506 "set the number of video frames to output", "number" },
3507 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3508 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3509 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3510 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3511 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3512 "set frame size (WxH or abbreviation)", "size" },
3513 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3514 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3515 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3516 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3517 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3518 "set pixel format", "format" },
3519 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3520 "set the number of bits per raw sample", "number" },
3521 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3522 "deprecated use -g 1" },
3523 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3525 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3526 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3527 "rate control override for specific intervals", "override" },
3528 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3529 OPT_OUTPUT, { .func_arg = opt_video_codec },
3530 "force video codec ('copy' to copy stream)", "codec" },
3531 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3533 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3535 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3536 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3537 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3538 "select the pass number (1 to 3)", "n" },
3539 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3540 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3541 "select two pass log file name prefix", "prefix" },
3542 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3543 "this option is deprecated, use the yadif filter instead" },
3544 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3545 "calculate PSNR of compressed frames" },
3546 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3547 "dump video coding statistics to file" },
3548 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3549 "dump video coding statistics to file", "file" },
3550 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3551 "Version of the vstats format to use."},
3552 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3553 "set video filters", "filter_graph" },
3554 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3555 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3556 "specify intra matrix coeffs", "matrix" },
3557 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3558 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3559 "specify inter matrix coeffs", "matrix" },
3560 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3561 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3562 "specify intra matrix coeffs", "matrix" },
3563 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3564 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3565 "top=1/bottom=0/auto=-1 field first", "" },
3566 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3567 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3568 "force video tag/fourcc", "fourcc/tag" },
3569 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3570 "show QP histogram" },
3571 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3572 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3573 "force the selected framerate, disable the best supported framerate selection" },
3574 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3575 OPT_OUTPUT, { .func_arg = opt_streamid },
3576 "set the value of an outfile streamid", "streamIndex:value" },
3577 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3578 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3579 "force key frames at specified timestamps", "timestamps" },
3580 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3581 "audio bitrate (please use -b:a)", "bitrate" },
3582 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3583 "video bitrate (please use -b:v)", "bitrate" },
3584 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3585 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3586 "use HW accelerated decoding", "hwaccel name" },
3587 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3588 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3589 "select a device for HW acceleration", "devicename" },
3590 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3591 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3592 "select output format used with HW accelerated decoding", "format" },
3593 #if CONFIG_VIDEOTOOLBOX
3594 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3596 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3597 "show available HW acceleration methods" },
3598 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3599 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3600 "automatically insert correct rotate filters" },
3603 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3604 "set the number of audio frames to output", "number" },
3605 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3606 "set audio quality (codec-specific)", "quality", },
3607 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3608 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3609 "set audio sampling rate (in Hz)", "rate" },
3610 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3611 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3612 "set number of audio channels", "channels" },
3613 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3615 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3616 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3617 "force audio codec ('copy' to copy stream)", "codec" },
3618 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3619 OPT_OUTPUT, { .func_arg = opt_old2new },
3620 "force audio tag/fourcc", "fourcc/tag" },
3621 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3622 "change audio volume (256=normal)" , "volume" },
3623 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3624 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3625 "set sample format", "format" },
3626 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3627 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3628 "set channel layout", "layout" },
3629 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3630 "set audio filters", "filter_graph" },
3631 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3632 "set the maximum number of channels to try to guess the channel layout" },
3634 /* subtitle options */
3635 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3636 "disable subtitle" },
3637 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3638 "force subtitle codec ('copy' to copy stream)", "codec" },
3639 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3640 , "force subtitle tag/fourcc", "fourcc/tag" },
3641 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3642 "fix subtitles duration" },
3643 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3644 "set canvas size (WxH or abbreviation)", "size" },
3647 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3648 "deprecated, use -channel", "channel" },
3649 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3650 "deprecated, use -standard", "standard" },
3651 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3654 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3655 "set the maximum demux-decode delay", "seconds" },
3656 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3657 "set the initial demux-decode delay", "seconds" },
3658 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3659 "specify a file in which to print sdp information", "file" },
3661 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3662 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3663 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3664 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3665 "two special values are defined - "
3666 "0 = use frame rate (video) or sample rate (audio),"
3667 "-1 = match source time base", "ratio" },
3669 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3670 "A comma-separated list of bitstream filters", "bitstream_filters" },
3671 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3672 "deprecated", "audio bitstream_filters" },
3673 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3674 "deprecated", "video bitstream_filters" },
3676 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3677 "set the audio options to the indicated preset", "preset" },
3678 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3679 "set the video options to the indicated preset", "preset" },
3680 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3681 "set the subtitle options to the indicated preset", "preset" },
3682 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3683 "set options from indicated preset file", "filename" },
3685 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3686 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3688 /* data codec support */
3689 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3690 "force data codec ('copy' to copy stream)", "codec" },
3691 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3695 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3696 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3700 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3701 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3704 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3705 "initialise hardware device", "args" },
3706 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3707 "set hardware device used when filtering", "device" },