FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/codec_internal.h
Date: 2025-09-17 22:08:16
Exec Total Coverage
Lines: 8 8 100.0%
Functions: 3 3 100.0%
Branches: 0 0 -%

Line Branch Exec Source
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 #ifndef AVCODEC_CODEC_INTERNAL_H
20 #define AVCODEC_CODEC_INTERNAL_H
21
22 #include <stdint.h>
23
24 #include "libavutil/attributes.h"
25 #include "codec.h"
26 #include "config.h"
27
28 /**
29 * The codec is not known to be init-threadsafe (i.e. it might be unsafe
30 * to initialize this codec and another codec concurrently, typically because
31 * the codec calls external APIs that are not known to be thread-safe).
32 * Therefore calling the codec's init function needs to be guarded with a lock.
33 */
34 #define FF_CODEC_CAP_NOT_INIT_THREADSAFE (1 << 0)
35 /**
36 * The codec allows calling the close function for deallocation even if
37 * the init function returned a failure. Without this capability flag, a
38 * codec does such cleanup internally when returning failures from the
39 * init function and does not expect the close function to be called at
40 * all.
41 */
42 #define FF_CODEC_CAP_INIT_CLEANUP (1 << 1)
43 /**
44 * Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set
45 * AVFrame.pkt_dts manually. If the flag is set, decode.c won't overwrite
46 * this field. If it's unset, decode.c tries to guess the pkt_dts field
47 * from the input AVPacket.
48 */
49 #define FF_CODEC_CAP_SETS_PKT_DTS (1 << 2)
50 /**
51 * The decoder extracts and fills its parameters even if the frame is
52 * skipped due to the skip_frame setting.
53 */
54 #define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM (1 << 3)
55 /**
56 * The decoder sets the cropping fields in the output frames manually.
57 * If this cap is set, the generic code will initialize output frame
58 * dimensions to coded rather than display values.
59 */
60 #define FF_CODEC_CAP_EXPORTS_CROPPING (1 << 4)
61 /**
62 * Codec initializes slice-based threading with a main function
63 */
64 #define FF_CODEC_CAP_SLICE_THREAD_HAS_MF (1 << 5)
65 /**
66 * The decoder might make use of the ProgressFrame API.
67 */
68 #define FF_CODEC_CAP_USES_PROGRESSFRAMES (1 << 6)
69 /**
70 * Codec handles avctx->thread_count == 0 (auto) internally.
71 */
72 #define FF_CODEC_CAP_AUTO_THREADS (1 << 7)
73 /**
74 * Codec handles output frame properties internally instead of letting the
75 * internal logic derive them from AVCodecInternal.last_pkt_props.
76 */
77 #define FF_CODEC_CAP_SETS_FRAME_PROPS (1 << 8)
78 /**
79 * Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
80 */
81 #define FF_CODEC_CAP_ICC_PROFILES (1 << 9)
82 /**
83 * The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it
84 * only wants to be flushed at the end to update some context variables (e.g.
85 * 2pass stats) or produce a trailing packet. Besides that it immediately
86 * produces exactly one output packet per each input frame, just as no-delay
87 * encoders do.
88 */
89 #define FF_CODEC_CAP_EOF_FLUSH (1 << 10)
90
91 /**
92 * FFCodec.codec_tags termination value
93 */
94 #define FF_CODEC_TAGS_END -1
95
96 typedef struct FFCodecDefault {
97 const char *key;
98 const char *value;
99 } FFCodecDefault;
100
101 struct AVCodecContext;
102 struct AVSubtitle;
103 struct AVPacket;
104 enum AVCodecConfig;
105
106 enum FFCodecType {
107 /* The codec is a decoder using the decode callback;
108 * audio and video codecs only. */
109 FF_CODEC_CB_TYPE_DECODE,
110 /* The codec is a decoder using the decode_sub callback;
111 * subtitle codecs only. */
112 FF_CODEC_CB_TYPE_DECODE_SUB,
113 /* The codec is a decoder using the receive_frame callback;
114 * audio and video codecs only. */
115 FF_CODEC_CB_TYPE_RECEIVE_FRAME,
116 /* The codec is an encoder using the encode callback;
117 * audio and video codecs only. */
118 FF_CODEC_CB_TYPE_ENCODE,
119 /* The codec is an encoder using the encode_sub callback;
120 * subtitle codecs only. */
121 FF_CODEC_CB_TYPE_ENCODE_SUB,
122 /* The codec is an encoder using the receive_packet callback;
123 * audio and video codecs only. */
124 FF_CODEC_CB_TYPE_RECEIVE_PACKET,
125 };
126
127 typedef struct FFCodec {
128 /**
129 * The public AVCodec. See codec.h for it.
130 */
131 AVCodec p;
132
133 /**
134 * Internal codec capabilities FF_CODEC_CAP_*.
135 */
136 unsigned caps_internal:26;
137
138 /**
139 * Is this a decoder?
140 */
141 unsigned is_decoder:1;
142
143 /**
144 * This field determines the video color ranges supported by an encoder.
145 * Should be set to a bitmask of AVCOL_RANGE_MPEG and AVCOL_RANGE_JPEG.
146 */
147 unsigned color_ranges:2;
148
149 /**
150 * This field determines the type of the codec (decoder/encoder)
151 * and also the exact callback cb implemented by the codec.
152 * cb_type uses enum FFCodecType values.
153 */
154 unsigned cb_type:3;
155
156 /**
157 * This field determines the alpha modes supported by an encoder.
158 */
159 const enum AVAlphaMode *alpha_modes;
160
161 int priv_data_size;
162 /**
163 * @name Frame-level threading support functions
164 * @{
165 */
166 /**
167 * Copy necessary context variables from a previous thread context to the current one.
168 * If not defined, the next thread will start automatically; otherwise, the codec
169 * must call ff_thread_finish_setup().
170 *
171 * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
172 */
173 int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
174
175 /**
176 * Copy variables back to the user-facing context
177 */
178 int (*update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src);
179 /** @} */
180
181 /**
182 * Private codec-specific defaults.
183 */
184 const FFCodecDefault *defaults;
185
186 int (*init)(struct AVCodecContext *);
187
188 union {
189 /**
190 * Decode to an AVFrame.
191 * cb is in this state if cb_type is FF_CODEC_CB_TYPE_DECODE.
192 *
193 * @param avctx codec context
194 * @param[out] frame AVFrame for output
195 * @param[out] got_frame_ptr decoder sets to 0 or 1 to indicate that
196 * a non-empty frame was returned in frame.
197 * @param[in] avpkt AVPacket containing the data to be decoded
198 * @return amount of bytes read from the packet on success,
199 * negative error code on failure
200 */
201 int (*decode)(struct AVCodecContext *avctx, struct AVFrame *frame,
202 int *got_frame_ptr, struct AVPacket *avpkt);
203 /**
204 * Decode subtitle data to an AVSubtitle.
205 * cb is in this state if cb_type is FF_CODEC_CB_TYPE_DECODE_SUB.
206 *
207 * Apart from that this is like the decode callback.
208 */
209 int (*decode_sub)(struct AVCodecContext *avctx, struct AVSubtitle *sub,
210 int *got_frame_ptr, const struct AVPacket *avpkt);
211 /**
212 * Decode API with decoupled packet/frame dataflow.
213 * cb is in this state if cb_type is FF_CODEC_CB_TYPE_RECEIVE_FRAME.
214 *
215 * This function is called to get one output frame. It should call
216 * ff_decode_get_packet() to obtain input data.
217 */
218 int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
219 /**
220 * Encode data to an AVPacket.
221 * cb is in this state if cb_type is FF_CODEC_CB_TYPE_ENCODE
222 *
223 * @param avctx codec context
224 * @param[out] avpkt output AVPacket
225 * @param[in] frame AVFrame containing the input to be encoded
226 * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
227 * non-empty packet was returned in avpkt.
228 * @return 0 on success, negative error code on failure
229 */
230 int (*encode)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
231 const struct AVFrame *frame, int *got_packet_ptr);
232 /**
233 * Encode subtitles to a raw buffer.
234 * cb is in this state if cb_type is FF_CODEC_CB_TYPE_ENCODE_SUB.
235 */
236 int (*encode_sub)(struct AVCodecContext *avctx, uint8_t *buf,
237 int buf_size, const struct AVSubtitle *sub);
238 /**
239 * Encode API with decoupled frame/packet dataflow.
240 * cb is in this state if cb_type is FF_CODEC_CB_TYPE_RECEIVE_PACKET.
241 *
242 * This function is called to get one output packet.
243 * It should call ff_encode_get_frame() to obtain input data.
244 */
245 int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
246 } cb;
247
248 int (*close)(struct AVCodecContext *);
249
250 /**
251 * Flush buffers.
252 * Will be called when seeking
253 */
254 void (*flush)(struct AVCodecContext *);
255
256 /**
257 * Decoding only, a comma-separated list of bitstream filters to apply to
258 * packets before decoding.
259 */
260 const char *bsfs;
261
262 /**
263 * Array of pointers to hardware configurations supported by the codec,
264 * or NULL if no hardware supported. The array is terminated by a NULL
265 * pointer.
266 *
267 * The user can only access this field via avcodec_get_hw_config().
268 */
269 const struct AVCodecHWConfigInternal *const *hw_configs;
270
271 /**
272 * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
273 */
274 const uint32_t *codec_tags;
275
276 /**
277 * Custom callback for avcodec_get_supported_config(). If absent,
278 * ff_default_get_supported_config() will be used. `out_num_configs` will
279 * always be set to a valid pointer.
280 */
281 int (*get_supported_config)(const struct AVCodecContext *avctx,
282 const AVCodec *codec,
283 enum AVCodecConfig config,
284 unsigned flags,
285 const void **out_configs,
286 int *out_num_configs);
287 } FFCodec;
288
289 26205053 static av_always_inline const FFCodec *ffcodec(const AVCodec *codec)
290 {
291 26205053 return (const FFCodec*)codec;
292 }
293
294 /**
295 * Internal version of av_codec_is_encoder(). Must not be called with
296 * a NULL AVCodec*.
297 */
298 6335768 static inline int ff_codec_is_encoder(const AVCodec *avcodec)
299 {
300 6335768 const FFCodec *const codec = ffcodec(avcodec);
301 6335768 return !codec->is_decoder;
302 }
303
304 /**
305 * Internal version of av_codec_is_decoder(). Must not be called with
306 * a NULL AVCodec*.
307 */
308 11617882 static inline int ff_codec_is_decoder(const AVCodec *avcodec)
309 {
310 11617882 const FFCodec *const codec = ffcodec(avcodec);
311 11617882 return codec->is_decoder;
312 }
313
314 /**
315 * Default implementation for avcodec_get_supported_config(). Will return the
316 * relevant fields from AVCodec if present, or NULL otherwise.
317 *
318 * For AVCODEC_CONFIG_COLOR_RANGE, the output will depend on the bitmask in
319 * FFCodec.color_ranges, with a value of 0 returning NULL.
320 */
321 int ff_default_get_supported_config(const struct AVCodecContext *avctx,
322 const AVCodec *codec,
323 enum AVCodecConfig config,
324 unsigned flags,
325 const void **out_configs,
326 int *out_num_configs);
327
328 #if CONFIG_SMALL
329 #define CODEC_LONG_NAME(str) .p.long_name = NULL
330 #else
331 #define CODEC_LONG_NAME(str) .p.long_name = str
332 #endif
333
334 #if HAVE_THREADS
335 #define UPDATE_THREAD_CONTEXT(func) \
336 .update_thread_context = (func)
337 #define UPDATE_THREAD_CONTEXT_FOR_USER(func) \
338 .update_thread_context_for_user = (func)
339 #else
340 #define UPDATE_THREAD_CONTEXT(func) \
341 .update_thread_context = NULL
342 #define UPDATE_THREAD_CONTEXT_FOR_USER(func) \
343 .update_thread_context_for_user = NULL
344 #endif
345
346 #define FF_CODEC_DECODE_CB(func) \
347 .is_decoder = 1, \
348 .cb_type = FF_CODEC_CB_TYPE_DECODE, \
349 .cb.decode = (func)
350 #define FF_CODEC_DECODE_SUB_CB(func) \
351 .is_decoder = 1, \
352 .cb_type = FF_CODEC_CB_TYPE_DECODE_SUB, \
353 .cb.decode_sub = (func)
354 #define FF_CODEC_RECEIVE_FRAME_CB(func) \
355 .is_decoder = 1, \
356 .cb_type = FF_CODEC_CB_TYPE_RECEIVE_FRAME, \
357 .cb.receive_frame = (func)
358 #define FF_CODEC_ENCODE_CB(func) \
359 .is_decoder = 0, \
360 .cb_type = FF_CODEC_CB_TYPE_ENCODE, \
361 .cb.encode = (func)
362 #define FF_CODEC_ENCODE_SUB_CB(func) \
363 .is_decoder = 0, \
364 .cb_type = FF_CODEC_CB_TYPE_ENCODE_SUB, \
365 .cb.encode_sub = (func)
366 #define FF_CODEC_RECEIVE_PACKET_CB(func) \
367 .is_decoder = 0, \
368 .cb_type = FF_CODEC_CB_TYPE_RECEIVE_PACKET, \
369 .cb.receive_packet = (func)
370
371 #ifdef __clang__
372 #define DISABLE_DEPRECATION_WARNINGS FF_DISABLE_DEPRECATION_WARNINGS
373 #define ENABLE_DEPRECATION_WARNINGS FF_ENABLE_DEPRECATION_WARNINGS
374 #else
375 #define DISABLE_DEPRECATION_WARNINGS
376 #define ENABLE_DEPRECATION_WARNINGS
377 #endif
378
379 #define CODEC_CH_LAYOUTS(...) CODEC_CH_LAYOUTS_ARRAY(((const AVChannelLayout[]) { __VA_ARGS__, { 0 } }))
380 #define CODEC_CH_LAYOUTS_ARRAY(array) CODEC_ARRAY(ch_layouts, (array))
381
382 #define CODEC_SAMPLERATES(...) CODEC_SAMPLERATES_ARRAY(((const int[]) { __VA_ARGS__, 0 }))
383 #define CODEC_SAMPLERATES_ARRAY(array) CODEC_ARRAY(supported_samplerates, (array))
384
385 #define CODEC_SAMPLEFMTS(...) CODEC_SAMPLEFMTS_ARRAY(((const enum AVSampleFormat[]) { __VA_ARGS__, AV_SAMPLE_FMT_NONE }))
386 #define CODEC_SAMPLEFMTS_ARRAY(array) CODEC_ARRAY(sample_fmts, (array))
387
388 #define CODEC_FRAMERATES(...) CODEC_FRAMERATES_ARRAY(((const AVRational[]) { __VA_ARGS__, { 0, 0 } }))
389 #define CODEC_FRAMERATES_ARRAY(array) CODEC_ARRAY(supported_framerates, (array))
390
391 #define CODEC_PIXFMTS(...) CODEC_PIXFMTS_ARRAY(((const enum AVPixelFormat[]) { __VA_ARGS__, AV_PIX_FMT_NONE }))
392 #define CODEC_PIXFMTS_ARRAY(array) CODEC_ARRAY(pix_fmts, (array))
393
394 #define CODEC_ARRAY(field, array) \
395 DISABLE_DEPRECATION_WARNINGS \
396 .p.field = (array) \
397 ENABLE_DEPRECATION_WARNINGS
398
399 #endif /* AVCODEC_CODEC_INTERNAL_H */
400