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"
23 #include "libavcodec/internal.h"
24 
25 static const char *get_type_string(enum AVMediaType type)
26 {
27  const char *ret = av_get_media_type_string(type);
28  return ret ? ret : "unknown";
29 }
30 
31 #define AV_LOG(...) av_log(NULL, AV_LOG_FATAL, __VA_ARGS__)
32 #define ERR_INTERNAL(msg, ...) \
33 do { \
34  AV_LOG(msg, codec->name __VA_ARGS__); \
35  ret = 1; \
36 } while (0)
37 #define ERR(msg) ERR_INTERNAL(msg, )
38 #define ERR_EXT(msg, ...) ERR_INTERNAL(msg, , __VA_ARGS__)
39 
40 static int priv_data_size_wrong(const FFCodec *codec)
41 {
42  if (codec->priv_data_size < 0 ||
43  codec->p.priv_class && codec->priv_data_size < sizeof(AVClass*))
44  return 1;
45  if (!codec->p.priv_class || !codec->p.priv_class->option)
46  return 0;
47  for (const AVOption *opt = codec->p.priv_class->option; opt->name; opt++) {
48  if (opt->offset >= codec->priv_data_size ||
49  opt->type == AV_OPT_TYPE_CONST && opt->offset != 0 ||
50  opt->type != AV_OPT_TYPE_CONST && (opt->offset < sizeof(AVClass*) || opt->offset < 0)) {
51  AV_LOG("Option %s offset %d nonsensical\n",
52  opt->name, opt->offset);
53  return 1;
54  }
55  }
56  return 0;
57 }
58 
59 int main(void){
60  void *iter = NULL;
61  const AVCodec *codec = NULL;
62  int ret = 0;
63 
64  while (codec = av_codec_iterate(&iter)) {
65  const FFCodec *const codec2 = ffcodec(codec);
66  const AVCodecDescriptor *desc;
67  int is_decoder = 0, is_encoder = 0;
68 
69  if (!codec->name) {
70  AV_LOG("Codec for format %s has no name\n",
71  avcodec_get_name(codec->id));
72  ret = 1;
73  continue;
74  }
75  if (codec->type != AVMEDIA_TYPE_VIDEO &&
76  codec->type != AVMEDIA_TYPE_AUDIO &&
77  codec->type != AVMEDIA_TYPE_SUBTITLE)
78  ERR_EXT("Codec %s has unsupported type %s\n",
79  get_type_string(codec->type));
80  if (codec->type != AVMEDIA_TYPE_AUDIO) {
81  if (codec->ch_layouts || codec->sample_fmts ||
82  codec->supported_samplerates)
83  ERR("Non-audio codec %s has audio-only fields set\n");
87  ERR("Non-audio codec %s has audio-only capabilities set\n");
88  }
89  if (codec->type != AVMEDIA_TYPE_VIDEO) {
90  if (codec->pix_fmts || codec->supported_framerates)
91  ERR("Non-video codec %s has video-only fields set\n");
93  ERR("Non-video codec %s exports cropping\n");
94  }
97  ERR("Codec %s wants mainfunction despite not being "
98  "slice-threading capable");
103  ERR("Codec %s has private-only threading support\n");
104 
105  switch (codec2->cb_type) {
109  is_decoder = 1;
110  break;
114  is_encoder = 1;
115  break;
116  default:
117  ERR("Codec %s has unknown cb_type\n");
118  continue;
119  }
120  if (is_decoder != av_codec_is_decoder(codec) ||
121  is_encoder != av_codec_is_encoder(codec)) {
122  ERR("Codec %s cb_type and av_codec_is_(de|en)coder inconsistent.\n");
123  continue;
124  }
125 #define CHECK(TYPE, type) (codec2->cb_type == FF_CODEC_CB_TYPE_ ## TYPE && !codec2->cb.type)
126  if (CHECK(DECODE, decode) || CHECK(DECODE_SUB, decode_sub) ||
127  CHECK(RECEIVE_PACKET, receive_packet) ||
128  CHECK(ENCODE, encode) || CHECK(ENCODE_SUB, encode_sub) ||
129  CHECK(RECEIVE_FRAME, receive_frame)) {
130  ERR_EXT("Codec %s does not implement its %s callback.\n",
131  is_decoder ? "decoding" : "encoding");
132  }
133 #undef CHECK
134  if (is_encoder) {
135  if ((codec->type == AVMEDIA_TYPE_SUBTITLE) != (codec2->cb_type == FF_CODEC_CB_TYPE_ENCODE_SUB))
136  ERR("Encoder %s is both subtitle encoder and not subtitle encoder.");
137  if (codec2->update_thread_context || codec2->update_thread_context_for_user || codec2->bsfs)
138  ERR("Encoder %s has decoder-only thread functions or bsf.\n");
139  if (codec->type == AVMEDIA_TYPE_AUDIO) {
140  if (!codec->sample_fmts) {
141  av_log(NULL, AV_LOG_FATAL, "Encoder %s is missing the sample_fmts field\n", codec->name);
142  ret = 1;
143  }
144  }
154  ERR("Encoder %s has decoder-only capabilities set\n");
157  ERR("Frame-threaded encoder %s claims to support flushing\n");
158  } else {
159  if ((codec->type == AVMEDIA_TYPE_SUBTITLE) != (codec2->cb_type == FF_CODEC_CB_TYPE_DECODE_SUB))
160  ERR("Subtitle decoder %s does not implement decode_sub callback\n");
161  if (codec->type == AVMEDIA_TYPE_SUBTITLE && codec2->bsfs)
162  ERR("Automatic bitstream filtering unsupported for subtitles; "
163  "yet decoder %s has it set\n");
168  ERR("Decoder %s has encoder-only capabilities\n");
171  ERR("Decoder %s wants allocated progress without supporting"
172  "frame threads\n");
173  }
174  if (priv_data_size_wrong(codec2))
175  ERR_EXT("Private context of codec %s is impossibly-sized (size %d).",
176  codec2->priv_data_size);
177  if (!(desc = avcodec_descriptor_get(codec->id))) {
178  ERR("Codec %s lacks a corresponding descriptor\n");
179  } else if (desc->type != codec->type)
180  ERR_EXT("The type of AVCodec %s and its AVCodecDescriptor differ: "
181  "%s vs %s\n",
182  get_type_string(codec->type), get_type_string(desc->type));
183  }
184  return ret;
185 }
AVCodec::ch_layouts
const AVChannelLayout * ch_layouts
Array of supported channel layouts, terminated with a zeroed layout.
Definition: codec.h:254
ERR
#define ERR(msg)
Definition: avcodec.c:37
FFCodec::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_internal.h:148
AVCodec
AVCodec.
Definition: codec.h:204
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
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: codec_internal.h:63
opt.h
ENCODE
#define ENCODE(type, endian, src, dst, n, shift, offset)
Write PCM samples macro.
Definition: pcm.c:78
FF_CODEC_CB_TYPE_RECEIVE_PACKET
@ FF_CODEC_CB_TYPE_RECEIVE_PACKET
Definition: codec_internal.h:115
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:236
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:226
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:223
internal.h
AVOption
AVOption.
Definition: opt.h:251
FFCodec
Definition: codec_internal.h:118
FF_CODEC_CB_TYPE_ENCODE_SUB
@ FF_CODEC_CB_TYPE_ENCODE_SUB
Definition: codec_internal.h:112
FFCodec::priv_data_size
int priv_data_size
Definition: codec_internal.h:136
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodec::sample_fmts
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:228
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_CB_TYPE_DECODE
@ FF_CODEC_CB_TYPE_DECODE
Definition: codec_internal.h:100
AVCodec::supported_samplerates
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0
Definition: codec.h:227
FFCodec::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_internal.h:153
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodec::supported_framerates
const AVRational * supported_framerates
array of supported framerates, or NULL if any, array is terminated by {0,0}
Definition: codec.h:225
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
priv_data_size_wrong
static int priv_data_size_wrong(const FFCodec *codec)
Definition: avcodec.c:40
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
FF_CODEC_CB_TYPE_ENCODE
@ FF_CODEC_CB_TYPE_ENCODE
Definition: codec_internal.h:109
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
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:217
get_type_string
static const char * get_type_string(enum AVMediaType type)
Definition: avcodec.c:25
receive_frame
static CopyRet receive_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
Definition: crystalhd.c:562
FF_CODEC_CB_TYPE_DECODE_SUB
@ FF_CODEC_CB_TYPE_DECODE_SUB
Definition: codec_internal.h:103
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
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:82
main
int main(void)
Definition: avcodec.c:59
AVMediaType
AVMediaType
Definition: avutil.h:199
codec_internal.h
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: codec_internal.h:77
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: codec_internal.h:59
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: codec_internal.h:68
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: codec_internal.h:53
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:279
DECODE
#define DECODE(size, endian, src, dst, n, shift, offset)
Read PCM samples macro.
Definition: pcm.c:310
AVOption::name
const char * name
Definition: opt.h:252
ERR_EXT
#define ERR_EXT(msg,...)
Definition: avcodec.c:38
AV_LOG
#define AV_LOG(...)
Definition: avcodec.c:31
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:94
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
AVCodec::id
enum AVCodecID id
Definition: codec.h:218
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:74
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:447
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:127
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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: codec_internal.h:48
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:890
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
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:28
AVClass::option
const struct AVOption * option
a pointer to the first option specified in the class if any or NULL
Definition: log.h:84
FF_CODEC_CB_TYPE_RECEIVE_FRAME
@ FF_CODEC_CB_TYPE_RECEIVE_FRAME
Definition: codec_internal.h:106
FFCodec::cb_type
unsigned cb_type
This field determines the type of the codec (decoder/encoder) and also the exact callback cb implemen...
Definition: codec_internal.h:134
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:243
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:72
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
CHECK
#define CHECK(TYPE, type)
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:3573
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:234