FFmpeg
codec_internal.h
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 #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;
100 
101 struct AVCodecContext;
102 struct AVSubtitle;
103 struct AVPacket;
104 
106  /* The codec is a decoder using the decode callback;
107  * audio and video codecs only. */
109  /* The codec is a decoder using the decode_sub callback;
110  * subtitle codecs only. */
112  /* The codec is a decoder using the receive_frame callback;
113  * audio and video codecs only. */
115  /* The codec is an encoder using the encode callback;
116  * audio and video codecs only. */
118  /* The codec is an encoder using the encode_sub callback;
119  * subtitle codecs only. */
121  /* The codec is an encoder using the receive_packet callback;
122  * audio and video codecs only. */
124 };
125 
126 typedef struct FFCodec {
127  /**
128  * The public AVCodec. See codec.h for it.
129  */
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 
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  */
157 
158  /**
159  * Copy variables back to the user-facing context
160  */
162  /** @} */
163 
164  /**
165  * Private codec-specific defaults.
166  */
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 static av_always_inline const FFCodec *ffcodec(const AVCodec *codec)
306 {
307  return (const FFCodec*)codec;
308 }
309 
310 #endif /* AVCODEC_CODEC_INTERNAL_H */
AVSubtitle
Definition: avcodec.h:2228
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:156
AVCodec
AVCodec.
Definition: codec.h:187
FFCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec_internal.h:209
FFCodec::defaults
const FFCodecDefault * defaults
Private codec-specific defaults.
Definition: codec_internal.h:167
FF_CODEC_CB_TYPE_RECEIVE_PACKET
@ FF_CODEC_CB_TYPE_RECEIVE_PACKET
Definition: codec_internal.h:123
FFCodecDefault::key
const char * key
Definition: codec_internal.h:97
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
FFCodec
Definition: codec_internal.h:126
FFCodec::encode
int(* encode)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec_internal.h:221
FF_CODEC_CB_TYPE_ENCODE_SUB
@ FF_CODEC_CB_TYPE_ENCODE_SUB
Definition: codec_internal.h:120
FFCodec::priv_data_size
int priv_data_size
Definition: codec_internal.h:144
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
FFCodec::cb
union FFCodec::@90 cb
codec.h
FF_CODEC_CB_TYPE_DECODE
@ FF_CODEC_CB_TYPE_DECODE
Definition: codec_internal.h:108
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:161
FF_CODEC_CB_TYPE_ENCODE
@ FF_CODEC_CB_TYPE_ENCODE
Definition: codec_internal.h:117
FFCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec_internal.h:245
FFCodec::encode_sub
int(* encode_sub)(struct AVCodecContext *avctx, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Encode subtitles to a raw buffer.
Definition: codec_internal.h:227
FFCodec::decode
int(* decode)(struct AVCodecContext *avctx, struct AVFrame *frame, int *got_frame_ptr, struct AVPacket *avpkt)
Decode to an AVFrame.
Definition: codec_internal.h:192
FFCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec_internal.h:177
FF_CODEC_CB_TYPE_DECODE_SUB
@ FF_CODEC_CB_TYPE_DECODE_SUB
Definition: codec_internal.h:111
FFCodec::receive_packet
int(* receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt)
Encode API with decoupled frame/packet dataflow.
Definition: codec_internal.h:236
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:305
AVCodecHWConfigInternal
Definition: hwconfig.h:25
attributes.h
FFCodec::hw_configs
const struct AVCodecHWConfigInternal *const * hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: codec_internal.h:260
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:135
FFCodecDefault::value
const char * value
Definition: codec_internal.h:98
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFCodec::decode_sub
int(* decode_sub)(struct AVCodecContext *avctx, struct AVSubtitle *sub, int *got_frame_ptr, const struct AVPacket *avpkt)
Decode subtitle data to an AVSubtitle.
Definition: codec_internal.h:200
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCodecContext
main external API structure.
Definition: avcodec.h:445
FFCodec::codec_tags
const uint32_t * codec_tags
List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
Definition: codec_internal.h:265
FF_CODEC_CB_TYPE_RECEIVE_FRAME
@ FF_CODEC_CB_TYPE_RECEIVE_FRAME
Definition: codec_internal.h:114
FFCodecType
FFCodecType
Definition: codec_internal.h:105
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:142
FFCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec_internal.h:239
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:251
AVPacket
This structure stores compressed data.
Definition: packet.h:510
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FFCodec::init_static_data
void(* init_static_data)(struct FFCodec *codec)
Initialize codec static data, called from av_codec_iterate().
Definition: codec_internal.h:175
int
int
Definition: ffmpeg_filter.c:424