53#include "libavutil/avassert.h"
54#include "libavutil/avstring.h"
55#include "libavutil/bprint.h"
56#include "libavutil/channel_layout.h"
57#include "libavutil/cpu.h"
58#include "libavutil/dict.h"
59#include "libavutil/error.h"
60#include "libavutil/ffversion.h"
61#include "libavutil/log.h"
62#include "libavutil/mem.h"
63#include "libavutil/parseutils.h"
64#include "libavutil/pixdesc.h"
65#include "libavutil/version.h"
67#include "libavcodec/avcodec.h"
68#include "libavcodec/bsf.h"
69#include "libavcodec/codec.h"
70#include "libavcodec/codec_desc.h"
71#include "libavcodec/version.h"
73#include "libavformat/avformat.h"
74#include "libavformat/version.h"
76#include "libavdevice/avdevice.h"
77#include "libavdevice/version.h"
79#include "libavfilter/avfilter.h"
80#include "libavfilter/version.h"
82#include "libswscale/swscale.h"
83#include "libswscale/version.h"
85#include "libswresample/swresample.h"
86#include "libswresample/version.h"
104 av_log(NULL, AV_LOG_ERROR,
105 "This version of %s has nonfree parts compiled in.\n"
106 "Therefore it is not legally redistributable.\n",
109 av_log(NULL, AV_LOG_ERROR,
110 "%s is free software; you can redistribute it and/or modify\n"
111 "it under the terms of the GNU General Public License as published by\n"
112 "the Free Software Foundation; either version 3 of the License, or\n"
113 "(at your option) any later version.\n"
115 "%s is distributed in the hope that it will be useful,\n"
116 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
117 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
118 "GNU General Public License for more details.\n"
120 "You should have received a copy of the GNU General Public License\n"
121 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
124 av_log(NULL, AV_LOG_ERROR,
125 "%s is free software; you can redistribute it and/or modify\n"
126 "it under the terms of the GNU General Public License as published by\n"
127 "the Free Software Foundation; either version 2 of the License, or\n"
128 "(at your option) any later version.\n"
130 "%s is distributed in the hope that it will be useful,\n"
131 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
132 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
133 "GNU General Public License for more details.\n"
135 "You should have received a copy of the GNU General Public License\n"
136 "along with %s; if not, write to the Free Software\n"
137 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
140 av_log(NULL, AV_LOG_ERROR,
141 "%s is free software; you can redistribute it and/or modify\n"
142 "it under the terms of the GNU Lesser General Public License as published by\n"
143 "the Free Software Foundation; either version 3 of the License, or\n"
144 "(at your option) any later version.\n"
146 "%s is distributed in the hope that it will be useful,\n"
147 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
148 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
149 "GNU Lesser General Public License for more details.\n"
151 "You should have received a copy of the GNU Lesser General Public License\n"
152 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
155 av_log(NULL, AV_LOG_ERROR,
156 "%s is free software; you can redistribute it and/or\n"
157 "modify it under the terms of the GNU Lesser General Public\n"
158 "License as published by the Free Software Foundation; either\n"
159 "version 2.1 of the License, or (at your option) any later version.\n"
161 "%s is distributed in the hope that it will be useful,\n"
162 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
163 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
164 "Lesser General Public License for more details.\n"
166 "You should have received a copy of the GNU Lesser General Public\n"
167 "License along with %s; if not, write to the Free Software\n"
168 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
178#define SHOW_VERSION 2
180#define SHOW_COPYRIGHT 8
182#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
183 if (CONFIG_##LIBNAME) { \
184 const char *indent = flags & INDENT? " " : ""; \
185 if (flags & SHOW_VERSION) { \
186 unsigned int version = libname##_version(); \
187 av_log(NULL, level, \
188 "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
190 LIB##LIBNAME##_VERSION_MAJOR, \
191 LIB##LIBNAME##_VERSION_MINOR, \
192 LIB##LIBNAME##_VERSION_MICRO, \
193 AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
194 AV_VERSION_MICRO(version)); \
196 if (flags & SHOW_CONFIG) { \
197 const char *cfg = libname##_configuration(); \
198 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
200 av_log(NULL, level, \
201 "%sWARNING: library configuration mismatch\n", \
205 av_log(NULL, level, "%s%-11s configuration: %s\n", \
206 indent, #libname, cfg); \
224 const char *indent = flags &
INDENT?
" " :
"";
226 av_log(NULL, level,
"%s version " FFMPEG_VERSION,
program_name);
228 av_log(NULL, level,
" Copyright (c) %d-%d the FFmpeg developers",
230 av_log(NULL, level,
"\n");
231 av_log(NULL, level,
"%sbuilt with %s\n", indent, CC_IDENT);
233 av_log(NULL, level,
"%sconfiguration: " FFMPEG_CONFIGURATION
"\n", indent);
238 const char *indent = flags &
INDENT ?
" " :
"";
239 char str[] = { FFMPEG_CONFIGURATION };
240 char *conflist, *remove_tilde, *splitconf;
244 while ((conflist = strstr(str,
" --")) != NULL) {
250 while ((remove_tilde = strstr(str,
"pkg-config~")) != NULL) {
251 remove_tilde[
sizeof(
"pkg-config~") - 2] =
' ';
254 splitconf = strtok(str,
"~");
255 av_log(NULL, level,
"\n%sconfiguration:\n", indent);
256 while (splitconf != NULL) {
257 av_log(NULL, level,
"%s%s%s\n", indent, indent, splitconf);
258 splitconf = strtok(NULL,
"~");
288#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
289 if (codec->field) { \
290 const type *p = codec->field; \
292 av_log(NULL, AV_LOG_ERROR, " Supported " list_name ":"); \
293 while (*p != term) { \
295 av_log(NULL, AV_LOG_ERROR, " %s", name); \
298 av_log(NULL, AV_LOG_ERROR, "\n"); \
303 int encoder = av_codec_is_encoder(c);
305 av_log(NULL, AV_LOG_ERROR,
"%s %s [%s]:\n", encoder ?
"Encoder" :
"Decoder", c->name,
306 c->long_name ? c->long_name :
"");
308 av_log(NULL, AV_LOG_ERROR,
" General capabilities: ");
309 if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
310 av_log(NULL, AV_LOG_ERROR,
"horizband ");
311 if (c->capabilities & AV_CODEC_CAP_DR1)
312 av_log(NULL, AV_LOG_ERROR,
"dr1 ");
313 if (c->capabilities & AV_CODEC_CAP_DELAY)
314 av_log(NULL, AV_LOG_ERROR,
"delay ");
315 if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
316 av_log(NULL, AV_LOG_ERROR,
"small ");
317 if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
318 av_log(NULL, AV_LOG_ERROR,
"subframes ");
319 if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
320 av_log(NULL, AV_LOG_ERROR,
"exp ");
321 if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
322 av_log(NULL, AV_LOG_ERROR,
"chconf ");
323 if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
324 av_log(NULL, AV_LOG_ERROR,
"paramchange ");
325 if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
326 av_log(NULL, AV_LOG_ERROR,
"variable ");
327 if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
328 AV_CODEC_CAP_SLICE_THREADS |
329 AV_CODEC_CAP_OTHER_THREADS))
330 av_log(NULL, AV_LOG_ERROR,
"threads ");
331 if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
332 av_log(NULL, AV_LOG_ERROR,
"avoidprobe ");
333 if (c->capabilities & AV_CODEC_CAP_HARDWARE)
334 av_log(NULL, AV_LOG_ERROR,
"hardware ");
335 if (c->capabilities & AV_CODEC_CAP_HYBRID)
336 av_log(NULL, AV_LOG_ERROR,
"hybrid ");
337 if (!c->capabilities)
338 av_log(NULL, AV_LOG_ERROR,
"none");
339 av_log(NULL, AV_LOG_ERROR,
"\n");
341 if (c->type == AVMEDIA_TYPE_VIDEO ||
342 c->type == AVMEDIA_TYPE_AUDIO) {
343 av_log(NULL, AV_LOG_ERROR,
" Threading capabilities: ");
344 switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
345 AV_CODEC_CAP_SLICE_THREADS |
346 AV_CODEC_CAP_OTHER_THREADS)) {
347 case AV_CODEC_CAP_FRAME_THREADS |
348 AV_CODEC_CAP_SLICE_THREADS: av_log(NULL, AV_LOG_ERROR,
"frame and slice");
break;
349 case AV_CODEC_CAP_FRAME_THREADS: av_log(NULL, AV_LOG_ERROR,
"frame");
break;
350 case AV_CODEC_CAP_SLICE_THREADS: av_log(NULL, AV_LOG_ERROR,
"slice");
break;
351 case AV_CODEC_CAP_OTHER_THREADS: av_log(NULL, AV_LOG_ERROR,
"other");
break;
352 default: av_log(NULL, AV_LOG_ERROR,
"none");
break;
354 av_log(NULL, AV_LOG_ERROR,
"\n");
357 if (avcodec_get_hw_config(c, 0)) {
358 av_log(NULL, AV_LOG_ERROR,
" Supported hardware devices: ");
359 for (
int i = 0;; i++) {
360 const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
363 av_log(NULL, AV_LOG_ERROR,
"%s ", av_hwdevice_get_type_name(config->device_type));
365 av_log(NULL, AV_LOG_ERROR,
"\n");
368 if (c->supported_framerates) {
369 const AVRational *fps = c->supported_framerates;
371 av_log(NULL, AV_LOG_ERROR,
" Supported framerates:");
373 av_log(NULL, AV_LOG_ERROR,
" %d/%d", fps->num, fps->den);
376 av_log(NULL, AV_LOG_ERROR,
"\n");
386 const AVChannelLayout *p = c->ch_layouts;
388 av_log(NULL, AV_LOG_ERROR,
" Supported channel layouts:");
389 while (p->nb_channels) {
391 av_channel_layout_describe(p, name,
sizeof(name));
392 av_log(NULL, AV_LOG_ERROR,
" %s", name);
395 av_log(NULL, AV_LOG_ERROR,
"\n");
400 AV_OPT_FLAG_ENCODING_PARAM |
401 AV_OPT_FLAG_DECODING_PARAM);
409 while ((c = av_codec_iterate(iter))) {
411 (encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
419 const AVCodecDescriptor *desc;
420 const AVCodec *codec;
423 av_log(NULL, AV_LOG_ERROR,
"No codec name specified.\n");
427 codec = encoder ? avcodec_find_encoder_by_name(name) :
428 avcodec_find_decoder_by_name(name);
432 else if ((desc = avcodec_descriptor_get_by_name(name))) {
442 av_log(NULL, AV_LOG_ERROR,
"Codec '%s' is known to FFmpeg, "
443 "but no %s for it are available. FFmpeg might need to be "
444 "recompiled with additional external libraries.\n",
445 name, encoder ?
"encoders" :
"decoders");
448 av_log(NULL, AV_LOG_ERROR,
"Codec '%s' is not recognized by FFmpeg.\n",
455 const AVInputFormat *fmt = av_find_input_format(name);
458 av_log(NULL, AV_LOG_ERROR,
"Unknown format '%s'.\n", name);
462 av_log(NULL, AV_LOG_ERROR,
"Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
465 av_log(NULL, AV_LOG_ERROR,
" Common extensions: %s.\n", fmt->extensions);
473 const AVClass *proto_class;
476 av_log(NULL, AV_LOG_ERROR,
"No protocol name specified.\n");
480 proto_class = avio_protocol_get_class(name);
482 av_log(NULL, AV_LOG_ERROR,
"Unknown protocol '%s'.\n", name);
486 show_help_children(proto_class, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
491 const AVCodecDescriptor *desc;
492 const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
495 av_log(NULL, AV_LOG_ERROR,
"Unknown format '%s'.\n", name);
499 av_log(NULL, AV_LOG_ERROR,
"Muxer %s [%s]:\n", fmt->name, fmt->long_name);
502 av_log(NULL, AV_LOG_ERROR,
" Common extensions: %s.\n", fmt->extensions);
504 av_log(NULL, AV_LOG_ERROR,
" Mime type: %s.\n", fmt->mime_type);
505 if (fmt->video_codec != AV_CODEC_ID_NONE &&
506 (desc = avcodec_descriptor_get(fmt->video_codec))) {
507 av_log(NULL, AV_LOG_ERROR,
" Default video codec: %s.\n", desc->name);
509 if (fmt->audio_codec != AV_CODEC_ID_NONE &&
510 (desc = avcodec_descriptor_get(fmt->audio_codec))) {
511 av_log(NULL, AV_LOG_ERROR,
" Default audio codec: %s.\n", desc->name);
513 if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
514 (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
515 av_log(NULL, AV_LOG_ERROR,
" Default subtitle codec: %s.\n", desc->name);
523static void show_help_filter(
const char *name)
526 const AVFilter *f = avfilter_get_by_name(name);
530 av_log(NULL, AV_LOG_ERROR,
"No filter name specified.\n");
533 av_log(NULL, AV_LOG_ERROR,
"Unknown filter '%s'.\n", name);
537 av_log(NULL, AV_LOG_ERROR,
"Filter %s\n", f->name);
539 av_log(NULL, AV_LOG_ERROR,
" %s\n", f->description);
541 if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
542 av_log(NULL, AV_LOG_ERROR,
" slice threading supported\n");
544 av_log(NULL, AV_LOG_ERROR,
" Inputs:\n");
545 count = avfilter_filter_pad_count(f, 0);
546 for (i = 0; i < count; i++) {
547 av_log(NULL, AV_LOG_ERROR,
" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
548 av_get_media_type_string(avfilter_pad_get_type(f->inputs, i)));
550 if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
551 av_log(NULL, AV_LOG_ERROR,
" dynamic (depending on the options)\n");
553 av_log(NULL, AV_LOG_ERROR,
" none (source filter)\n");
555 av_log(NULL, AV_LOG_ERROR,
" Outputs:\n");
556 count = avfilter_filter_pad_count(f, 1);
557 for (i = 0; i < count; i++) {
558 av_log(NULL, AV_LOG_ERROR,
" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
559 av_get_media_type_string(avfilter_pad_get_type(f->outputs, i)));
561 if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
562 av_log(NULL, AV_LOG_ERROR,
" dynamic (depending on the options)\n");
564 av_log(NULL, AV_LOG_ERROR,
" none (sink filter)\n");
567 show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
568 AV_OPT_FLAG_AUDIO_PARAM);
569 if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
570 av_log(NULL, AV_LOG_ERROR,
"This filter has support for timeline through the 'enable' option.\n");
572 av_log(NULL, AV_LOG_ERROR,
"Build without libavfilter; "
573 "can not to satisfy request\n");
580 const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
583 av_log(NULL, AV_LOG_ERROR,
"No bitstream filter name specified.\n");
586 av_log(NULL, AV_LOG_ERROR,
"Unknown bit stream filter '%s'.\n", name);
590 av_log(NULL, AV_LOG_ERROR,
"Bit stream filter %s\n", bsf->name);
597int show_help(
void *optctx,
const char *opt,
const char *arg)
601 topic = av_strdup(arg ? arg :
"");
603 return AVERROR(ENOMEM);
604 par = strchr(topic,
'=');
614 }
else if (!strcmp(topic,
"decoder")) {
616 }
else if (!strcmp(topic,
"encoder")) {
618 }
else if (!strcmp(topic,
"demuxer")) {
620 }
else if (!strcmp(topic,
"muxer")) {
622 }
else if (!strcmp(topic,
"protocol")) {
625 }
else if (!strcmp(topic,
"filter")) {
626 show_help_filter(par);
628 }
else if (!strcmp(topic,
"bsf")) {
645 const AVCodec *codec;
647 av_log(NULL, AV_LOG_ERROR,
" (%s: ", encoder ?
"encoders" :
"decoders");
650 av_log(NULL, AV_LOG_ERROR,
"%s ", codec->name);
652 av_log(NULL, AV_LOG_ERROR,
")");
657 const AVCodecDescriptor *
const *da = a;
658 const AVCodecDescriptor *
const *db = b;
660 return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
661 strcmp((*da)->name, (*db)->name);
666 const AVCodecDescriptor *desc = NULL;
667 const AVCodecDescriptor **codecs;
668 unsigned nb_codecs = 0, i = 0;
670 while ((desc = avcodec_descriptor_next(desc)))
672 if (!(codecs = av_calloc(nb_codecs,
sizeof(*codecs)))) {
673 av_log(NULL, AV_LOG_ERROR,
"Out of memory\n");
677 while ((desc = avcodec_descriptor_next(desc)))
679 av_assert0(i == nb_codecs);
688 case AVMEDIA_TYPE_VIDEO:
return 'V';
689 case AVMEDIA_TYPE_AUDIO:
return 'A';
690 case AVMEDIA_TYPE_DATA:
return 'D';
691 case AVMEDIA_TYPE_SUBTITLE:
return 'S';
692 case AVMEDIA_TYPE_ATTACHMENT:
return 'T';
699 const AVCodecDescriptor **codecs;
702 av_log(NULL, AV_LOG_ERROR,
"Codecs:\n"
703 " D..... = Decoding supported\n"
704 " .E.... = Encoding supported\n"
705 " ..V... = Video codec\n"
706 " ..A... = Audio codec\n"
707 " ..S... = Subtitle codec\n"
708 " ..D... = Data codec\n"
709 " ..T... = Attachment codec\n"
710 " ...I.. = Intra frame-only codec\n"
711 " ....L. = Lossy compression\n"
712 " .....S = Lossless compression\n"
714 for (i = 0; i < nb_codecs; i++) {
715 const AVCodecDescriptor *desc = codecs[i];
716 const AVCodec *codec;
719 if (strstr(desc->name,
"_deprecated"))
722 av_log(NULL, AV_LOG_ERROR,
" ");
723 av_log(NULL, AV_LOG_ERROR, avcodec_find_decoder(desc->id) ?
"D" :
".");
724 av_log(NULL, AV_LOG_ERROR, avcodec_find_encoder(desc->id) ?
"E" :
".");
727 av_log(NULL, AV_LOG_ERROR, (desc->props & AV_CODEC_PROP_INTRA_ONLY) ?
"I" :
".");
728 av_log(NULL, AV_LOG_ERROR, (desc->props & AV_CODEC_PROP_LOSSY) ?
"L" :
".");
729 av_log(NULL, AV_LOG_ERROR, (desc->props & AV_CODEC_PROP_LOSSLESS) ?
"S" :
".");
731 av_log(NULL, AV_LOG_ERROR,
" %-20s %s", desc->name, desc->long_name ? desc->long_name :
"");
736 if (strcmp(codec->name, desc->name)) {
743 if (strcmp(codec->name, desc->name)) {
749 av_log(NULL, AV_LOG_ERROR,
"\n");
757 const AVCodecDescriptor **codecs;
760 av_log(NULL, AV_LOG_ERROR,
"%s:\n"
763 " S..... = Subtitle\n"
764 " .F.... = Frame-level multithreading\n"
765 " ..S... = Slice-level multithreading\n"
766 " ...X.. = Codec is experimental\n"
767 " ....B. = Supports draw_horiz_band\n"
768 " .....D = Supports direct rendering method 1\n"
770 encoder ?
"Encoders" :
"Decoders");
771 for (i = 0; i < nb_codecs; i++) {
772 const AVCodecDescriptor *desc = codecs[i];
773 const AVCodec *codec;
778 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ?
"F" :
".");
779 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ?
"S" :
".");
780 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ?
"X" :
".");
781 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?
"B" :
".");
782 av_log(NULL, AV_LOG_ERROR, (codec->capabilities & AV_CODEC_CAP_DR1) ?
"D" :
".");
784 av_log(NULL, AV_LOG_ERROR,
" %-20s %s", codec->name, codec->long_name ? codec->long_name :
"");
785 if (strcmp(codec->name, desc->name))
786 av_log(NULL, AV_LOG_ERROR,
" (codec %s)", desc->name);
788 av_log(NULL, AV_LOG_ERROR,
"\n");
806int show_bsfs(
void *optctx,
const char *opt,
const char *arg)
808 const AVBitStreamFilter *bsf = NULL;
811 av_log(NULL, AV_LOG_ERROR,
"Bitstream filters:\n");
812 while ((bsf = av_bsf_iterate(&opaque)))
813 av_log(NULL, AV_LOG_ERROR,
"%s\n", bsf->name);
814 av_log(NULL, AV_LOG_ERROR,
"\n");
821 const AVFilter *filter = NULL;
822 char descr[64], *descr_cur;
825 const AVFilterPad *pad;
827 av_log(NULL, AV_LOG_ERROR,
"Filters:\n"
828 " T.. = Timeline support\n"
829 " .S. = Slice threading\n"
830 " ..C = Command support\n"
831 " A = Audio input/output\n"
832 " V = Video input/output\n"
833 " N = Dynamic number and/or type of input/output\n"
834 " | = Source or sink filter\n");
835 while ((filter = av_filter_iterate(&opaque))) {
837 for (i = 0; i < 2; i++) {
840 *(descr_cur++) =
'-';
841 *(descr_cur++) =
'>';
843 pad = i ? filter->outputs : filter->inputs;
844 nb_pads = avfilter_filter_pad_count(filter, i);
845 for (j = 0; j < nb_pads; j++) {
846 if (descr_cur >= descr +
sizeof(descr) - 4)
851 *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
852 ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ?
'N' :
'|';
855 av_log(NULL, AV_LOG_ERROR,
" %c%c%c %-17s %-10s %s\n",
856 filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ?
'T' :
'.',
857 filter->flags & AVFILTER_FLAG_SLICE_THREADS ?
'S' :
'.',
858 filter->process_command ?
'C' :
'.',
859 filter->name, descr, filter->description);
862 av_log(NULL, AV_LOG_ERROR,
"No filters available: libavfilter disabled\n");
871 return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
874static int show_formats_devices(
void *optctx,
const char *opt,
const char *arg,
int device_only,
int muxdemuxers)
876 void *ifmt_opaque = NULL;
877 const AVInputFormat *ifmt = NULL;
878 void *ofmt_opaque = NULL;
879 const AVOutputFormat *ofmt = NULL;
880 const char *last_name;
883 av_log(NULL, AV_LOG_ERROR,
"%s\n"
884 " D. = Demuxing supported\n"
885 " .E = Muxing supported\n"
886 " --\n", device_only ?
"Devices:" :
"File formats:");
891 const char *name = NULL;
892 const char *long_name = NULL;
896 while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
898 if (!is_dev && device_only)
900 if ((!name || strcmp(ofmt->name, name) < 0) &&
901 strcmp(ofmt->name, last_name) > 0) {
903 long_name = ofmt->long_name;
910 while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
912 if (!is_dev && device_only)
914 if ((!name || strcmp(ifmt->name, name) < 0) &&
915 strcmp(ifmt->name, last_name) > 0) {
917 long_name = ifmt->long_name;
920 if (name && strcmp(ifmt->name, name) == 0)
928 av_log(NULL, AV_LOG_ERROR,
" %c%c %-15s %s\n",
932 long_name ? long_name:
" ");
962 av_log(NULL, AV_LOG_ERROR,
"Supported file protocols:\n"
964 while ((name = avio_enum_protocols(&opaque, 0)))
965 av_log(NULL, AV_LOG_ERROR,
" %s\n", name);
966 av_log(NULL, AV_LOG_ERROR,
"Output:\n");
967 while ((name = avio_enum_protocols(&opaque, 1)))
968 av_log(NULL, AV_LOG_ERROR,
" %s\n", name);
978 av_log(NULL, AV_LOG_ERROR,
"%-32s #RRGGBB\n",
"name");
980 for (i = 0; (name = av_get_known_color_name(i, &rgb)); i++)
981 av_log(NULL, AV_LOG_ERROR,
"%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
988 const AVPixFmtDescriptor *pix_desc = NULL;
990 av_log(NULL, AV_LOG_ERROR,
"Pixel formats:\n"
991 "I.... = Supported Input format for conversion\n"
992 ".O... = Supported Output format for conversion\n"
993 "..H.. = Hardware accelerated format\n"
994 "...P. = Paletted format\n"
995 "....B = Bitstream format\n"
996 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL BIT_DEPTHS\n"
1000# define sws_isSupportedInput(x) 0
1001# define sws_isSupportedOutput(x) 0
1004 while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1005 enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
1006 av_log(NULL, AV_LOG_ERROR,
"%c%c%c%c%c %-16s %d %3d %d",
1009 pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ?
'H' :
'.',
1010 pix_desc->flags & AV_PIX_FMT_FLAG_PAL ?
'P' :
'.',
1011 pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ?
'B' :
'.',
1013 pix_desc->nb_components,
1014 av_get_bits_per_pixel(pix_desc),
1015 pix_desc->comp[0].depth);
1017 for (
unsigned i = 1; i < pix_desc->nb_components; i++)
1018 av_log(NULL, AV_LOG_ERROR,
"-%d", pix_desc->comp[i].depth);
1019 av_log(NULL, AV_LOG_ERROR,
"\n");
1026 const AVChannelLayout *ch_layout;
1028 char buf[128], buf2[128];
1031 av_log(NULL, AV_LOG_ERROR,
"Individual channels:\n"
1032 "NAME DESCRIPTION\n");
1033 for (i = 0; i < 63; i++) {
1034 av_channel_name(buf,
sizeof(buf), i);
1035 if (strstr(buf,
"USR"))
1037 av_channel_description(buf2,
sizeof(buf2), i);
1038 av_log(NULL, AV_LOG_ERROR,
"%-14s %s\n", buf, buf2);
1040 av_log(NULL, AV_LOG_ERROR,
"\nStandard channel layouts:\n"
1041 "NAME DECOMPOSITION\n");
1042 while ((ch_layout = av_channel_layout_standard(&iter))) {
1043 av_channel_layout_describe(ch_layout, buf,
sizeof(buf));
1044 av_log(NULL, AV_LOG_ERROR,
"%-14s ", buf);
1045 for (i = 0; i < 63; i++) {
1046 int idx = av_channel_layout_index_from_channel(ch_layout, i);
1048 av_channel_name(buf2,
sizeof(buf2), i);
1049 av_log(NULL, AV_LOG_ERROR,
"%s%s", idx ?
"+" :
"", buf2);
1052 av_log(NULL, AV_LOG_ERROR,
"\n");
1061 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1062 av_log(NULL, AV_LOG_ERROR,
"%s\n", av_get_sample_fmt_string(fmt_str,
sizeof(fmt_str), i));
1068 for (
int i = 0; i < 32; i++) {
1069 const char *str = av_disposition_to_string(1U << i);
1071 av_log(NULL, AV_LOG_ERROR,
"%s\n", str);
1079 unsigned flags = av_get_cpu_flags();
1081 if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
1084 av_force_cpu_flags(flags);
1093 static const AVOption opts[] = {
1094 {
"count", NULL, 0, AV_OPT_TYPE_INT, { .i64 = -1}, -1, INT_MAX},
1097 static const AVClass
class = {
1098 .class_name =
"cpucount",
1099 .item_name = av_default_item_name,
1101 .version = LIBAVUTIL_VERSION_INT,
1103 const AVClass *pclass = &
class;
1105 ret = av_opt_eval_int(&pclass, opts, arg, &count);
1108 av_cpu_force_count(count);
1119 while ((c = *(
template++))) {
1121 if (!(c = *(
template++)))
1128 av_bprintf(bp,
"%04d%02d%02d-%02d%02d%02d",
1129 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1130 tm->tm_hour, tm->tm_min, tm->tm_sec);
1133 av_bprint_chars(bp, c, 1);
1137 av_bprint_chars(bp, c, 1);
1146 static int print_prefix = 1;
1150 av_log_default_callback(ptr, level, fmt, vl);
1154 av_log_format_line(ptr, level, fmt, vl2, line,
sizeof(line), &print_prefix);
1164 char *filename_template = NULL;
1167 int prog_loglevel, envlevel = 0;
1175 tm = localtime(&now);
1177 while (env && *env) {
1178 if ((ret = av_opt_get_key_value(&env,
"=",
":", 0, &key, &val)) < 0) {
1180 av_log(NULL, AV_LOG_ERROR,
1181 "Failed to parse FFREPORT environment variable: %s\n",
1188 if (!strcmp(key,
"file")) {
1189 av_free(filename_template);
1190 filename_template = val;
1192 }
else if (!strcmp(key,
"level")) {
1196 av_log(NULL, AV_LOG_FATAL,
"Invalid report file level\n");
1201 av_log(NULL, AV_LOG_ERROR,
"Unknown key '%s' in FFREPORT\n", key);
1207 av_bprint_init(&filename, 0, AV_BPRINT_SIZE_AUTOMATIC);
1209 av_x_if_null(filename_template,
"%p-%t.log"), tm);
1210 av_free(filename_template);
1211 if (!av_bprint_is_complete(&filename)) {
1212 av_log(NULL, AV_LOG_ERROR,
"Out of memory building report file name\n");
1213 return AVERROR(ENOMEM);
1216 prog_loglevel = av_log_get_level();
1222 int ret = AVERROR(errno);
1223 av_log(NULL, AV_LOG_ERROR,
"Failed to open report \"%s\": %s\n",
1224 filename.str, strerror(errno));
1228 av_log(NULL, AV_LOG_INFO,
1229 "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1230 "Report written to \"%s\"\n"
1233 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1234 tm->tm_hour, tm->tm_min, tm->tm_sec,
1236 av_bprint_finalize(&filename, NULL);
1254 max = strtol(arg, &tail, 10);
1256 av_log(NULL, AV_LOG_FATAL,
"Invalid max_alloc \"%s\".\n", arg);
1265 const struct {
const char *name;
int level; } log_levels[] = {
1266 {
"quiet" , AV_LOG_QUIET },
1267 {
"panic" , AV_LOG_PANIC },
1268 {
"fatal" , AV_LOG_FATAL },
1269 {
"error" , AV_LOG_ERROR },
1270 {
"warning", AV_LOG_WARNING },
1271 {
"info" , AV_LOG_INFO },
1272 {
"verbose", AV_LOG_VERBOSE },
1273 {
"debug" , AV_LOG_DEBUG },
1274 {
"trace" , AV_LOG_TRACE },
1278 int flags = av_log_get_flags();
1279 int level = av_log_get_level();
1285 if (*token ==
'+' || *token ==
'-') {
1293 if (av_strstart(token,
"repeat", &arg)) {
1295 flags |= AV_LOG_SKIP_REPEATED;
1297 flags &= ~AV_LOG_SKIP_REPEATED;
1299 }
else if (av_strstart(token,
"level", &arg)) {
1301 flags &= ~AV_LOG_PRINT_LEVEL;
1303 flags |= AV_LOG_PRINT_LEVEL;
1312 }
else if (*arg ==
'+') {
1315 flags = av_log_get_flags();
1318 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
1319 if (!strcmp(log_levels[i].name, arg)) {
1320 level = log_levels[i].level;
1325 level = strtol(arg, &tail, 10);
1327 av_log(NULL, AV_LOG_FATAL,
"Invalid loglevel \"%s\". "
1328 "Possible levels are numbers or:\n", arg);
1329 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
1330 av_log(NULL, AV_LOG_FATAL,
"\"%s\"\n", log_levels[i].name);
1335 av_log_set_flags(flags);
1336 av_log_set_level(level);
1341static void print_device_list(
const AVDeviceInfoList *device_list)
1344 for (
int i = 0; i < device_list->nb_devices; i++) {
1345 const AVDeviceInfo *device = device_list->devices[i];
1346 av_log(NULL, AV_LOG_ERROR,
"%c %s [%s] (", device_list->default_device == i ?
'*' :
' ',
1347 device->device_name, device->device_description);
1348 if (device->nb_media_types > 0) {
1349 for (
int j = 0; j < device->nb_media_types; ++j) {
1350 const char* media_type = av_get_media_type_string(device->media_types[j]);
1352 av_log(NULL, AV_LOG_ERROR,
", ");
1353 av_log(NULL, AV_LOG_ERROR,
"%s", media_type ? media_type :
"unknown");
1356 av_log(NULL, AV_LOG_ERROR,
"none");
1358 av_log(NULL, AV_LOG_ERROR,
")\n");
1362static int print_device_sources(
const AVInputFormat *fmt, AVDictionary *opts)
1365 AVDeviceInfoList *device_list = NULL;
1367 if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
1368 return AVERROR(EINVAL);
1370 av_log(NULL, AV_LOG_ERROR,
"Auto-detected sources for %s:\n", fmt->name);
1371 if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
1372 av_log(NULL, AV_LOG_ERROR,
"Cannot list sources: %s\n", av_err2str(ret));
1376 print_device_list(device_list);
1379 avdevice_free_list_devices(&device_list);
1383static int print_device_sinks(
const AVOutputFormat *fmt, AVDictionary *opts)
1386 AVDeviceInfoList *device_list = NULL;
1388 if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
1389 return AVERROR(EINVAL);
1391 av_log(NULL, AV_LOG_ERROR,
"Auto-detected sinks for %s:\n", fmt->name);
1392 if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
1393 av_log(NULL, AV_LOG_ERROR,
"Cannot list sinks: %s\n", av_err2str(ret));
1397 print_device_list(device_list);
1400 avdevice_free_list_devices(&device_list);
1404static int show_sinks_sources_parse_arg(
const char *arg,
char **dev, AVDictionary **opts)
1408 char *opts_str = NULL;
1409 av_assert0(dev && opts);
1410 *dev = av_strdup(arg);
1412 return AVERROR(ENOMEM);
1413 if ((opts_str = strchr(*dev,
','))) {
1414 *(opts_str++) =
'\0';
1415 if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str,
"=",
":", 0)) < 0)) {
1421 av_log(NULL, AV_LOG_ERROR,
"\nDevice name is not provided.\n"
1422 "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
1426int show_sources(
void *optctx,
const char *opt,
const char *arg)
1428 const AVInputFormat *fmt = NULL;
1430 AVDictionary *opts = NULL;
1432 int error_level = av_log_get_level();
1434 av_log_set_level(AV_LOG_WARNING);
1436 if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1440 fmt = av_input_audio_device_next(fmt);
1442 if (!strcmp(fmt->name,
"lavfi"))
1444 if (dev && !av_match_name(dev, fmt->name))
1446 print_device_sources(fmt, opts);
1450 fmt = av_input_video_device_next(fmt);
1452 if (dev && !av_match_name(dev, fmt->name))
1454 print_device_sources(fmt, opts);
1458 av_dict_free(&opts);
1460 av_log_set_level(error_level);
1464int show_sinks(
void *optctx,
const char *opt,
const char *arg)
1466 const AVOutputFormat *fmt = NULL;
1468 AVDictionary *opts = NULL;
1470 int error_level = av_log_get_level();
1472 av_log_set_level(AV_LOG_WARNING);
1474 if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1478 fmt = av_output_audio_device_next(fmt);
1480 if (dev && !av_match_name(dev, fmt->name))
1482 print_device_sinks(fmt, opts);
1486 fmt = av_output_video_device_next(fmt);
1488 if (dev && !av_match_name(dev, fmt->name))
1490 print_device_sinks(fmt, opts);
1494 av_dict_free(&opts);
1496 av_log_set_level(error_level);