FFmpeg
avcodec.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/opt.h"
20 #include "libavcodec/codec.h"
21 #include "libavcodec/codec_desc.h"
22 #include "libavcodec/internal.h"
23 
24 static const char *get_type_string(enum AVMediaType type)
25 {
26  const char *ret = av_get_media_type_string(type);
27  return ret ? ret : "unknown";
28 }
29 
30 #define AV_LOG(...) av_log(NULL, AV_LOG_FATAL, __VA_ARGS__)
31 #define ERR_INTERNAL(msg, ...) \
32 do { \
33  AV_LOG(msg, codec->name __VA_ARGS__); \
34  ret = 1; \
35 } while (0)
36 #define ERR(msg) ERR_INTERNAL(msg, )
37 #define ERR_EXT(msg, ...) ERR_INTERNAL(msg, , __VA_ARGS__)
38 
39 static int priv_data_size_wrong(const AVCodec *codec)
40 {
41  if (codec->priv_data_size < 0 ||
42  codec->priv_class && codec->priv_data_size < sizeof(AVClass*))
43  return 1;
44  if (!codec->priv_class || !codec->priv_class->option)
45  return 0;
46  for (const AVOption *opt = codec->priv_class->option; opt->name; opt++) {
47  if (opt->offset >= codec->priv_data_size ||
48  opt->type == AV_OPT_TYPE_CONST && opt->offset != 0 ||
49  opt->type != AV_OPT_TYPE_CONST && (opt->offset < sizeof(AVClass*) || opt->offset < 0)) {
50  AV_LOG("Option %s offset %d nonsensical\n",
51  opt->name, opt->offset);
52  return 1;
53  }
54  }
55  return 0;
56 }
57 
58 int main(void){
59  void *iter = NULL;
60  const AVCodec *codec = NULL;
61  int ret = 0;
62 
63  while (codec = av_codec_iterate(&iter)) {
64  const AVCodecDescriptor *desc;
65  int is_decoder, is_encoder;
66 
67  if (!codec->name) {
68  AV_LOG("Codec for format %s has no name\n",
69  avcodec_get_name(codec->id));
70  ret = 1;
71  continue;
72  }
73  if (codec->type != AVMEDIA_TYPE_VIDEO &&
74  codec->type != AVMEDIA_TYPE_AUDIO &&
75  codec->type != AVMEDIA_TYPE_SUBTITLE)
76  ERR_EXT("Codec %s has unsupported type %s\n",
77  get_type_string(codec->type));
78  if (codec->type != AVMEDIA_TYPE_AUDIO) {
79  if (codec->channel_layouts || codec->sample_fmts ||
80  codec->supported_samplerates)
81  ERR("Non-audio codec %s has audio-only fields set\n");
85  ERR("Non-audio codec %s has audio-only capabilities set\n");
86  }
87  if (codec->type != AVMEDIA_TYPE_VIDEO) {
88  if (codec->pix_fmts || codec->supported_framerates)
89  ERR("Non-video codec %s has video-only fields set\n");
91  ERR("Non-video codec %s exports cropping\n");
92  }
95  ERR("Codec %s wants mainfunction despite not being "
96  "slice-threading capable");
101  ERR("Codec %s has private-only threading support\n");
102 
103  is_decoder = av_codec_is_decoder(codec);
104  is_encoder = av_codec_is_encoder(codec);
105  if (!!is_decoder + !!is_encoder != 1) {
106  ERR("Codec %s is decoder and encoder or neither.\n");
107  continue;
108  }
109  if (is_encoder) {
110  if (codec->type == AVMEDIA_TYPE_SUBTITLE ^ !!codec->encode_sub)
111  ERR("Encoder %s is both subtitle encoder and not subtitle encoder.");
112  if (!!codec->encode_sub + !!codec->encode2 + !!codec->receive_packet != 1)
113  ERR("Encoder %s does not implement exactly one encode API.\n");
114  if (codec->update_thread_context || codec->update_thread_context_for_user || codec->bsfs)
115  ERR("Encoder %s has decoder-only thread functions or bsf.\n");
116  if (codec->type == AVMEDIA_TYPE_AUDIO) {
117  if (!codec->sample_fmts) {
118  av_log(NULL, AV_LOG_FATAL, "Encoder %s is missing the sample_fmts field\n", codec->name);
119  ret = 1;
120  }
121  }
131  ERR("Encoder %s has decoder-only capabilities set\n");
134  ERR("Frame-threaded encoder %s claims to support flushing\n");
135  } else {
136  if (codec->type == AVMEDIA_TYPE_SUBTITLE && !codec->decode)
137  ERR("Subtitle decoder %s does not implement decode callback\n");
138  if (codec->type == AVMEDIA_TYPE_SUBTITLE && codec->bsfs)
139  ERR("Automatic bitstream filtering unsupported for subtitles; "
140  "yet decoder %s has it set\n");
141  if (!!codec->decode + !!codec->receive_frame != 1)
142  ERR("Decoder %s does not implement exactly one decode API.\n");
147  ERR("Decoder %s has encoder-only capabilities\n");
150  ERR("Decoder %s wants allocated progress without supporting"
151  "frame threads\n");
152  }
153  if (priv_data_size_wrong(codec))
154  ERR_EXT("Private context of codec %s is impossibly-sized (size %d).",
155  codec->priv_data_size);
156  if (!(desc = avcodec_descriptor_get(codec->id))) {
157  ERR("Codec %s lacks a corresponding descriptor\n");
158  } else if (desc->type != codec->type)
159  ERR_EXT("The type of AVCodec %s and its AVCodecDescriptor differ: "
160  "%s vs %s\n",
161  get_type_string(codec->type), get_type_string(desc->type));
162  }
163  return ret;
164 }
ERR
#define ERR(msg)
Definition: avcodec.c:36
AVCodec
AVCodec.
Definition: codec.h:202
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
FF_CODEC_CAP_SETS_PKT_DTS
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: internal.h:57
opt.h
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:228
AVCodec::update_thread_context
int(* update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy necessary context variables from a previous thread context to the current one.
Definition: codec.h:268
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:224
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:221
internal.h
AVOption
AVOption.
Definition: opt.h:247
AVCodec::sample_fmts
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:226
AVCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec.h:342
AVCodec::encode_sub
int(* encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: codec.h:290
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:183
codec.h
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: internal.h:62
AVCodec::supported_samplerates
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0
Definition: codec.h:225
AVCodec::supported_framerates
const AVRational * supported_framerates
array of supported framerates, or NULL if any, array is terminated by {0,0}
Definition: codec.h:223
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:127
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
Definition: codec.h:176
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
priv_data_size_wrong
static int priv_data_size_wrong(const AVCodec *codec)
Definition: avcodec.c:39
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodec::type
enum AVMediaType type
Definition: codec.h:215
get_type_string
static const char * get_type_string(enum AVMediaType type)
Definition: avcodec.c:24
AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: codec.h:134
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: internal.h:68
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:81
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:81
main
int main(void)
Definition: avcodec.c:58
AVMediaType
AVMediaType
Definition: avutil.h:199
AVCodec::update_thread_context_for_user
int(* update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy variables back to the user-facing context.
Definition: codec.h:273
AVCodec::encode2
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:302
AVCodec::receive_packet
int(* receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt)
Encode API with decoupled frame/packet dataflow.
Definition: codec.h:324
AVOption::name
const char * name
Definition: opt.h:248
FF_CODEC_CAP_SETS_FRAME_PROPS
#define FF_CODEC_CAP_SETS_FRAME_PROPS
Codec handles output frame properties internally instead of letting the internal logic derive them fr...
Definition: internal.h:86
ERR_EXT
#define ERR_EXT(msg,...)
Definition: avcodec.c:37
AV_LOG
#define AV_LOG(...)
Definition: avcodec.c:30
AVCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:331
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
FF_CODEC_CAP_SLICE_THREAD_HAS_MF
#define FF_CODEC_CAP_SLICE_THREAD_HAS_MF
Codec initializes slice-based threading with a main function.
Definition: internal.h:72
AVCodec::id
enum AVCodecID id
Definition: codec.h:216
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:76
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:454
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodec::priv_data_size
int priv_data_size
Definition: codec.h:256
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:872
ret
ret
Definition: filter_design.txt:187
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
AVCodec::caps_internal
int caps_internal
Internal codec capabilities.
Definition: codec.h:254
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:71
AVClass::option
const struct AVOption * option
a pointer to the first option specified in the class if any or NULL
Definition: log.h:84
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:100
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:77
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
AVCodec::decode
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:316
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:144
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3521
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:87
codec_desc.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
AVCodec::channel_layouts
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: codec.h:227