FFmpeg coverage

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
105			enum FFCodecType {
106			/* The codec is a decoder using the decode callback;
107			* audio and video codecs only. */
108			FF_CODEC_CB_TYPE_DECODE,
109			/* The codec is a decoder using the decode_sub callback;
110			* subtitle codecs only. */
111			FF_CODEC_CB_TYPE_DECODE_SUB,
112			/* The codec is a decoder using the receive_frame callback;
113			* audio and video codecs only. */
114			FF_CODEC_CB_TYPE_RECEIVE_FRAME,
115			/* The codec is an encoder using the encode callback;
116			* audio and video codecs only. */
117			FF_CODEC_CB_TYPE_ENCODE,
118			/* The codec is an encoder using the encode_sub callback;
119			* subtitle codecs only. */
120			FF_CODEC_CB_TYPE_ENCODE_SUB,
121			/* The codec is an encoder using the receive_packet callback;
122			* audio and video codecs only. */
123			FF_CODEC_CB_TYPE_RECEIVE_PACKET,
124			};
125
126			typedef struct FFCodec {
127			/**
128			* The public AVCodec. See codec.h for it.
129			*/
130			AVCodec p;
131
132			/**
133			* Internal codec capabilities FF_CODEC_CAP_*.
134			*/
135			unsigned caps_internal:29;
136
137			/**
138			* This field determines the type of the codec (decoder/encoder)
139			* and also the exact callback cb implemented by the codec.
140			* cb_type uses enum FFCodecType values.
141			*/
142			unsigned cb_type:3;
143
144			int priv_data_size;
145			/**
146			* @name Frame-level threading support functions
147			* @{
148			*/
149			/**
150			* Copy necessary context variables from a previous thread context to the current one.
151			* If not defined, the next thread will start automatically; otherwise, the codec
152			* must call ff_thread_finish_setup().
153			*
154			* dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
155			*/
156			int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
157
158			/**
159			* Copy variables back to the user-facing context
160			*/
161			int (*update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src);
162			/** @} */
163
164			/**
165			* Private codec-specific defaults.
166			*/
167			const FFCodecDefault *defaults;
168
169			/**
170			* Initialize codec static data, called from av_codec_iterate().
171			*
172			* This is not intended for time consuming operations as it is
173			* run for every codec regardless of that codec being used.
174			*/
175			void (*init_static_data)(struct FFCodec *codec);
176
177			int (*init)(struct AVCodecContext *);
178
179			union {
180			/**
181			* Decode to an AVFrame.
182			* cb is in this state if cb_type is FF_CODEC_CB_TYPE_DECODE.
183			*
184			* @param avctx codec context
185			* @param[out] frame AVFrame for output
186			* @param[out] got_frame_ptr decoder sets to 0 or 1 to indicate that
187			* a non-empty frame was returned in frame.
188			* @param[in] avpkt AVPacket containing the data to be decoded
189			* @return amount of bytes read from the packet on success,
190			* negative error code on failure
191			*/
192			int (*decode)(struct AVCodecContext *avctx, struct AVFrame *frame,
193			int *got_frame_ptr, struct AVPacket *avpkt);
194			/**
195			* Decode subtitle data to an AVSubtitle.
196			* cb is in this state if cb_type is FF_CODEC_CB_TYPE_DECODE_SUB.
197			*
198			* Apart from that this is like the decode callback.
199			*/
200			int (*decode_sub)(struct AVCodecContext *avctx, struct AVSubtitle *sub,
201			int *got_frame_ptr, const struct AVPacket *avpkt);
202			/**
203			* Decode API with decoupled packet/frame dataflow.
204			* cb is in this state if cb_type is FF_CODEC_CB_TYPE_RECEIVE_FRAME.
205			*
206			* This function is called to get one output frame. It should call
207			* ff_decode_get_packet() to obtain input data.
208			*/
209			int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
210			/**
211			* Encode data to an AVPacket.
212			* cb is in this state if cb_type is FF_CODEC_CB_TYPE_ENCODE
213			*
214			* @param avctx codec context
215			* @param[out] avpkt output AVPacket
216			* @param[in] frame AVFrame containing the input to be encoded
217			* @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
218			* non-empty packet was returned in avpkt.
219			* @return 0 on success, negative error code on failure
220			*/
221			int (*encode)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
222			const struct AVFrame *frame, int *got_packet_ptr);
223			/**
224			* Encode subtitles to a raw buffer.
225			* cb is in this state if cb_type is FF_CODEC_CB_TYPE_ENCODE_SUB.
226			*/
227			int (*encode_sub)(struct AVCodecContext *avctx, uint8_t *buf,
228			int buf_size, const struct AVSubtitle *sub);
229			/**
230			* Encode API with decoupled frame/packet dataflow.
231			* cb is in this state if cb_type is FF_CODEC_CB_TYPE_RECEIVE_PACKET.
232			*
233			* This function is called to get one output packet.
234			* It should call ff_encode_get_frame() to obtain input data.
235			*/
236			int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
237			} cb;
238
239			int (*close)(struct AVCodecContext *);
240
241			/**
242			* Flush buffers.
243			* Will be called when seeking
244			*/
245			void (*flush)(struct AVCodecContext *);
246
247			/**
248			* Decoding only, a comma-separated list of bitstream filters to apply to
249			* packets before decoding.
250			*/
251			const char *bsfs;
252
253			/**
254			* Array of pointers to hardware configurations supported by the codec,
255			* or NULL if no hardware supported. The array is terminated by a NULL
256			* pointer.
257			*
258			* The user can only access this field via avcodec_get_hw_config().
259			*/
260			const struct AVCodecHWConfigInternal *const *hw_configs;
261
262			/**
263			* List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
264			*/
265			const uint32_t *codec_tags;
266			} FFCodec;
267
268			#if CONFIG_SMALL
269			#define CODEC_LONG_NAME(str) .p.long_name = NULL
270			#else
271			#define CODEC_LONG_NAME(str) .p.long_name = str
272			#endif
273
274			#if HAVE_THREADS
275			#define UPDATE_THREAD_CONTEXT(func) \
276			.update_thread_context = (func)
277			#define UPDATE_THREAD_CONTEXT_FOR_USER(func) \
278			.update_thread_context_for_user = (func)
279			#else
280			#define UPDATE_THREAD_CONTEXT(func) \
281			.update_thread_context = NULL
282			#define UPDATE_THREAD_CONTEXT_FOR_USER(func) \
283			.update_thread_context_for_user = NULL
284			#endif
285
286			#define FF_CODEC_DECODE_CB(func) \
287			.cb_type = FF_CODEC_CB_TYPE_DECODE, \
288			.cb.decode = (func)
289			#define FF_CODEC_DECODE_SUB_CB(func) \
290			.cb_type = FF_CODEC_CB_TYPE_DECODE_SUB, \
291			.cb.decode_sub = (func)
292			#define FF_CODEC_RECEIVE_FRAME_CB(func) \
293			.cb_type = FF_CODEC_CB_TYPE_RECEIVE_FRAME, \
294			.cb.receive_frame = (func)
295			#define FF_CODEC_ENCODE_CB(func) \
296			.cb_type = FF_CODEC_CB_TYPE_ENCODE, \
297			.cb.encode = (func)
298			#define FF_CODEC_ENCODE_SUB_CB(func) \
299			.cb_type = FF_CODEC_CB_TYPE_ENCODE_SUB, \
300			.cb.encode_sub = (func)
301			#define FF_CODEC_RECEIVE_PACKET_CB(func) \
302			.cb_type = FF_CODEC_CB_TYPE_RECEIVE_PACKET, \
303			.cb.receive_packet = (func)
304
305		24625673	static av_always_inline const FFCodec *ffcodec(const AVCodec *codec)
306			{
307		24625673	return (const FFCodec*)codec;
308			}
309
310			#endif /* AVCODEC_CODEC_INTERNAL_H */
311