4 * This file is part of FFmpeg.
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.
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.
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
21 #ifndef AVCODEC_CODEC_H
22 #define AVCODEC_CODEC_H
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"
33 #include "libavcodec/codec_id.h"
34 #include "libavcodec/version.h"
37 * @addtogroup lavc_core
42 * Decoder can use draw_horiz_band callback.
44 #define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
46 * Codec uses get_buffer() or get_encode_buffer() for allocating buffers and
47 * supports custom allocators.
48 * If not set, it might not use get_buffer() or get_encode_buffer() at all, or
49 * use operations that assume the buffer was allocated by
50 * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
52 #define AV_CODEC_CAP_DR1 (1 << 1)
53 #define AV_CODEC_CAP_TRUNCATED (1 << 3)
55 * Encoder or decoder requires flushing with NULL input at the end in order to
56 * give the complete and correct output.
58 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
59 * with NULL data. The user can still send NULL data to the public encode
60 * or decode function, but libavcodec will not pass it along to the codec
61 * unless this flag is set.
64 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
65 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
69 * The encoder needs to be fed with NULL data at the end of encoding until the
70 * encoder no longer returns data.
72 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
73 * flag also means that the encoder must set the pts and duration for
74 * each output packet. If this flag is not set, the pts and duration will
75 * be determined by libavcodec from the input frame.
77 #define AV_CODEC_CAP_DELAY (1 << 5)
79 * Codec can be fed a final frame with a smaller size.
80 * This can be used to prevent truncation of the last audio samples.
82 #define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
85 * Codec can output multiple frames per AVPacket
86 * Normally demuxers return one frame at a time, demuxers which do not do
87 * are connected to a parser to split what they return into proper frames.
88 * This flag is reserved to the very rare category of codecs which have a
89 * bitstream that cannot be split into frames without timeconsuming
90 * operations like full decoding. Demuxers carrying such bitstreams thus
91 * may return multiple frames in a packet. This has many disadvantages like
92 * prohibiting stream copy in many cases thus it should only be considered
95 #define AV_CODEC_CAP_SUBFRAMES (1 << 8)
97 * Codec is experimental and is thus avoided in favor of non experimental
100 #define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
102 * Codec should fill in channel configuration and samplerate instead of container
104 #define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
106 * Codec supports frame-level multithreading.
108 #define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
110 * Codec supports slice-based (or partition-based) multithreading.
112 #define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
114 * Codec supports changed parameters at any point.
116 #define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
118 * Codec supports multithreading through a method other than slice- or
119 * frame-level multithreading. Typically this marks wrappers around
120 * multithreading-capable external libraries.
122 #define AV_CODEC_CAP_OTHER_THREADS (1 << 15)
123 #if FF_API_AUTO_THREADS
124 #define AV_CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_OTHER_THREADS
127 * Audio encoder supports receiving a different number of samples in each call.
129 #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
131 * Decoder is not a preferred choice for probing.
132 * This indicates that the decoder is not a good choice for probing.
133 * It could for example be an expensive to spin up hardware decoder,
134 * or it could simply not provide a lot of useful information about
136 * A decoder marked with this flag should only be used as last resort
137 * choice for probing.
139 #define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
141 #if FF_API_UNUSED_CODEC_CAPS
143 * Deprecated and unused. Use AVCodecDescriptor.props instead
145 #define AV_CODEC_CAP_INTRA_ONLY 0x40000000
147 * Deprecated and unused. Use AVCodecDescriptor.props instead
149 #define AV_CODEC_CAP_LOSSLESS 0x80000000
153 * Codec is backed by a hardware implementation. Typically used to
154 * identify a non-hwaccel hardware decoder. For information about hwaccels, use
155 * avcodec_get_hw_config() instead.
157 #define AV_CODEC_CAP_HARDWARE (1 << 18)
160 * Codec is potentially backed by a hardware implementation, but not
161 * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
162 * implementation provides some sort of internal fallback.
164 #define AV_CODEC_CAP_HYBRID (1 << 19)
167 * This codec takes the reordered_opaque field from input AVFrames
168 * and returns it in the corresponding field in AVCodecContext after
171 #define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
174 * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
175 * not set, the encoder must be closed and reopened to ensure that no frames
178 #define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
183 typedef struct AVProfile {
185 const char *name; ///< short name for the profile
188 typedef struct AVCodecDefault AVCodecDefault;
190 struct AVCodecContext;
197 typedef struct AVCodec {
199 * Name of the codec implementation.
200 * The name is globally unique among encoders and among decoders (but an
201 * encoder and a decoder can share the same name).
202 * This is the primary way to find a codec from the user perspective.
206 * Descriptive name for the codec, meant to be more human readable than name.
207 * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
209 const char *long_name;
210 enum AVMediaType type;
213 * Codec capabilities.
217 const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
218 const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
219 const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
220 const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
221 const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
222 uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
223 const AVClass *priv_class; ///< AVClass for the private context
224 const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
227 * Group name of the codec implementation.
228 * This is a short symbolic name of the wrapper backing this codec. A
229 * wrapper uses some kind of external implementation for the codec, such
230 * as an external library, or a codec implementation provided by the OS or
232 * If this field is NULL, this is a builtin, libavcodec native codec.
233 * If non-NULL, this will be the suffix in AVCodec.name in most cases
234 * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
236 const char *wrapper_name;
238 /*****************************************************************
239 * No fields below this line are part of the public API. They
240 * may not be used outside of libavcodec and can be changed and
242 * New public fields should be added right above.
243 *****************************************************************
247 * @name Frame-level threading support functions
251 * Copy necessary context variables from a previous thread context to the current one.
252 * If not defined, the next thread will start automatically; otherwise, the codec
253 * must call ff_thread_finish_setup().
255 * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
257 int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
260 * Copy variables back to the user-facing context
262 int (*update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src);
266 * Private codec-specific defaults.
268 const AVCodecDefault *defaults;
271 * Initialize codec static data, called from av_codec_iterate().
273 * This is not intended for time consuming operations as it is
274 * run for every codec regardless of that codec being used.
276 void (*init_static_data)(struct AVCodec *codec);
278 int (*init)(struct AVCodecContext *);
279 int (*encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size,
280 const struct AVSubtitle *sub);
282 * Encode data to an AVPacket.
284 * @param avctx codec context
285 * @param avpkt output AVPacket
286 * @param[in] frame AVFrame containing the raw data to be encoded
287 * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
288 * non-empty packet was returned in avpkt.
289 * @return 0 on success, negative error code on failure
291 int (*encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
292 const struct AVFrame *frame, int *got_packet_ptr);
294 * Decode picture or subtitle data.
296 * @param avctx codec context
297 * @param outdata codec type dependent output struct
298 * @param[out] got_frame_ptr decoder sets to 0 or 1 to indicate that a
299 * non-empty frame or subtitle was returned in
301 * @param[in] avpkt AVPacket containing the data to be decoded
302 * @return amount of bytes read from the packet on success, negative error
305 int (*decode)(struct AVCodecContext *avctx, void *outdata,
306 int *got_frame_ptr, struct AVPacket *avpkt);
307 int (*close)(struct AVCodecContext *);
309 * Encode API with decoupled frame/packet dataflow. This function is called
310 * to get one output packet. It should call ff_encode_get_frame() to obtain
313 int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
316 * Decode API with decoupled packet/frame dataflow. This function is called
317 * to get one output frame. It should call ff_decode_get_packet() to obtain
320 int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
323 * Will be called when seeking
325 void (*flush)(struct AVCodecContext *);
327 * Internal codec capabilities.
328 * See FF_CODEC_CAP_* in internal.h
333 * Decoding only, a comma-separated list of bitstream filters to apply to
334 * packets before decoding.
339 * Array of pointers to hardware configurations supported by the codec,
340 * or NULL if no hardware supported. The array is terminated by a NULL
343 * The user can only access this field via avcodec_get_hw_config().
345 const struct AVCodecHWConfigInternal *const *hw_configs;
348 * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
350 const uint32_t *codec_tags;
354 * Iterate over all registered codecs.
356 * @param opaque a pointer where libavcodec will store the iteration state. Must
357 * point to NULL to start the iteration.
359 * @return the next registered codec or NULL when the iteration is
362 const AVCodec *av_codec_iterate(void **opaque);
365 * Find a registered decoder with a matching codec ID.
367 * @param id AVCodecID of the requested decoder
368 * @return A decoder if one was found, NULL otherwise.
370 AVCodec *avcodec_find_decoder(enum AVCodecID id);
373 * Find a registered decoder with the specified name.
375 * @param name name of the requested decoder
376 * @return A decoder if one was found, NULL otherwise.
378 AVCodec *avcodec_find_decoder_by_name(const char *name);
381 * Find a registered encoder with a matching codec ID.
383 * @param id AVCodecID of the requested encoder
384 * @return An encoder if one was found, NULL otherwise.
386 AVCodec *avcodec_find_encoder(enum AVCodecID id);
389 * Find a registered encoder with the specified name.
391 * @param name name of the requested encoder
392 * @return An encoder if one was found, NULL otherwise.
394 AVCodec *avcodec_find_encoder_by_name(const char *name);
396 * @return a non-zero number if codec is an encoder, zero otherwise
398 int av_codec_is_encoder(const AVCodec *codec);
401 * @return a non-zero number if codec is a decoder, zero otherwise
403 int av_codec_is_decoder(const AVCodec *codec);
407 * The codec supports this format via the hw_device_ctx interface.
409 * When selecting this format, AVCodecContext.hw_device_ctx should
410 * have been set to a device of the specified type before calling
413 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
415 * The codec supports this format via the hw_frames_ctx interface.
417 * When selecting this format for a decoder,
418 * AVCodecContext.hw_frames_ctx should be set to a suitable frames
419 * context inside the get_format() callback. The frames context
420 * must have been created on a device of the specified type.
422 * When selecting this format for an encoder,
423 * AVCodecContext.hw_frames_ctx should be set to the context which
424 * will be used for the input frames before calling avcodec_open2().
426 AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
428 * The codec supports this format by some internal method.
430 * This format can be selected without any additional configuration -
431 * no device or frames context is required.
433 AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
435 * The codec supports this format by some ad-hoc method.
437 * Additional settings and/or function calls are required. See the
438 * codec-specific documentation for details. (Methods requiring
439 * this sort of configuration are deprecated and others should be
440 * used in preference.)
442 AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
445 typedef struct AVCodecHWConfig {
447 * For decoders, a hardware pixel format which that decoder may be
448 * able to decode to if suitable hardware is available.
450 * For encoders, a pixel format which the encoder may be able to
451 * accept. If set to AV_PIX_FMT_NONE, this applies to all pixel
452 * formats supported by the codec.
454 enum AVPixelFormat pix_fmt;
456 * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
457 * setup methods which can be used with this configuration.
461 * The device type associated with the configuration.
463 * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
464 * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
466 enum AVHWDeviceType device_type;
470 * Retrieve supported hardware configurations for a codec.
472 * Values of index from zero to some maximum return the indexed configuration
473 * descriptor; all other values return NULL. If the codec does not support
474 * any hardware configurations then it will always return NULL.
476 const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
482 #endif /* AVCODEC_CODEC_H */