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_major.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() 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.
51 */
52#define AV_CODEC_CAP_DR1 (1 << 1)
53/**
54 * Encoder or decoder requires flushing with NULL input at the end in order to
55 * give the complete and correct output.
56 *
57 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
58 * with NULL data. The user can still send NULL data to the public encode
59 * or decode function, but libavcodec will not pass it along to the codec
60 * unless this flag is set.
61 *
62 * Decoders:
63 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
64 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
65 * returns frames.
66 *
67 * Encoders:
68 * The encoder needs to be fed with NULL data at the end of encoding until the
69 * encoder no longer returns data.
70 *
71 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
72 * flag also means that the encoder must set the pts and duration for
73 * each output packet. If this flag is not set, the pts and duration will
74 * be determined by libavcodec from the input frame.
75 */
76#define AV_CODEC_CAP_DELAY (1 << 5)
77/**
78 * Codec can be fed a final frame with a smaller size.
79 * This can be used to prevent truncation of the last audio samples.
80 */
81#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
82
83#if FF_API_SUBFRAMES
84/**
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
93 * as a last resort.
94 */
95#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
96#endif
97
98/**
99 * Codec is experimental and is thus avoided in favor of non experimental
100 * encoders
101 */
102#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
103/**
104 * Codec should fill in channel configuration and samplerate instead of container
105 */
106#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
107/**
108 * Codec supports frame-level multithreading.
109 */
110#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
111/**
112 * Codec supports slice-based (or partition-based) multithreading.
113 */
114#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
115/**
116 * Codec supports changed parameters at any point.
117 */
118#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
119/**
120 * Codec supports multithreading through a method other than slice- or
121 * frame-level multithreading. Typically this marks wrappers around
122 * multithreading-capable external libraries.
123 */
124#define AV_CODEC_CAP_OTHER_THREADS (1 << 15)
125/**
126 * Audio encoder supports receiving a different number of samples in each call.
127 */
128#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
129/**
130 * Decoder is not a preferred choice for probing.
131 * This indicates that the decoder is not a good choice for probing.
132 * It could for example be an expensive to spin up hardware decoder,
133 * or it could simply not provide a lot of useful information about
134 * the stream.
135 * A decoder marked with this flag should only be used as last resort
136 * choice for probing.
137 */
138#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
139
140/**
141 * Codec is backed by a hardware implementation. Typically used to
142 * identify a non-hwaccel hardware decoder. For information about hwaccels, use
143 * avcodec_get_hw_config() instead.
144 */
145#define AV_CODEC_CAP_HARDWARE (1 << 18)
146
147/**
148 * Codec is potentially backed by a hardware implementation, but not
149 * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
150 * implementation provides some sort of internal fallback.
151 */
152#define AV_CODEC_CAP_HYBRID (1 << 19)
153
154/**
155 * This encoder can reorder user opaque values from input AVFrames and return
156 * them with corresponding output packets.
157 * @see AV_CODEC_FLAG_COPY_OPAQUE
158 */
159#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
160
161/**
162 * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
163 * not set, the encoder must be closed and reopened to ensure that no frames
164 * remain pending.
165 */
166#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
167
168/**
169 * The encoder is able to output reconstructed frame data, i.e. raw frames that
170 * would be produced by decoding the encoded bitstream.
171 *
172 * Reconstructed frame output is enabled by the AV_CODEC_FLAG_RECON_FRAME flag.
173 */
174#define AV_CODEC_CAP_ENCODER_RECON_FRAME (1 << 22)
175
176/**
177 * AVProfile.
178 */
179typedef struct AVProfile {
180 int profile;
181 const char *name; ///< short name for the profile
182} AVProfile;
183
184/**
185 * AVCodec.
186 */
187typedef struct AVCodec {
188 /**
189 * Name of the codec implementation.
190 * The name is globally unique among encoders and among decoders (but an
191 * encoder and a decoder can share the same name).
192 * This is the primary way to find a codec from the user perspective.
193 */
194 const char *name;
195 /**
196 * Descriptive name for the codec, meant to be more human readable than name.
197 * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
198 */
199 const char *long_name;
200 enum AVMediaType type;
201 enum AVCodecID id;
202 /**
203 * Codec capabilities.
204 * see AV_CODEC_CAP_*
205 */
206 int capabilities;
207 uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
208 const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
209 const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
210 const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
211 const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
212#if FF_API_OLD_CHANNEL_LAYOUT
213 /**
214 * @deprecated use ch_layouts instead
215 */
216 attribute_deprecated
217 const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
218#endif
219 const AVClass *priv_class; ///< AVClass for the private context
220 const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {AV_PROFILE_UNKNOWN}
221
222 /**
223 * Group name of the codec implementation.
224 * This is a short symbolic name of the wrapper backing this codec. A
225 * wrapper uses some kind of external implementation for the codec, such
226 * as an external library, or a codec implementation provided by the OS or
227 * the hardware.
228 * If this field is NULL, this is a builtin, libavcodec native codec.
229 * If non-NULL, this will be the suffix in AVCodec.name in most cases
230 * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
231 */
232 const char *wrapper_name;
233
234 /**
235 * Array of supported channel layouts, terminated with a zeroed layout.
236 */
237 const AVChannelLayout *ch_layouts;
238} AVCodec;
239
240/**
241 * Iterate over all registered codecs.
242 *
243 * @param opaque a pointer where libavcodec will store the iteration state. Must
244 * point to NULL to start the iteration.
245 *
246 * @return the next registered codec or NULL when the iteration is
247 * finished
248 */
249const AVCodec *av_codec_iterate(void **opaque);
250
251/**
252 * Find a registered decoder with a matching codec ID.
253 *
254 * @param id AVCodecID of the requested decoder
255 * @return A decoder if one was found, NULL otherwise.
256 */
257const AVCodec *avcodec_find_decoder(enum AVCodecID id);
258
259/**
260 * Find a registered decoder with the specified name.
261 *
262 * @param name name of the requested decoder
263 * @return A decoder if one was found, NULL otherwise.
264 */
265const AVCodec *avcodec_find_decoder_by_name(const char *name);
266
267/**
268 * Find a registered encoder with a matching codec ID.
269 *
270 * @param id AVCodecID of the requested encoder
271 * @return An encoder if one was found, NULL otherwise.
272 */
273const AVCodec *avcodec_find_encoder(enum AVCodecID id);
274
275/**
276 * Find a registered encoder with the specified name.
277 *
278 * @param name name of the requested encoder
279 * @return An encoder if one was found, NULL otherwise.
280 */
281const AVCodec *avcodec_find_encoder_by_name(const char *name);
282/**
283 * @return a non-zero number if codec is an encoder, zero otherwise
284 */
285int av_codec_is_encoder(const AVCodec *codec);
286
287/**
288 * @return a non-zero number if codec is a decoder, zero otherwise
289 */
290int av_codec_is_decoder(const AVCodec *codec);
291
292/**
293 * Return a name for the specified profile, if available.
294 *
295 * @param codec the codec that is searched for the given profile
296 * @param profile the profile value for which a name is requested
297 * @return A name for the profile if found, NULL otherwise.
298 */
299const char *av_get_profile_name(const AVCodec *codec, int profile);
300
301enum {
302 /**
303 * The codec supports this format via the hw_device_ctx interface.
304 *
305 * When selecting this format, AVCodecContext.hw_device_ctx should
306 * have been set to a device of the specified type before calling
307 * avcodec_open2().
308 */
309 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
310 /**
311 * The codec supports this format via the hw_frames_ctx interface.
312 *
313 * When selecting this format for a decoder,
314 * AVCodecContext.hw_frames_ctx should be set to a suitable frames
315 * context inside the get_format() callback. The frames context
316 * must have been created on a device of the specified type.
317 *
318 * When selecting this format for an encoder,
319 * AVCodecContext.hw_frames_ctx should be set to the context which
320 * will be used for the input frames before calling avcodec_open2().
321 */
322 AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
323 /**
324 * The codec supports this format by some internal method.
325 *
326 * This format can be selected without any additional configuration -
327 * no device or frames context is required.
328 */
329 AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
330 /**
331 * The codec supports this format by some ad-hoc method.
332 *
333 * Additional settings and/or function calls are required. See the
334 * codec-specific documentation for details. (Methods requiring
335 * this sort of configuration are deprecated and others should be
336 * used in preference.)
337 */
338 AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
339};
340
341typedef struct AVCodecHWConfig {
342 /**
343 * For decoders, a hardware pixel format which that decoder may be
344 * able to decode to if suitable hardware is available.
345 *
346 * For encoders, a pixel format which the encoder may be able to
347 * accept. If set to AV_PIX_FMT_NONE, this applies to all pixel
348 * formats supported by the codec.
349 */
350 enum AVPixelFormat pix_fmt;
351 /**
352 * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
353 * setup methods which can be used with this configuration.
354 */
355 int methods;
356 /**
357 * The device type associated with the configuration.
358 *
359 * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
360 * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
361 */
362 enum AVHWDeviceType device_type;
363} AVCodecHWConfig;
364
365/**
366 * Retrieve supported hardware configurations for a codec.
367 *
368 * Values of index from zero to some maximum return the indexed configuration
369 * descriptor; all other values return NULL. If the codec does not support
370 * any hardware configurations then it will always return NULL.
371 */
372const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
373
374/**
375 * @}
376 */
377
378#endif /* AVCODEC_CODEC_H */
379

source code of include/x86_64-linux-gnu/libavcodec/codec.h