FFmpeg  4.3.1
codec.h
Go to the documentation of this file.
1 /*
2  * AVCodec public API
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #ifndef AVCODEC_CODEC_H
22 #define AVCODEC_CODEC_H
23 
24 #include <stdint.h>
25 
26 #include "libavutil/avutil.h"
27 #include "libavutil/hwcontext.h"
28 #include "libavutil/log.h"
29 #include "libavutil/pixfmt.h"
30 #include "libavutil/rational.h"
31 #include "libavutil/samplefmt.h"
32 
33 #include "libavcodec/codec_id.h"
34 #include "libavcodec/version.h"
35 
36 /**
37  * @addtogroup lavc_core
38  * @{
39  */
40 
41 /**
42  * Decoder can use draw_horiz_band callback.
43  */
44 #define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
45 /**
46  * Codec uses get_buffer() for allocating buffers and supports custom allocators.
47  * If not set, it might not use get_buffer() at all or use operations that
48  * assume the buffer was allocated by avcodec_default_get_buffer.
49  */
50 #define AV_CODEC_CAP_DR1 (1 << 1)
51 #define AV_CODEC_CAP_TRUNCATED (1 << 3)
52 /**
53  * Encoder or decoder requires flushing with NULL input at the end in order to
54  * give the complete and correct output.
55  *
56  * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
57  * with NULL data. The user can still send NULL data to the public encode
58  * or decode function, but libavcodec will not pass it along to the codec
59  * unless this flag is set.
60  *
61  * Decoders:
62  * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
63  * avpkt->size=0 at the end to get the delayed data until the decoder no longer
64  * returns frames.
65  *
66  * Encoders:
67  * The encoder needs to be fed with NULL data at the end of encoding until the
68  * encoder no longer returns data.
69  *
70  * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
71  * flag also means that the encoder must set the pts and duration for
72  * each output packet. If this flag is not set, the pts and duration will
73  * be determined by libavcodec from the input frame.
74  */
75 #define AV_CODEC_CAP_DELAY (1 << 5)
76 /**
77  * Codec can be fed a final frame with a smaller size.
78  * This can be used to prevent truncation of the last audio samples.
79  */
80 #define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
81 
82 /**
83  * Codec can output multiple frames per AVPacket
84  * Normally demuxers return one frame at a time, demuxers which do not do
85  * are connected to a parser to split what they return into proper frames.
86  * This flag is reserved to the very rare category of codecs which have a
87  * bitstream that cannot be split into frames without timeconsuming
88  * operations like full decoding. Demuxers carrying such bitstreams thus
89  * may return multiple frames in a packet. This has many disadvantages like
90  * prohibiting stream copy in many cases thus it should only be considered
91  * as a last resort.
92  */
93 #define AV_CODEC_CAP_SUBFRAMES (1 << 8)
94 /**
95  * Codec is experimental and is thus avoided in favor of non experimental
96  * encoders
97  */
98 #define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
99 /**
100  * Codec should fill in channel configuration and samplerate instead of container
101  */
102 #define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
103 /**
104  * Codec supports frame-level multithreading.
105  */
106 #define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
107 /**
108  * Codec supports slice-based (or partition-based) multithreading.
109  */
110 #define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
111 /**
112  * Codec supports changed parameters at any point.
113  */
114 #define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
115 /**
116  * Codec supports avctx->thread_count == 0 (auto).
117  */
118 #define AV_CODEC_CAP_AUTO_THREADS (1 << 15)
119 /**
120  * Audio encoder supports receiving a different number of samples in each call.
121  */
122 #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
123 /**
124  * Decoder is not a preferred choice for probing.
125  * This indicates that the decoder is not a good choice for probing.
126  * It could for example be an expensive to spin up hardware decoder,
127  * or it could simply not provide a lot of useful information about
128  * the stream.
129  * A decoder marked with this flag should only be used as last resort
130  * choice for probing.
131  */
132 #define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
133 
134 #if FF_API_UNUSED_CODEC_CAPS
135 /**
136  * Deprecated and unused. Use AVCodecDescriptor.props instead
137  */
138 #define AV_CODEC_CAP_INTRA_ONLY 0x40000000
139 /**
140  * Deprecated and unused. Use AVCodecDescriptor.props instead
141  */
142 #define AV_CODEC_CAP_LOSSLESS 0x80000000
143 #endif
144 
145 /**
146  * Codec is backed by a hardware implementation. Typically used to
147  * identify a non-hwaccel hardware decoder. For information about hwaccels, use
148  * avcodec_get_hw_config() instead.
149  */
150 #define AV_CODEC_CAP_HARDWARE (1 << 18)
151 
152 /**
153  * Codec is potentially backed by a hardware implementation, but not
154  * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
155  * implementation provides some sort of internal fallback.
156  */
157 #define AV_CODEC_CAP_HYBRID (1 << 19)
158 
159 /**
160  * This codec takes the reordered_opaque field from input AVFrames
161  * and returns it in the corresponding field in AVCodecContext after
162  * encoding.
163  */
164 #define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
165 
166 /**
167  * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
168  * not set, the encoder must be closed and reopened to ensure that no frames
169  * remain pending.
170  */
171 #define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
172 
173 /**
174  * AVProfile.
175  */
176 typedef struct AVProfile {
177  int profile;
178  const char *name; ///< short name for the profile
179 } AVProfile;
180 
181 typedef struct AVCodecDefault AVCodecDefault;
182 
183 struct AVCodecContext;
184 struct AVSubtitle;
185 struct AVPacket;
186 
187 /**
188  * AVCodec.
189  */
190 typedef struct AVCodec {
191  /**
192  * Name of the codec implementation.
193  * The name is globally unique among encoders and among decoders (but an
194  * encoder and a decoder can share the same name).
195  * This is the primary way to find a codec from the user perspective.
196  */
197  const char *name;
198  /**
199  * Descriptive name for the codec, meant to be more human readable than name.
200  * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
201  */
202  const char *long_name;
203  enum AVMediaType type;
204  enum AVCodecID id;
205  /**
206  * Codec capabilities.
207  * see AV_CODEC_CAP_*
208  */
210  const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
211  const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
212  const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
213  const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
214  const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
215  uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
216  const AVClass *priv_class; ///< AVClass for the private context
217  const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
218 
219  /**
220  * Group name of the codec implementation.
221  * This is a short symbolic name of the wrapper backing this codec. A
222  * wrapper uses some kind of external implementation for the codec, such
223  * as an external library, or a codec implementation provided by the OS or
224  * the hardware.
225  * If this field is NULL, this is a builtin, libavcodec native codec.
226  * If non-NULL, this will be the suffix in AVCodec.name in most cases
227  * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
228  */
229  const char *wrapper_name;
230 
231  /*****************************************************************
232  * No fields below this line are part of the public API. They
233  * may not be used outside of libavcodec and can be changed and
234  * removed at will.
235  * New public fields should be added right above.
236  *****************************************************************
237  */
239  struct AVCodec *next;
240  /**
241  * @name Frame-level threading support functions
242  * @{
243  */
244  /**
245  * Copy necessary context variables from a previous thread context to the current one.
246  * If not defined, the next thread will start automatically; otherwise, the codec
247  * must call ff_thread_finish_setup().
248  *
249  * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
250  */
251  int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
252  /** @} */
253 
254  /**
255  * Private codec-specific defaults.
256  */
258 
259  /**
260  * Initialize codec static data, called from avcodec_register().
261  *
262  * This is not intended for time consuming operations as it is
263  * run for every codec regardless of that codec being used.
264  */
265  void (*init_static_data)(struct AVCodec *codec);
266 
267  int (*init)(struct AVCodecContext *);
268  int (*encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size,
269  const struct AVSubtitle *sub);
270  /**
271  * Encode data to an AVPacket.
272  *
273  * @param avctx codec context
274  * @param avpkt output AVPacket (may contain a user-provided buffer)
275  * @param[in] frame AVFrame containing the raw data to be encoded
276  * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
277  * non-empty packet was returned in avpkt.
278  * @return 0 on success, negative error code on failure
279  */
280  int (*encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
281  const struct AVFrame *frame, int *got_packet_ptr);
282  int (*decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt);
283  int (*close)(struct AVCodecContext *);
284  /**
285  * Encode API with decoupled packet/frame dataflow. The API is the
286  * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except
287  * that:
288  * - never called if the codec is closed or the wrong type,
289  * - if AV_CODEC_CAP_DELAY is not set, drain frames are never sent,
290  * - only one drain frame is ever passed down,
291  */
292  int (*send_frame)(struct AVCodecContext *avctx, const struct AVFrame *frame);
293  int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
294 
295  /**
296  * Decode API with decoupled packet/frame dataflow. This function is called
297  * to get one output frame. It should call ff_decode_get_packet() to obtain
298  * input data.
299  */
300  int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
301  /**
302  * Flush buffers.
303  * Will be called when seeking
304  */
305  void (*flush)(struct AVCodecContext *);
306  /**
307  * Internal codec capabilities.
308  * See FF_CODEC_CAP_* in internal.h
309  */
311 
312  /**
313  * Decoding only, a comma-separated list of bitstream filters to apply to
314  * packets before decoding.
315  */
316  const char *bsfs;
317 
318  /**
319  * Array of pointers to hardware configurations supported by the codec,
320  * or NULL if no hardware supported. The array is terminated by a NULL
321  * pointer.
322  *
323  * The user can only access this field via avcodec_get_hw_config().
324  */
325  const struct AVCodecHWConfigInternal **hw_configs;
326 
327  /**
328  * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
329  */
330  const uint32_t *codec_tags;
331 } AVCodec;
332 
333 /**
334  * Iterate over all registered codecs.
335  *
336  * @param opaque a pointer where libavcodec will store the iteration state. Must
337  * point to NULL to start the iteration.
338  *
339  * @return the next registered codec or NULL when the iteration is
340  * finished
341  */
342 const AVCodec *av_codec_iterate(void **opaque);
343 
344 /**
345  * Find a registered decoder with a matching codec ID.
346  *
347  * @param id AVCodecID of the requested decoder
348  * @return A decoder if one was found, NULL otherwise.
349  */
351 
352 /**
353  * Find a registered decoder with the specified name.
354  *
355  * @param name name of the requested decoder
356  * @return A decoder if one was found, NULL otherwise.
357  */
359 
360 /**
361  * Find a registered encoder with a matching codec ID.
362  *
363  * @param id AVCodecID of the requested encoder
364  * @return An encoder if one was found, NULL otherwise.
365  */
367 
368 /**
369  * Find a registered encoder with the specified name.
370  *
371  * @param name name of the requested encoder
372  * @return An encoder if one was found, NULL otherwise.
373  */
375 /**
376  * @return a non-zero number if codec is an encoder, zero otherwise
377  */
378 int av_codec_is_encoder(const AVCodec *codec);
379 
380 /**
381  * @return a non-zero number if codec is a decoder, zero otherwise
382  */
383 int av_codec_is_decoder(const AVCodec *codec);
384 
385 enum {
386  /**
387  * The codec supports this format via the hw_device_ctx interface.
388  *
389  * When selecting this format, AVCodecContext.hw_device_ctx should
390  * have been set to a device of the specified type before calling
391  * avcodec_open2().
392  */
394  /**
395  * The codec supports this format via the hw_frames_ctx interface.
396  *
397  * When selecting this format for a decoder,
398  * AVCodecContext.hw_frames_ctx should be set to a suitable frames
399  * context inside the get_format() callback. The frames context
400  * must have been created on a device of the specified type.
401  *
402  * When selecting this format for an encoder,
403  * AVCodecContext.hw_frames_ctx should be set to the context which
404  * will be used for the input frames before calling avcodec_open2().
405  */
407  /**
408  * The codec supports this format by some internal method.
409  *
410  * This format can be selected without any additional configuration -
411  * no device or frames context is required.
412  */
414  /**
415  * The codec supports this format by some ad-hoc method.
416  *
417  * Additional settings and/or function calls are required. See the
418  * codec-specific documentation for details. (Methods requiring
419  * this sort of configuration are deprecated and others should be
420  * used in preference.)
421  */
423 };
424 
425 typedef struct AVCodecHWConfig {
426  /**
427  * For decoders, a hardware pixel format which that decoder may be
428  * able to decode to if suitable hardware is available.
429  *
430  * For encoders, a pixel format which the encoder may be able to
431  * accept. If set to AV_PIX_FMT_NONE, this applies to all pixel
432  * formats supported by the codec.
433  */
434  enum AVPixelFormat pix_fmt;
435  /**
436  * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
437  * setup methods which can be used with this configuration.
438  */
439  int methods;
440  /**
441  * The device type associated with the configuration.
442  *
443  * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
444  * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
445  */
448 
449 /**
450  * Retrieve supported hardware configurations for a codec.
451  *
452  * Values of index from zero to some maximum return the indexed configuration
453  * descriptor; all other values return NULL. If the codec does not support
454  * any hardware configurations then it will always return NULL.
455  */
456 const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
457 
458 /**
459  * @}
460  */
461 
462 #endif /* AVCODEC_CODEC_H */
Convenience header that includes libavutil's core.
static AVFrame * frame
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
struct AVCodecDefault AVCodecDefault
Definition: codec.h:181
int av_codec_is_encoder(const AVCodec *codec)
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
int av_codec_is_decoder(const AVCodec *codec)
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
@ AV_CODEC_HW_CONFIG_METHOD_AD_HOC
The codec supports this format by some ad-hoc method.
Definition: codec.h:422
@ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
The codec supports this format via the hw_frames_ctx interface.
Definition: codec.h:406
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:393
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:413
AVMediaType
Definition: avutil.h:199
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AVHWDeviceType
Definition: hwcontext.h:27
Libavcodec version macros.
pixel format definitions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
Utilties for rational number calculation.
Describe the class of an AVClass context structure.
Definition: log.h:67
main external API structure.
Definition: avcodec.h:526
enum AVHWDeviceType device_type
The device type associated with the configuration.
Definition: codec.h:446
int methods
Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible setup methods which can be used...
Definition: codec.h:439
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:434
AVCodec.
Definition: codec.h:190
enum AVCodecID id
Definition: codec.h:204
const AVCodecDefault * defaults
Private codec-specific defaults.
Definition: codec.h:257
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: codec.h:214
int(* receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt)
Definition: codec.h:293
int caps_internal
Internal codec capabilities.
Definition: codec.h:310
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:300
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec.h:316
void(* init_static_data)(struct AVCodec *codec)
Initialize codec static data, called from avcodec_register().
Definition: codec.h:265
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:216
int(* init)(struct AVCodecContext *)
Definition: codec.h:267
const AVRational * supported_framerates
array of supported framerates, or NULL if any, array is terminated by {0,0}
Definition: codec.h:210
int(* send_frame)(struct AVCodecContext *avctx, const struct AVFrame *frame)
Encode API with decoupled packet/frame dataflow.
Definition: codec.h:292
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:251
const struct AVCodecHWConfigInternal ** hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: codec.h:325
int priv_data_size
Definition: codec.h:238
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:305
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:213
const uint32_t * codec_tags
List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
Definition: codec.h:330
struct AVCodec * next
Definition: codec.h:239
enum AVMediaType type
Definition: codec.h:203
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:211
const AVProfile * profiles
array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
Definition: codec.h:217
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:202
const char * wrapper_name
Group name of the codec implementation.
Definition: codec.h:229
const char * name
Name of the codec implementation.
Definition: codec.h:197
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:280
int(* close)(struct AVCodecContext *)
Definition: codec.h:283
int(* encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: codec.h:268
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0
Definition: codec.h:212
int capabilities
Codec capabilities.
Definition: codec.h:209
int(* decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt)
Definition: codec.h:282
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:215
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
This structure stores compressed data.
Definition: packet.h:332
AVProfile.
Definition: codec.h:176
int profile
Definition: codec.h:177
const char * name
short name for the profile
Definition: codec.h:178
Rational number (pair of numerator and denominator).
Definition: rational.h:58