46#include "libavutil/avassert.h"
47#include "libavutil/avstring.h"
48#include "libavutil/bprint.h"
49#include "libavutil/channel_layout.h"
50#include "libavutil/cpu.h"
51#include "libavutil/dict.h"
52#include "libavutil/error.h"
53#include "libavutil/ffversion.h"
54#include "libavutil/log.h"
55#include "libavutil/mem.h"
56#include "libavutil/parseutils.h"
57#include "libavutil/pixdesc.h"
58#include "libavutil/version.h"
60#include "libavcodec/avcodec.h"
61#include "libavcodec/bsf.h"
62#include "libavcodec/codec.h"
63#include "libavcodec/codec_desc.h"
64#include "libavcodec/version.h"
66#include "libavformat/avformat.h"
67#include "libavformat/version.h"
69#include "libavdevice/avdevice.h"
70#include "libavdevice/version.h"
72#include "libavfilter/avfilter.h"
73#include "libavfilter/version.h"
75#include "libswscale/swscale.h"
76#include "libswscale/version.h"
78#include "libswresample/swresample.h"
79#include "libswresample/version.h"
97 av_log(NULL, AV_LOG_ERROR,
98 "This version of %s has nonfree parts compiled in.\n"
99 "Therefore it is not legally redistributable.\n",
102 av_log(NULL, AV_LOG_ERROR,
103 "%s is free software; you can redistribute it and/or modify\n"
104 "it under the terms of the GNU General Public License as published by\n"
105 "the Free Software Foundation; either version 3 of the License, or\n"
106 "(at your option) any later version.\n"
108 "%s is distributed in the hope that it will be useful,\n"
109 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
110 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
111 "GNU General Public License for more details.\n"
113 "You should have received a copy of the GNU General Public License\n"
114 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
117 av_log(NULL, AV_LOG_ERROR,
118 "%s is free software; you can redistribute it and/or modify\n"
119 "it under the terms of the GNU General Public License as published by\n"
120 "the Free Software Foundation; either version 2 of the License, or\n"
121 "(at your option) any later version.\n"
123 "%s is distributed in the hope that it will be useful,\n"
124 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
125 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
126 "GNU General Public License for more details.\n"
128 "You should have received a copy of the GNU General Public License\n"
129 "along with %s; if not, write to the Free Software\n"
130 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
133 av_log(NULL, AV_LOG_ERROR,
134 "%s is free software; you can redistribute it and/or modify\n"
135 "it under the terms of the GNU Lesser General Public License as published by\n"
136 "the Free Software Foundation; either version 3 of the License, or\n"
137 "(at your option) any later version.\n"
139 "%s is distributed in the hope that it will be useful,\n"
140 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
141 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
142 "GNU Lesser General Public License for more details.\n"
144 "You should have received a copy of the GNU Lesser General Public License\n"
145 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
148 av_log(NULL, AV_LOG_ERROR,
149 "%s is free software; you can redistribute it and/or\n"
150 "modify it under the terms of the GNU Lesser General Public\n"
151 "License as published by the Free Software Foundation; either\n"
152 "version 2.1 of the License, or (at your option) any later version.\n"
154 "%s is distributed in the hope that it will be useful,\n"
155 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
156 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
157 "Lesser General Public License for more details.\n"
159 "You should have received a copy of the GNU Lesser General Public\n"
160 "License along with %s; if not, write to the Free Software\n"
161 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
171#define SHOW_VERSION 2
173#define SHOW_COPYRIGHT 8
175#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
176 if (CONFIG_##LIBNAME) { \
177 const char *indent = flags & INDENT? " " : ""; \
178 if (flags & SHOW_VERSION) { \
179 unsigned int version = libname##_version(); \
180 av_log(NULL, level, \
181 "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
183 LIB##LIBNAME##_VERSION_MAJOR, \
184 LIB##LIBNAME##_VERSION_MINOR, \
185 LIB##LIBNAME##_VERSION_MICRO, \
186 AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
187 AV_VERSION_MICRO(version)); \
189 if (flags & SHOW_CONFIG) { \
190 const char *cfg = libname##_configuration(); \
191 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
193 av_log(NULL, level, \
194 "%sWARNING: library configuration mismatch\n", \
198 av_log(NULL, level, "%s%-11s configuration: %s\n", \
199 indent, #libname, cfg); \
217 const char *indent = flags &
INDENT?
" " :
"";
219 av_log(NULL, level,
"%s version " FFMPEG_VERSION,
program_name);
221 av_log(NULL, level,
" Copyright (c) %d-%d the FFmpeg developers",
223 av_log(NULL, level,
"\n");
224 av_log(NULL, level,
"%sbuilt with %s\n", indent, CC_IDENT);
226 av_log(NULL, level,
"%sconfiguration: " FFMPEG_CONFIGURATION
"\n", indent);
231 const char *indent = flags &
INDENT ?
" " :
"";
232 char str[] = { FFMPEG_CONFIGURATION };
233 char *conflist, *remove_tilde, *splitconf;
237 while ((conflist = strstr(str,
" --")) != NULL) {
243 while ((remove_tilde = strstr(str,
"pkg-config~")) != NULL) {
244 remove_tilde[
sizeof(
"pkg-config~") - 2] =
' ';
247 splitconf = strtok(str,
"~");
248 av_log(NULL, level,
"\n%sconfiguration:\n", indent);
249 while (splitconf != NULL) {
250 av_log(NULL, level,
"%s%s%s\n", indent, indent, splitconf);
251 splitconf = strtok(NULL,
"~");
281#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
282 if (codec->field) { \
283 const type *p = codec->field; \
285 av_log(NULL, AV_LOG_ERROR, " Supported " list_name ":"); \
286 while (*p != term) { \
288 av_log(NULL, AV_LOG_ERROR, " %s", name); \
291 av_log(NULL, AV_LOG_ERROR, "\n"); \
296 int encoder = av_codec_is_encoder(c);
298 av_log(NULL, AV_LOG_ERROR,
"%s %s [%s]:\n", encoder ?
"Encoder" :
"Decoder", c->name,
299 c->long_name ? c->long_name :
"");
301 av_log(NULL, AV_LOG_ERROR,
" General capabilities: ");
302 if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
303 av_log(NULL, AV_LOG_ERROR,
"horizband ");
304 if (c->capabilities & AV_CODEC_CAP_DR1)
305 av_log(NULL, AV_LOG_ERROR,
"dr1 ");
306 if (c->capabilities & AV_CODEC_CAP_DELAY)
307 av_log(NULL, AV_LOG_ERROR,
"delay ");
308 if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
309 av_log(NULL, AV_LOG_ERROR,
"small ");
310 if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
311 av_log(NULL, AV_LOG_ERROR,
"subframes ");
312 if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
313 av_log(NULL, AV_LOG_ERROR,
"exp ");
314 if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
315 av_log(NULL, AV_LOG_ERROR,
"chconf ");
316 if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
317 av_log(NULL, AV_LOG_ERROR,
"paramchange ");
318 if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
319 av_log(NULL, AV_LOG_ERROR,
"variable ");
320 if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
321 AV_CODEC_CAP_SLICE_THREADS |
322 AV_CODEC_CAP_OTHER_THREADS))
323 av_log(NULL, AV_LOG_ERROR,
"threads ");
324 if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
325 av_log(NULL, AV_LOG_ERROR,
"avoidprobe ");
326 if (c->capabilities & AV_CODEC_CAP_HARDWARE)
327 av_log(NULL, AV_LOG_ERROR,
"hardware ");
328 if (c->capabilities & AV_CODEC_CAP_HYBRID)
329 av_log(NULL, AV_LOG_ERROR,
"hybrid ");
330 if (!c->capabilities)
331 av_log(NULL, AV_LOG_ERROR,
"none");
332 av_log(NULL, AV_LOG_ERROR,
"\n");
334 if (c->type == AVMEDIA_TYPE_VIDEO ||
335 c->type == AVMEDIA_TYPE_AUDIO) {
336 av_log(NULL, AV_LOG_ERROR,
" Threading capabilities: ");
337 switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
338 AV_CODEC_CAP_SLICE_THREADS |
339 AV_CODEC_CAP_OTHER_THREADS)) {
340 case AV_CODEC_CAP_FRAME_THREADS |
341 AV_CODEC_CAP_SLICE_THREADS: av_log(NULL, AV_LOG_ERROR,
"frame and slice");
break;
342 case AV_CODEC_CAP_FRAME_THREADS: av_log(NULL, AV_LOG_ERROR,
"frame");
break;
343 case AV_CODEC_CAP_SLICE_THREADS: av_log(NULL, AV_LOG_ERROR,
"slice");
break;
344 case AV_CODEC_CAP_OTHER_THREADS: av_log(NULL, AV_LOG_ERROR,
"other");
break;
345 default: av_log(NULL, AV_LOG_ERROR,
"none");
break;
347 av_log(NULL, AV_LOG_ERROR,
"\n");
350 if (avcodec_get_hw_config(c, 0)) {
351 av_log(NULL, AV_LOG_ERROR,
" Supported hardware devices: ");
352 for (
int i = 0;; i++) {
353 const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
356 av_log(NULL, AV_LOG_ERROR,
"%s ", av_hwdevice_get_type_name(config->device_type));
358 av_log(NULL, AV_LOG_ERROR,
"\n");
361 if (c->supported_framerates) {
362 const AVRational *fps = c->supported_framerates;
364 av_log(NULL, AV_LOG_ERROR,
" Supported framerates:");
366 av_log(NULL, AV_LOG_ERROR,
" %d/%d", fps->num, fps->den);
369 av_log(NULL, AV_LOG_ERROR,
"\n");
379 const AVChannelLayout *p = c->ch_layouts;
381 av_log(NULL, AV_LOG_ERROR,
" Supported channel layouts:");
382 while (p->nb_channels) {
384 av_channel_layout_describe(p, name,
sizeof(name));
385 av_log(NULL, AV_LOG_ERROR,
" %s", name);
388 av_log(NULL, AV_LOG_ERROR,
"\n");
393 AV_OPT_FLAG_ENCODING_PARAM |
394 AV_OPT_FLAG_DECODING_PARAM);
402 while ((c = av_codec_iterate(iter))) {
404 (encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
412 const AVCodecDescriptor *desc;
413 const AVCodec *codec;
416 av_log(NULL, AV_LOG_ERROR,
"No codec name specified.\n");
420 codec = encoder ? avcodec_find_encoder_by_name(name) :
421 avcodec_find_decoder_by_name(name);
425 else if ((desc = avcodec_descriptor_get_by_name(name))) {
435 av_log(NULL, AV_LOG_ERROR,
"Codec '%s' is known to FFmpeg, "
436 "but no %s for it are available. FFmpeg might need to be "
437 "recompiled with additional external libraries.\n",
438 name, encoder ?
"encoders" :
"decoders");
441 av_log(NULL, AV_LOG_ERROR,
"Codec '%s' is not recognized by FFmpeg.\n",
448 const AVInputFormat *fmt = av_find_input_format(name);
451 av_log(NULL, AV_LOG_ERROR,
"Unknown format '%s'.\n", name);
455 av_log(NULL, AV_LOG_ERROR,
"Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
458 av_log(NULL, AV_LOG_ERROR,
" Common extensions: %s.\n", fmt->extensions);
466 const AVClass *proto_class;
469 av_log(NULL, AV_LOG_ERROR,
"No protocol name specified.\n");
473 proto_class = avio_protocol_get_class(name);
475 av_log(NULL, AV_LOG_ERROR,
"Unknown protocol '%s'.\n", name);
479 show_help_children(proto_class, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
484 const AVCodecDescriptor *desc;
485 const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
488 av_log(NULL, AV_LOG_ERROR,
"Unknown format '%s'.\n", name);
492 av_log(NULL, AV_LOG_ERROR,
"Muxer %s [%s]:\n", fmt->name, fmt->long_name);
495 av_log(NULL, AV_LOG_ERROR,
" Common extensions: %s.\n", fmt->extensions);
497 av_log(NULL, AV_LOG_ERROR,
" Mime type: %s.\n", fmt->mime_type);
498 if (fmt->video_codec != AV_CODEC_ID_NONE &&
499 (desc = avcodec_descriptor_get(fmt->video_codec))) {
500 av_log(NULL, AV_LOG_ERROR,
" Default video codec: %s.\n", desc->name);
502 if (fmt->audio_codec != AV_CODEC_ID_NONE &&
503 (desc = avcodec_descriptor_get(fmt->audio_codec))) {
504 av_log(NULL, AV_LOG_ERROR,
" Default audio codec: %s.\n", desc->name);
506 if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
507 (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
508 av_log(NULL, AV_LOG_ERROR,
" Default subtitle codec: %s.\n", desc->name);
516static void show_help_filter(
const char *name)
519 const AVFilter *f = avfilter_get_by_name(name);
523 av_log(NULL, AV_LOG_ERROR,
"No filter name specified.\n");
526 av_log(NULL, AV_LOG_ERROR,
"Unknown filter '%s'.\n", name);
530 av_log(NULL, AV_LOG_ERROR,
"Filter %s\n", f->name);
532 av_log(NULL, AV_LOG_ERROR,
" %s\n", f->description);
534 if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
535 av_log(NULL, AV_LOG_ERROR,
" slice threading supported\n");
537 av_log(NULL, AV_LOG_ERROR,
" Inputs:\n");
538 count = avfilter_filter_pad_count(f, 0);
539 for (i = 0; i < count; i++) {
540 av_log(NULL, AV_LOG_ERROR,
" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
541 av_get_media_type_string(avfilter_pad_get_type(f->inputs, i)));
543 if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
544 av_log(NULL, AV_LOG_ERROR,
" dynamic (depending on the options)\n");
546 av_log(NULL, AV_LOG_ERROR,
" none (source filter)\n");
548 av_log(NULL, AV_LOG_ERROR,
" Outputs:\n");
549 count = avfilter_filter_pad_count(f, 1);
550 for (i = 0; i < count; i++) {
551 av_log(NULL, AV_LOG_ERROR,
" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
552 av_get_media_type_string(avfilter_pad_get_type(f->outputs, i)));
554 if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
555 av_log(NULL, AV_LOG_ERROR,
" dynamic (depending on the options)\n");
557 av_log(NULL, AV_LOG_ERROR,
" none (sink filter)\n");
560 show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
561 AV_OPT_FLAG_AUDIO_PARAM);
562 if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
563 av_log(NULL, AV_LOG_ERROR,
"This filter has support for timeline through the 'enable' option.\n");
565 av_log(NULL, AV_LOG_ERROR,
"Build without libavfilter; "
566 "can not to satisfy request\n");
573 const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
576 av_log(NULL, AV_LOG_ERROR,
"No bitstream filter name specified.\n");
579 av_log(NULL, AV_LOG_ERROR,
"Unknown bit stream filter '%s'.\n", name);
583 av_log(NULL, AV_LOG_ERROR,
"Bit stream filter %s\n", bsf->name);
590int show_help(
void *optctx,
const char *opt,
const char *arg)
594 topic = av_strdup(arg ? arg :
"");
596 return AVERROR(ENOMEM);
597 par = strchr(topic,
'=');
607 }
else if (!strcmp(topic,
"decoder")) {
609 }
else if (!strcmp(topic,
"encoder")) {
611 }
else if (!strcmp(topic,
"demuxer")) {
613 }
else if (!strcmp(topic,
"muxer")) {
615 }
else if (!strcmp(topic,
"protocol")) {
618 }
else if (!strcmp(topic,
"filter")) {
619 show_help_filter(par);
621 }
else if (!strcmp(topic,
"bsf")) {
638 const AVCodec *codec;
640 av_log(NULL, AV_LOG_ERROR,
" (%s: ", encoder ?
"encoders" :
"decoders");
643 av_log(NULL, AV_LOG_ERROR,
"%s ", codec->name);
645 av_log(NULL, AV_LOG_ERROR,
")");
650 const AVCodecDescriptor *
const *da = a;
651 const AVCodecDescriptor *
const *db = b;
653 return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
654 strcmp((*da)->name, (*db)->name);
659 const AVCodecDescriptor *desc = NULL;
660 const AVCodecDescriptor **codecs;
661 unsigned nb_codecs = 0, i = 0;
663 while ((desc = avcodec_descriptor_next(desc)))
665 if (!(codecs = av_calloc(nb_codecs,
sizeof(*codecs)))) {
666 av_log(NULL, AV_LOG_ERROR,
"Out of memory\n");
670 while ((desc = avcodec_descriptor_next(desc)))
672 av_assert0(i == nb_codecs);
681 case AVMEDIA_TYPE_VIDEO:
return 'V';
682 case AVMEDIA_TYPE_AUDIO:
return 'A';
683 case AVMEDIA_TYPE_DATA:
return 'D';
684 case AVMEDIA_TYPE_SUBTITLE:
return 'S';
685 case AVMEDIA_TYPE_ATTACHMENT:
return 'T';
692 const AVCodecDescriptor **codecs;
695 av_log(NULL, AV_LOG_ERROR,
"Codecs:\n"
696 " D..... = Decoding supported\n"
697 " .E.... = Encoding supported\n"
698 " ..V... = Video codec\n"
699 " ..A... = Audio codec\n"
700 " ..S... = Subtitle codec\n"
701 " ..D... = Data codec\n"
702 " ..T... = Attachment codec\n"
703 " ...I.. = Intra frame-only codec\n"
704 " ....L. = Lossy compression\n"
705 " .....S = Lossless compression\n"
707 for (i = 0; i < nb_codecs; i++) {
708 const AVCodecDescriptor *desc = codecs[i];
709 const AVCodec *codec;
712 if (strstr(desc->name,
"_deprecated"))
715 av_log(NULL, AV_LOG_ERROR,
" ");
716 av_log(NULL, AV_LOG_ERROR, avcodec_find_decoder(desc->id) ?
"D" :
".");
717 av_log(NULL, AV_LOG_ERROR, avcodec_find_encoder(desc->id) ?
"E" :
".");
720 av_log(NULL, AV_LOG_ERROR, (desc->props & AV_CODEC_PROP_INTRA_ONLY) ?
"I" :
".");
721 av_log(NULL, AV_LOG_ERROR, (desc->props & AV_CODEC_PROP_LOSSY) ?
"L" :
".");
722 av_log(NULL, AV_LOG_ERROR, (desc->props & AV_CODEC_PROP_LOSSLESS) ?
"S" :
".");
724 av_log(NULL, AV_LOG_ERROR,
" %-20s %s", desc->name, desc->long_name ? desc->long_name :
"");
729 if (strcmp(codec->name, desc->name)) {
736 if (strcmp(codec->name, desc->name)) {
742 av_log(NULL, AV_LOG_ERROR,
"\n");
750 const AVCodecDescriptor **codecs;
753 av_log(NULL, AV_LOG_ERROR,
"%s:\n"
756 " S..... = Subtitle\n"
757 " .F.... = Frame-level multithreading\n"
758 " ..S... = Slice-level multithreading\n"
759 " ...X.. = Codec is experimental\n"
760 " ....B. = Supports draw_horiz_band\n"
761 " .....D = Supports direct rendering method 1\n"
763 encoder ?
"Encoders" :
"Decoders");
764 for (i = 0; i < nb_codecs; i++) {
765 const AVCodecDescriptor *desc = codecs[i];
766 const AVCodec *codec;
771 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ?
"F" :
".");
772 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ?
"S" :
".");
773 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ?
"X" :
".");
774 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?
"B" :
".");
775 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_DR1) ?
"D" :
".");
777 av_log(NULL, AV_LOG_ERROR,
" %-20s %s", codec->name, codec->long_name ? codec->long_name :
"");
778 if (strcmp(codec->name, desc->name))
779 av_log(NULL, AV_LOG_ERROR,
" (codec %s)", desc->name);
781 av_log(NULL, AV_LOG_ERROR,
"\n");
799int show_bsfs(
void *optctx,
const char *opt,
const char *arg)
801 const AVBitStreamFilter *bsf = NULL;
804 av_log(NULL, AV_LOG_ERROR,
"Bitstream filters:\n");
805 while ((bsf = av_bsf_iterate(&opaque)))
806 av_log(NULL, AV_LOG_ERROR,
"%s\n", bsf->name);
807 av_log(NULL, AV_LOG_ERROR,
"\n");
814 const AVFilter *filter = NULL;
815 char descr[64], *descr_cur;
818 const AVFilterPad *pad;
820 av_log(NULL, AV_LOG_ERROR,
"Filters:\n"
821 " T.. = Timeline support\n"
822 " .S. = Slice threading\n"
823 " ..C = Command support\n"
824 " A = Audio input/output\n"
825 " V = Video input/output\n"
826 " N = Dynamic number and/or type of input/output\n"
827 " | = Source or sink filter\n");
828 while ((filter = av_filter_iterate(&opaque))) {
830 for (i = 0; i < 2; i++) {
833 *(descr_cur++) =
'-';
834 *(descr_cur++) =
'>';
836 pad = i ? filter->outputs : filter->inputs;
837 nb_pads = avfilter_filter_pad_count(filter, i);
838 for (j = 0; j < nb_pads; j++) {
839 if (descr_cur >= descr +
sizeof(descr) - 4)
844 *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
845 ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ?
'N' :
'|';
848 av_log(NULL, AV_LOG_ERROR,
" %c%c%c %-17s %-10s %s\n",
849 filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ?
'T' :
'.',
850 filter->flags & AVFILTER_FLAG_SLICE_THREADS ?
'S' :
'.',
851 filter->process_command ?
'C' :
'.',
852 filter->name, descr, filter->description);
855 av_log(NULL, AV_LOG_ERROR,
"No filters available: libavfilter disabled\n");
864 return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
867static int show_formats_devices(
void *optctx,
const char *opt,
const char *arg,
int device_only,
int muxdemuxers)
869 void *ifmt_opaque = NULL;
870 const AVInputFormat *ifmt = NULL;
871 void *ofmt_opaque = NULL;
872 const AVOutputFormat *ofmt = NULL;
873 const char *last_name;
876 av_log(NULL, AV_LOG_ERROR,
"%s\n"
877 " D. = Demuxing supported\n"
878 " .E = Muxing supported\n"
879 " --\n", device_only ?
"Devices:" :
"File formats:");
884 const char *name = NULL;
885 const char *long_name = NULL;
889 while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
891 if (!is_dev && device_only)
893 if ((!name || strcmp(ofmt->name, name) < 0) &&
894 strcmp(ofmt->name, last_name) > 0) {
896 long_name = ofmt->long_name;
903 while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
905 if (!is_dev && device_only)
907 if ((!name || strcmp(ifmt->name, name) < 0) &&
908 strcmp(ifmt->name, last_name) > 0) {
910 long_name = ifmt->long_name;
913 if (name && strcmp(ifmt->name, name) == 0)
921 av_log(NULL, AV_LOG_ERROR,
" %c%c %-15s %s\n",
925 long_name ? long_name:
" ");
955 av_log(NULL, AV_LOG_ERROR,
"Supported file protocols:\n"
957 while ((name = avio_enum_protocols(&opaque, 0)))
958 av_log(NULL, AV_LOG_ERROR,
" %s\n", name);
959 av_log(NULL, AV_LOG_ERROR,
"Output:\n");
960 while ((name = avio_enum_protocols(&opaque, 1)))
961 av_log(NULL, AV_LOG_ERROR,
" %s\n", name);
971 av_log(NULL, AV_LOG_ERROR,
"%-32s #RRGGBB\n",
"name");
973 for (i = 0; (name = av_get_known_color_name(i, &rgb)); i++)
974 av_log(NULL, AV_LOG_ERROR,
"%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
981 const AVPixFmtDescriptor *pix_desc = NULL;
983 av_log(NULL, AV_LOG_ERROR,
"Pixel formats:\n"
984 "I.... = Supported Input format for conversion\n"
985 ".O... = Supported Output format for conversion\n"
986 "..H.. = Hardware accelerated format\n"
987 "...P. = Paletted format\n"
988 "....B = Bitstream format\n"
989 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL BIT_DEPTHS\n"
993# define sws_isSupportedInput(x) 0
994# define sws_isSupportedOutput(x) 0
997 while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
998 enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
999 av_log(NULL, AV_LOG_ERROR,
"%c%c%c%c%c %-16s %d %3d %d",
1002 pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ?
'H' :
'.',
1003 pix_desc->flags & AV_PIX_FMT_FLAG_PAL ?
'P' :
'.',
1004 pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ?
'B' :
'.',
1006 pix_desc->nb_components,
1007 av_get_bits_per_pixel(pix_desc),
1008 pix_desc->comp[0].depth);
1010 for (
unsigned i = 1; i < pix_desc->nb_components; i++)
1011 av_log(NULL, AV_LOG_ERROR,
"-%d", pix_desc->comp[i].depth);
1012 av_log(NULL, AV_LOG_ERROR,
"\n");
1019 const AVChannelLayout *ch_layout;
1021 char buf[128], buf2[128];
1024 av_log(NULL, AV_LOG_ERROR,
"Individual channels:\n"
1025 "NAME DESCRIPTION\n");
1026 for (i = 0; i < 63; i++) {
1027 av_channel_name(buf,
sizeof(buf), i);
1028 if (strstr(buf,
"USR"))
1030 av_channel_description(buf2,
sizeof(buf2), i);
1031 av_log(NULL, AV_LOG_ERROR,
"%-14s %s\n", buf, buf2);
1033 av_log(NULL, AV_LOG_ERROR,
"\nStandard channel layouts:\n"
1034 "NAME DECOMPOSITION\n");
1035 while ((ch_layout = av_channel_layout_standard(&iter))) {
1036 av_channel_layout_describe(ch_layout, buf,
sizeof(buf));
1037 av_log(NULL, AV_LOG_ERROR,
"%-14s ", buf);
1038 for (i = 0; i < 63; i++) {
1039 int idx = av_channel_layout_index_from_channel(ch_layout, i);
1041 av_channel_name(buf2,
sizeof(buf2), i);
1042 av_log(NULL, AV_LOG_ERROR,
"%s%s", idx ?
"+" :
"", buf2);
1045 av_log(NULL, AV_LOG_ERROR,
"\n");
1054 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1055 av_log(NULL, AV_LOG_ERROR,
"%s\n", av_get_sample_fmt_string(fmt_str,
sizeof(fmt_str), i));
1061 for (
int i = 0; i < 32; i++) {
1062 const char *str = av_disposition_to_string(1U << i);
1064 av_log(NULL, AV_LOG_ERROR,
"%s\n", str);
1072 unsigned flags = av_get_cpu_flags();
1074 if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
1077 av_force_cpu_flags(flags);
1086 static const AVOption opts[] = {
1087 {
"count", NULL, 0, AV_OPT_TYPE_INT, { .i64 = -1}, -1, INT_MAX},
1090 static const AVClass
class = {
1091 .class_name =
"cpucount",
1092 .item_name = av_default_item_name,
1094 .version = LIBAVUTIL_VERSION_INT,
1096 const AVClass *pclass = &
class;
1098 ret = av_opt_eval_int(&pclass, opts, arg, &count);
1101 av_cpu_force_count(count);
1112 while ((c = *(
template++))) {
1114 if (!(c = *(
template++)))
1121 av_bprintf(bp,
"%04d%02d%02d-%02d%02d%02d",
1122 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1123 tm->tm_hour, tm->tm_min, tm->tm_sec);
1126 av_bprint_chars(bp, c, 1);
1130 av_bprint_chars(bp, c, 1);
1139 static int print_prefix = 1;
1143 av_log_default_callback(ptr, level, fmt, vl);
1147 av_log_format_line(ptr, level, fmt, vl2, line,
sizeof(line), &print_prefix);
1157 char *filename_template = NULL;
1160 int prog_loglevel, envlevel = 0;
1168 tm = localtime(&now);
1170 while (env && *env) {
1171 if ((ret = av_opt_get_key_value(&env,
"=",
":", 0, &key, &val)) < 0) {
1173 av_log(NULL, AV_LOG_ERROR,
1174 "Failed to parse FFREPORT environment variable: %s\n",
1181 if (!strcmp(key,
"file")) {
1182 av_free(filename_template);
1183 filename_template = val;
1185 }
else if (!strcmp(key,
"level")) {
1189 av_log(NULL, AV_LOG_FATAL,
"Invalid report file level\n");
1194 av_log(NULL, AV_LOG_ERROR,
"Unknown key '%s' in FFREPORT\n", key);
1200 av_bprint_init(&filename, 0, AV_BPRINT_SIZE_AUTOMATIC);
1202 av_x_if_null(filename_template,
"%p-%t.log"), tm);
1203 av_free(filename_template);
1204 if (!av_bprint_is_complete(&filename)) {
1205 av_log(NULL, AV_LOG_ERROR,
"Out of memory building report file name\n");
1206 return AVERROR(ENOMEM);
1209 prog_loglevel = av_log_get_level();
1215 int ret = AVERROR(errno);
1216 av_log(NULL, AV_LOG_ERROR,
"Failed to open report \"%s\": %s\n",
1217 filename.str, strerror(errno));
1221 av_log(NULL, AV_LOG_INFO,
1222 "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1223 "Report written to \"%s\"\n"
1226 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1227 tm->tm_hour, tm->tm_min, tm->tm_sec,
1229 av_bprint_finalize(&filename, NULL);
1247 max = strtol(arg, &tail, 10);
1249 av_log(NULL, AV_LOG_FATAL,
"Invalid max_alloc \"%s\".\n", arg);
1258 const struct {
const char *name;
int level; } log_levels[] = {
1259 {
"quiet" , AV_LOG_QUIET },
1260 {
"panic" , AV_LOG_PANIC },
1261 {
"fatal" , AV_LOG_FATAL },
1262 {
"error" , AV_LOG_ERROR },
1263 {
"warning", AV_LOG_WARNING },
1264 {
"info" , AV_LOG_INFO },
1265 {
"verbose", AV_LOG_VERBOSE },
1266 {
"debug" , AV_LOG_DEBUG },
1267 {
"trace" , AV_LOG_TRACE },
1271 int flags = av_log_get_flags();
1272 int level = av_log_get_level();
1278 if (*token ==
'+' || *token ==
'-') {
1286 if (av_strstart(token,
"repeat", &arg)) {
1288 flags |= AV_LOG_SKIP_REPEATED;
1290 flags &= ~AV_LOG_SKIP_REPEATED;
1292 }
else if (av_strstart(token,
"level", &arg)) {
1294 flags &= ~AV_LOG_PRINT_LEVEL;
1296 flags |= AV_LOG_PRINT_LEVEL;
1305 }
else if (*arg ==
'+') {
1308 flags = av_log_get_flags();
1311 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
1312 if (!strcmp(log_levels[i].name, arg)) {
1313 level = log_levels[i].level;
1318 level = strtol(arg, &tail, 10);
1320 av_log(NULL, AV_LOG_FATAL,
"Invalid loglevel \"%s\". "
1321 "Possible levels are numbers or:\n", arg);
1322 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
1323 av_log(NULL, AV_LOG_FATAL,
"\"%s\"\n", log_levels[i].name);
1328 av_log_set_flags(flags);
1329 av_log_set_level(level);
1334static void print_device_list(
const AVDeviceInfoList *device_list)
1337 for (
int i = 0; i < device_list->nb_devices; i++) {
1338 const AVDeviceInfo *device = device_list->devices[i];
1339 av_log(NULL, AV_LOG_ERROR,
"%c %s [%s] (", device_list->default_device == i ?
'*' :
' ',
1340 device->device_name, device->device_description);
1341 if (device->nb_media_types > 0) {
1342 for (
int j = 0; j < device->nb_media_types; ++j) {
1343 const char* media_type = av_get_media_type_string(device->media_types[j]);
1345 av_log(NULL, AV_LOG_ERROR,
", ");
1346 av_log(NULL, AV_LOG_ERROR,
"%s", media_type ? media_type :
"unknown");
1349 av_log(NULL, AV_LOG_ERROR,
"none");
1351 av_log(NULL, AV_LOG_ERROR,
")\n");
1355static int print_device_sources(
const AVInputFormat *fmt, AVDictionary *opts)
1358 AVDeviceInfoList *device_list = NULL;
1360 if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
1361 return AVERROR(EINVAL);
1363 av_log(NULL, AV_LOG_ERROR,
"Auto-detected sources for %s:\n", fmt->name);
1364 if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
1365 av_log(NULL, AV_LOG_ERROR,
"Cannot list sources: %s\n", av_err2str(ret));
1369 print_device_list(device_list);
1372 avdevice_free_list_devices(&device_list);
1376static int print_device_sinks(
const AVOutputFormat *fmt, AVDictionary *opts)
1379 AVDeviceInfoList *device_list = NULL;
1381 if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
1382 return AVERROR(EINVAL);
1384 av_log(NULL, AV_LOG_ERROR,
"Auto-detected sinks for %s:\n", fmt->name);
1385 if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
1386 av_log(NULL, AV_LOG_ERROR,
"Cannot list sinks: %s\n", av_err2str(ret));
1390 print_device_list(device_list);
1393 avdevice_free_list_devices(&device_list);
1397static int show_sinks_sources_parse_arg(
const char *arg,
char **dev, AVDictionary **opts)
1401 char *opts_str = NULL;
1402 av_assert0(dev && opts);
1403 *dev = av_strdup(arg);
1405 return AVERROR(ENOMEM);
1406 if ((opts_str = strchr(*dev,
','))) {
1407 *(opts_str++) =
'\0';
1408 if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str,
"=",
":", 0)) < 0)) {
1414 av_log(NULL, AV_LOG_ERROR,
"\nDevice name is not provided.\n"
1415 "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
1419int show_sources(
void *optctx,
const char *opt,
const char *arg)
1421 const AVInputFormat *fmt = NULL;
1423 AVDictionary *opts = NULL;
1425 int error_level = av_log_get_level();
1427 av_log_set_level(AV_LOG_WARNING);
1429 if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1433 fmt = av_input_audio_device_next(fmt);
1435 if (!strcmp(fmt->name,
"lavfi"))
1437 if (dev && !av_match_name(dev, fmt->name))
1439 print_device_sources(fmt, opts);
1443 fmt = av_input_video_device_next(fmt);
1445 if (dev && !av_match_name(dev, fmt->name))
1447 print_device_sources(fmt, opts);
1451 av_dict_free(&opts);
1453 av_log_set_level(error_level);
1457int show_sinks(
void *optctx,
const char *opt,
const char *arg)
1459 const AVOutputFormat *fmt = NULL;
1461 AVDictionary *opts = NULL;
1463 int error_level = av_log_get_level();
1465 av_log_set_level(AV_LOG_WARNING);
1467 if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1471 fmt = av_output_audio_device_next(fmt);
1473 if (dev && !av_match_name(dev, fmt->name))
1475 print_device_sinks(fmt, opts);
1479 fmt = av_output_video_device_next(fmt);
1481 if (dev && !av_match_name(dev, fmt->name))
1483 print_device_sinks(fmt, opts);
1487 av_dict_free(&opts);
1489 av_log_set_level(error_level);