tor-browser

codec.h (17522B)

---

/*
* AVCodec public API
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#ifndef AVCODEC_CODEC_H
#define AVCODEC_CODEC_H

#include <stdint.h>

#include "libavutil/avutil.h"
#include "libavutil/hwcontext.h"
#include "libavutil/log.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"
#include "libavutil/samplefmt.h"

#include "libavcodec/codec_id.h"
#include "libavcodec/version.h"

/**
* @addtogroup lavc_core
* @{
*/

/**
* Decoder can use draw_horiz_band callback.
*/
#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
/**
* Codec uses get_buffer() or get_encode_buffer() for allocating buffers and
* supports custom allocators.
* If not set, it might not use get_buffer() or get_encode_buffer() at all, or
* use operations that assume the buffer was allocated by
* avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
*/
#define AV_CODEC_CAP_DR1 (1 << 1)
#if FF_API_FLAG_TRUNCATED
/**
* @deprecated Use parsers to always send proper frames.
*/
#  define AV_CODEC_CAP_TRUNCATED (1 << 3)
#endif
/**
* Encoder or decoder requires flushing with NULL input at the end in order to
* give the complete and correct output.
*
* NOTE: If this flag is not set, the codec is guaranteed to never be fed with
*       with NULL data. The user can still send NULL data to the public encode
*       or decode function, but libavcodec will not pass it along to the codec
*       unless this flag is set.
*
* Decoders:
* The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
* avpkt->size=0 at the end to get the delayed data until the decoder no longer
* returns frames.
*
* Encoders:
* The encoder needs to be fed with NULL data at the end of encoding until the
* encoder no longer returns data.
*
* NOTE: For encoders implementing the AVCodec.encode2() function, setting this
*       flag also means that the encoder must set the pts and duration for
*       each output packet. If this flag is not set, the pts and duration will
*       be determined by libavcodec from the input frame.
*/
#define AV_CODEC_CAP_DELAY (1 << 5)
/**
* Codec can be fed a final frame with a smaller size.
* This can be used to prevent truncation of the last audio samples.
*/
#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)

/**
* Codec can output multiple frames per AVPacket
* Normally demuxers return one frame at a time, demuxers which do not do
* are connected to a parser to split what they return into proper frames.
* This flag is reserved to the very rare category of codecs which have a
* bitstream that cannot be split into frames without timeconsuming
* operations like full decoding. Demuxers carrying such bitstreams thus
* may return multiple frames in a packet. This has many disadvantages like
* prohibiting stream copy in many cases thus it should only be considered
* as a last resort.
*/
#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
/**
* Codec is experimental and is thus avoided in favor of non experimental
* encoders
*/
#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
/**
* Codec should fill in channel configuration and samplerate instead of
* container
*/
#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
/**
* Codec supports frame-level multithreading.
*/
#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
/**
* Codec supports slice-based (or partition-based) multithreading.
*/
#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
/**
* Codec supports changed parameters at any point.
*/
#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
/**
* Codec supports multithreading through a method other than slice- or
* frame-level multithreading. Typically this marks wrappers around
* multithreading-capable external libraries.
*/
#define AV_CODEC_CAP_OTHER_THREADS (1 << 15)
#if FF_API_AUTO_THREADS
#  define AV_CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_OTHER_THREADS
#endif
/**
* Audio encoder supports receiving a different number of samples in each call.
*/
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
/**
* Decoder is not a preferred choice for probing.
* This indicates that the decoder is not a good choice for probing.
* It could for example be an expensive to spin up hardware decoder,
* or it could simply not provide a lot of useful information about
* the stream.
* A decoder marked with this flag should only be used as last resort
* choice for probing.
*/
#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)

#if FF_API_UNUSED_CODEC_CAPS
/**
* Deprecated and unused. Use AVCodecDescriptor.props instead
*/
#  define AV_CODEC_CAP_INTRA_ONLY 0x40000000
/**
* Deprecated and unused. Use AVCodecDescriptor.props instead
*/
#  define AV_CODEC_CAP_LOSSLESS 0x80000000
#endif

/**
* Codec is backed by a hardware implementation. Typically used to
* identify a non-hwaccel hardware decoder. For information about hwaccels, use
* avcodec_get_hw_config() instead.
*/
#define AV_CODEC_CAP_HARDWARE (1 << 18)

/**
* Codec is potentially backed by a hardware implementation, but not
* necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
* implementation provides some sort of internal fallback.
*/
#define AV_CODEC_CAP_HYBRID (1 << 19)

/**
* This codec takes the reordered_opaque field from input AVFrames
* and returns it in the corresponding field in AVCodecContext after
* encoding.
*/
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)

/**
* This encoder can be flushed using avcodec_flush_buffers(). If this flag is
* not set, the encoder must be closed and reopened to ensure that no frames
* remain pending.
*/
#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)

/**
* AVProfile.
*/
typedef struct AVProfile {
 int profile;
 const char* name;  ///< short name for the profile
} AVProfile;

typedef struct AVCodecDefault AVCodecDefault;

struct AVCodecContext;
struct AVSubtitle;
struct AVPacket;

/**
* AVCodec.
*/
typedef struct AVCodec {
 /**
  * Name of the codec implementation.
  * The name is globally unique among encoders and among decoders (but an
  * encoder and a decoder can share the same name).
  * This is the primary way to find a codec from the user perspective.
  */
 const char* name;
 /**
  * Descriptive name for the codec, meant to be more human readable than name.
  * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
  */
 const char* long_name;
 enum AVMediaType type;
 enum AVCodecID id;
 /**
  * Codec capabilities.
  * see AV_CODEC_CAP_*
  */
 int capabilities;
 uint8_t max_lowres;  ///< maximum value for lowres supported by the decoder
 const AVRational*
     supported_framerates;  ///< array of supported framerates, or NULL if any,
                            ///< array is terminated by {0,0}
 const enum AVPixelFormat*
     pix_fmts;  ///< array of supported pixel formats, or NULL if unknown,
                ///< array is terminated by -1
 const int*
     supported_samplerates;  ///< array of supported audio samplerates, or NULL
                             ///< if unknown, array is terminated by 0
 const enum AVSampleFormat*
     sample_fmts;  ///< array of supported sample formats, or NULL if unknown,
                   ///< array is terminated by -1
 const uint64_t*
     channel_layouts;        ///< array of support channel layouts, or NULL if
                             ///< unknown. array is terminated by 0
 const AVClass* priv_class;  ///< AVClass for the private context
 const AVProfile*
     profiles;  ///< array of recognized profiles, or NULL if unknown, array is
                ///< terminated by {FF_PROFILE_UNKNOWN}

 /**
  * Group name of the codec implementation.
  * This is a short symbolic name of the wrapper backing this codec. A
  * wrapper uses some kind of external implementation for the codec, such
  * as an external library, or a codec implementation provided by the OS or
  * the hardware.
  * If this field is NULL, this is a builtin, libavcodec native codec.
  * If non-NULL, this will be the suffix in AVCodec.name in most cases
  * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
  */
 const char* wrapper_name;

 /*****************************************************************
  * No fields below this line are part of the public API. They
  * may not be used outside of libavcodec and can be changed and
  * removed at will.
  * New public fields should be added right above.
  *****************************************************************
  */
 /**
  * Internal codec capabilities.
  * See FF_CODEC_CAP_* in internal.h
  */
 int caps_internal;

 int priv_data_size;
 /**
  * @name Frame-level threading support functions
  * @{
  */
 /**
  * Copy necessary context variables from a previous thread context to the
  * current one. If not defined, the next thread will start automatically;
  * otherwise, the codec must call ff_thread_finish_setup().
  *
  * dst and src will (rarely) point to the same context, in which case memcpy
  * should be skipped.
  */
 int (*update_thread_context)(struct AVCodecContext* dst,
                              const struct AVCodecContext* src);

 /**
  * Copy variables back to the user-facing context
  */
 int (*update_thread_context_for_user)(struct AVCodecContext* dst,
                                       const struct AVCodecContext* src);
 /** @} */

 /**
  * Private codec-specific defaults.
  */
 const AVCodecDefault* defaults;

 /**
  * Initialize codec static data, called from av_codec_iterate().
  *
  * This is not intended for time consuming operations as it is
  * run for every codec regardless of that codec being used.
  */
 void (*init_static_data)(struct AVCodec* codec);

 int (*init)(struct AVCodecContext*);
 int (*encode_sub)(struct AVCodecContext*, uint8_t* buf, int buf_size,
                   const struct AVSubtitle* sub);
 /**
  * Encode data to an AVPacket.
  *
  * @param      avctx          codec context
  * @param      avpkt          output AVPacket
  * @param[in]  frame          AVFrame containing the raw data to be encoded
  * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
  *                            non-empty packet was returned in avpkt.
  * @return 0 on success, negative error code on failure
  */
 int (*encode2)(struct AVCodecContext* avctx, struct AVPacket* avpkt,
                const struct AVFrame* frame, int* got_packet_ptr);
 /**
  * Decode picture or subtitle data.
  *
  * @param      avctx          codec context
  * @param      outdata        codec type dependent output struct
  * @param[out] got_frame_ptr  decoder sets to 0 or 1 to indicate that a
  *                            non-empty frame or subtitle was returned in
  *                            outdata.
  * @param[in]  avpkt          AVPacket containing the data to be decoded
  * @return amount of bytes read from the packet on success, negative error
  *         code on failure
  */
 int (*decode)(struct AVCodecContext* avctx, void* outdata, int* got_frame_ptr,
               struct AVPacket* avpkt);
 int (*close)(struct AVCodecContext*);
 /**
  * Encode API with decoupled frame/packet dataflow. This function is called
  * to get one output packet. It should call ff_encode_get_frame() to obtain
  * input data.
  */
 int (*receive_packet)(struct AVCodecContext* avctx, struct AVPacket* avpkt);

 /**
  * Decode API with decoupled packet/frame dataflow. This function is called
  * to get one output frame. It should call ff_decode_get_packet() to obtain
  * input data.
  */
 int (*receive_frame)(struct AVCodecContext* avctx, struct AVFrame* frame);
 /**
  * Flush buffers.
  * Will be called when seeking
  */
 void (*flush)(struct AVCodecContext*);

 /**
  * Decoding only, a comma-separated list of bitstream filters to apply to
  * packets before decoding.
  */
 const char* bsfs;

 /**
  * Array of pointers to hardware configurations supported by the codec,
  * or NULL if no hardware supported.  The array is terminated by a NULL
  * pointer.
  *
  * The user can only access this field via avcodec_get_hw_config().
  */
 const struct AVCodecHWConfigInternal* const* hw_configs;

 /**
  * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
  */
 const uint32_t* codec_tags;
} AVCodec;

/**
* Iterate over all registered codecs.
*
* @param opaque a pointer where libavcodec will store the iteration state. Must
*               point to NULL to start the iteration.
*
* @return the next registered codec or NULL when the iteration is
*         finished
*/
const AVCodec* av_codec_iterate(void** opaque);

/**
* Find a registered decoder with a matching codec ID.
*
* @param id AVCodecID of the requested decoder
* @return A decoder if one was found, NULL otherwise.
*/
const AVCodec* avcodec_find_decoder(enum AVCodecID id);

/**
* Find a registered decoder with the specified name.
*
* @param name name of the requested decoder
* @return A decoder if one was found, NULL otherwise.
*/
const AVCodec* avcodec_find_decoder_by_name(const char* name);

/**
* Find a registered encoder with a matching codec ID.
*
* @param id AVCodecID of the requested encoder
* @return An encoder if one was found, NULL otherwise.
*/
const AVCodec* avcodec_find_encoder(enum AVCodecID id);

/**
* Find a registered encoder with the specified name.
*
* @param name name of the requested encoder
* @return An encoder if one was found, NULL otherwise.
*/
const AVCodec* avcodec_find_encoder_by_name(const char* name);
/**
* @return a non-zero number if codec is an encoder, zero otherwise
*/
int av_codec_is_encoder(const AVCodec* codec);

/**
* @return a non-zero number if codec is a decoder, zero otherwise
*/
int av_codec_is_decoder(const AVCodec* codec);

/**
* Return a name for the specified profile, if available.
*
* @param codec the codec that is searched for the given profile
* @param profile the profile value for which a name is requested
* @return A name for the profile if found, NULL otherwise.
*/
const char* av_get_profile_name(const AVCodec* codec, int profile);

enum {
 /**
  * The codec supports this format via the hw_device_ctx interface.
  *
  * When selecting this format, AVCodecContext.hw_device_ctx should
  * have been set to a device of the specified type before calling
  * avcodec_open2().
  */
 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
 /**
  * The codec supports this format via the hw_frames_ctx interface.
  *
  * When selecting this format for a decoder,
  * AVCodecContext.hw_frames_ctx should be set to a suitable frames
  * context inside the get_format() callback.  The frames context
  * must have been created on a device of the specified type.
  *
  * When selecting this format for an encoder,
  * AVCodecContext.hw_frames_ctx should be set to the context which
  * will be used for the input frames before calling avcodec_open2().
  */
 AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
 /**
  * The codec supports this format by some internal method.
  *
  * This format can be selected without any additional configuration -
  * no device or frames context is required.
  */
 AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
 /**
  * The codec supports this format by some ad-hoc method.
  *
  * Additional settings and/or function calls are required.  See the
  * codec-specific documentation for details.  (Methods requiring
  * this sort of configuration are deprecated and others should be
  * used in preference.)
  */
 AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
};

typedef struct AVCodecHWConfig {
 /**
  * For decoders, a hardware pixel format which that decoder may be
  * able to decode to if suitable hardware is available.
  *
  * For encoders, a pixel format which the encoder may be able to
  * accept.  If set to AV_PIX_FMT_NONE, this applies to all pixel
  * formats supported by the codec.
  */
 enum AVPixelFormat pix_fmt;
 /**
  * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
  * setup methods which can be used with this configuration.
  */
 int methods;
 /**
  * The device type associated with the configuration.
  *
  * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
  * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
  */
 enum AVHWDeviceType device_type;
} AVCodecHWConfig;

/**
* Retrieve supported hardware configurations for a codec.
*
* Values of index from zero to some maximum return the indexed configuration
* descriptor; all other values return NULL.  If the codec does not support
* any hardware configurations then it will always return NULL.
*/
const AVCodecHWConfig* avcodec_get_hw_config(const AVCodec* codec, int index);

/**
* @}
*/

#endif /* AVCODEC_CODEC_H */