mirror/musikcube
1
0
Fork 0
mirror of https://github.com/clangen/musikcube.git synced 2024-10-02 13:02:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to ffmpeg 6.0.

Browse Source
This commit is contained in:
casey langen 2023-03-25 23:55:16 -07:00
parent f2909bcaa0
commit 2372eb1e78
71 changed files with 2826 additions and 970 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/3rdparty/bin vendored

@ -1 +1 @@
Subproject commit 0f2c74ab939760bbad14cd1251aa89d64be6fe38 Subproject commit dd6f64314f28f0cf5e75ae175f0b4b7c5fad0380

371
src/3rdparty/win32_include/libavcodec/avcodec.h vendored
View File

@ -43,7 +43,13 @@
#include "codec_id.h" #include "codec_id.h"
#include "defs.h" #include "defs.h"
#include "packet.h" #include "packet.h"
#include "version_major.h"
#ifndef HAVE_AV_CONFIG_H
/* When included as part of the ffmpeg build, only include the major version
* to avoid unnecessary rebuilds. When included externally, keep including
* the full version information. */
#include "version.h" #include "version.h"
#endif
/** /**
* @defgroup libavc libavcodec * @defgroup libavc libavcodec
@ -225,6 +231,58 @@ typedef struct RcOverride{
* decoded frame in stream. * decoded frame in stream.
*/ */
#define AV_CODEC_FLAG_DROPCHANGED (1 << 5) #define AV_CODEC_FLAG_DROPCHANGED (1 << 5)
/**
* Request the encoder to output reconstructed frames, i.e.\ frames that would
* be produced by decoding the encoded bistream. These frames may be retrieved
* by calling avcodec_receive_frame() immediately after a successful call to
* avcodec_receive_packet().
*
* Should only be used with encoders flagged with the
* @ref AV_CODEC_CAP_ENCODER_RECON_FRAME capability.
*/
#define AV_CODEC_FLAG_RECON_FRAME (1 << 6)
/**
* @par decoding
* Request the decoder to propagate each packets AVPacket.opaque and
* AVPacket.opaque_ref to its corresponding output AVFrame.
*
* @par encoding:
* Request the encoder to propagate each frame's AVFrame.opaque and
* AVFrame.opaque_ref values to its corresponding output AVPacket.
*
* @par
* May only be set on encoders that have the
* @ref AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE capability flag.
*
* @note
* While in typical cases one input frame produces exactly one output packet
* (perhaps after a delay), in general the mapping of frames to packets is
* M-to-N, so
* - Any number of input frames may be associated with any given output packet.
* This includes zero - e.g. some encoders may output packets that carry only
* metadata about the whole stream.
* - A given input frame may be associated with any number of output packets.
* Again this includes zero - e.g. some encoders may drop frames under certain
* conditions.
* .
* This implies that when using this flag, the caller must NOT assume that
* - a given input frame's opaques will necessarily appear on some output packet;
* - every output packet will have some non-NULL opaque value.
* .
* When an output packet contains multiple frames, the opaque values will be
* taken from the first of those.
*
* @note
* The converse holds for decoders, with frames and packets switched.
*/
#define AV_CODEC_FLAG_COPY_OPAQUE (1 << 7)
/**
* Signal to the encoder that the values of AVFrame.duration are valid and
* should be used (typically for transferring them to output packets).
*
* If this flag is not set, frame durations are ignored.
*/
#define AV_CODEC_FLAG_FRAME_DURATION (1 << 8)
/** /**
* Use internal 2pass ratecontrol in first pass mode. * Use internal 2pass ratecontrol in first pass mode.
*/ */
@ -245,15 +303,6 @@ typedef struct RcOverride{
* error[?] variables will be set during encoding. * error[?] variables will be set during encoding.
*/ */
#define AV_CODEC_FLAG_PSNR (1 << 15) #define AV_CODEC_FLAG_PSNR (1 << 15)
#if FF_API_FLAG_TRUNCATED
/**
* Input bitstream might be truncated at a random location
* instead of only at frame boundaries.
*
* @deprecated use codec parsers for packetizing input
*/
#define AV_CODEC_FLAG_TRUNCATED (1 << 16)
#endif
/** /**
* Use interlaced DCT. * Use interlaced DCT.
*/ */
@ -294,11 +343,6 @@ typedef struct RcOverride{
*/ */
#define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3) #define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3)
/**
* timecode is in drop frame format. DEPRECATED!!!!
*/
#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13)
/** /**
* Input bitstream might be truncated at a packet boundaries * Input bitstream might be truncated at a packet boundaries
* instead of only at frame boundaries. * instead of only at frame boundaries.
@ -325,13 +369,12 @@ typedef struct RcOverride{
* Do not reset ASS ReadOrder field on flush (subtitles decoding) * Do not reset ASS ReadOrder field on flush (subtitles decoding)
*/ */
#define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30) #define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30)
/**
/* Unsupported options : * Generate/parse ICC profiles on encode/decode, as appropriate for the type of
* Syntax Arithmetic coding (SAC) * file. No effect on codecs which cannot contain embedded ICC profiles, or
* Reference Picture Selection * when compiled without support for lcms2.
* Independent Segment Decoding */ */
/* /Fx */ #define AV_CODEC_FLAG2_ICC_PROFILES (1U << 31)
/* codec capabilities */
/* Exported side data. /* Exported side data.
These flags can be passed in AVCodecContext.export_side_data before initialization. These flags can be passed in AVCodecContext.export_side_data before initialization.
@ -500,8 +543,7 @@ typedef struct AVCodecContext {
* (fixed_vop_rate == 0 implies that it is different from the framerate) * (fixed_vop_rate == 0 implies that it is different from the framerate)
* *
* - encoding: MUST be set by user. * - encoding: MUST be set by user.
* - decoding: the use of this field for decoding is deprecated. * - decoding: unused.
* Use framerate instead.
*/ */
AVRational time_base; AVRational time_base;
@ -990,7 +1032,15 @@ typedef struct AVCodecContext {
/* audio only */ /* audio only */
int sample_rate; ///< samples per second int sample_rate; ///< samples per second
int channels; ///< number of audio channels
#if FF_API_OLD_CHANNEL_LAYOUT
/**
* number of audio channels
* @deprecated use ch_layout.nb_channels
*/
attribute_deprecated
int channels;
#endif
/** /**
* audio sample format * audio sample format
@ -1011,6 +1061,7 @@ typedef struct AVCodecContext {
*/ */
int frame_size; int frame_size;
#if FF_API_AVCTX_FRAME_NUMBER
/** /**
* Frame counter, set by libavcodec. * Frame counter, set by libavcodec.
* *
@ -1019,8 +1070,11 @@ typedef struct AVCodecContext {
* *
* @note the counter is not incremented if encoding/decoding resulted in * @note the counter is not incremented if encoding/decoding resulted in
* an error. * an error.
* @deprecated use frame_num instead
*/ */
attribute_deprecated
int frame_number; int frame_number;
#endif
/** /**
* number of bytes per packet if constant and known or 0 * number of bytes per packet if constant and known or 0
@ -1035,19 +1089,25 @@ typedef struct AVCodecContext {
*/ */
int cutoff; int cutoff;
#if FF_API_OLD_CHANNEL_LAYOUT
/** /**
* Audio channel layout. * Audio channel layout.
* - encoding: set by user. * - encoding: set by user.
* - decoding: set by user, may be overwritten by libavcodec. * - decoding: set by user, may be overwritten by libavcodec.
* @deprecated use ch_layout
*/ */
attribute_deprecated
uint64_t channel_layout; uint64_t channel_layout;
/** /**
* Request decoder to use this channel layout if it can (0 for default) * Request decoder to use this channel layout if it can (0 for default)
* - encoding: unused * - encoding: unused
* - decoding: Set by user. * - decoding: Set by user.
* @deprecated use "downmix" codec private option
*/ */
attribute_deprecated
uint64_t request_channel_layout; uint64_t request_channel_layout;
#endif
/** /**
* Type of service that the audio stream conveys. * Type of service that the audio stream conveys.
@ -1276,13 +1336,9 @@ typedef struct AVCodecContext {
* unofficial and experimental (that is, they always try to decode things * unofficial and experimental (that is, they always try to decode things
* when they can) unless they are explicitly asked to behave stupidly * when they can) unless they are explicitly asked to behave stupidly
* (=strictly conform to the specs) * (=strictly conform to the specs)
* This may only be set to one of the FF_COMPLIANCE_* values in defs.h.
*/ */
int strict_std_compliance; int strict_std_compliance;
#define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
#define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
#define FF_COMPLIANCE_NORMAL 0
#define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
/** /**
* error concealment flags * error concealment flags
@ -1318,28 +1374,14 @@ typedef struct AVCodecContext {
/** /**
* Error recognition; may misdetect some more or less valid parts as errors. * Error recognition; may misdetect some more or less valid parts as errors.
* This is a bitfield of the AV_EF_* values defined in defs.h.
*
* - encoding: Set by user. * - encoding: Set by user.
* - decoding: Set by user. * - decoding: Set by user.
*/ */
int err_recognition; int err_recognition;
/** #if FF_API_REORDERED_OPAQUE
* Verify checksums embedded in the bitstream (could be of either encoded or
* decoded data, depending on the codec) and print an error message on mismatch.
* If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
* decoder returning an error.
*/
#define AV_EF_CRCCHECK (1<<0)
#define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations
#define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length
#define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection
#define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue
#define AV_EF_CAREFUL (1<<16) ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
#define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors
#define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error
/** /**
* opaque 64-bit number (generally a PTS) that will be reordered and * opaque 64-bit number (generally a PTS) that will be reordered and
* output in AVFrame.reordered_opaque * output in AVFrame.reordered_opaque
@ -1348,8 +1390,12 @@ typedef struct AVCodecContext {
* supported by encoders with the * supported by encoders with the
* AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE capability. * AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE capability.
* - decoding: Set by user. * - decoding: Set by user.
*
* @deprecated Use AV_CODEC_FLAG_COPY_OPAQUE instead
*/ */
attribute_deprecated
int64_t reordered_opaque; int64_t reordered_opaque;
#endif
/** /**
* Hardware accelerator in use * Hardware accelerator in use
@ -1359,13 +1405,26 @@ typedef struct AVCodecContext {
const struct AVHWAccel *hwaccel; const struct AVHWAccel *hwaccel;
/** /**
* Hardware accelerator context. * Legacy hardware accelerator context.
* For some hardware accelerators, a global context needs to be *
* provided by the user. In that case, this holds display-dependent * For some hardware acceleration methods, the caller may use this field to
* data FFmpeg cannot instantiate itself. Please refer to the * signal hwaccel-specific data to the codec. The struct pointed to by this
* FFmpeg HW accelerator documentation to know how to fill this. * pointer is hwaccel-dependent and defined in the respective header. Please
* - encoding: unused * refer to the FFmpeg HW accelerator documentation to know how to fill
* - decoding: Set by user * this.
*
* In most cases this field is optional - the necessary information may also
* be provided to libavcodec through @ref hw_frames_ctx or @ref
* hw_device_ctx (see avcodec_get_hw_config()). However, in some cases it
* may be the only method of signalling some (optional) information.
*
* The struct and its contents are owned by the caller.
*
* - encoding: May be set by the caller before avcodec_open2(). Must remain
* valid until avcodec_free_context().
* - decoding: May be set by the caller in the get_format() callback.
* Must remain valid until the next get_format() call,
* or avcodec_free_context() (whichever comes first).
*/ */
void *hwaccel_context; void *hwaccel_context;
@ -1407,7 +1466,10 @@ typedef struct AVCodecContext {
#define FF_IDCT_SIMPLEARMV6 17 #define FF_IDCT_SIMPLEARMV6 17
#define FF_IDCT_FAAN 20 #define FF_IDCT_FAAN 20
#define FF_IDCT_SIMPLENEON 22 #define FF_IDCT_SIMPLENEON 22
#define FF_IDCT_NONE 24 /* Used by XvMC to extract IDCT coefficients with FF_IDCT_PERM_NONE */ #if FF_API_IDCT_NONE
// formerly used by xvmc
#define FF_IDCT_NONE 24
#endif
#define FF_IDCT_SIMPLEAUTO 128 #define FF_IDCT_SIMPLEAUTO 128
/** /**
@ -1458,27 +1520,6 @@ typedef struct AVCodecContext {
*/ */
int active_thread_type; int active_thread_type;
#if FF_API_THREAD_SAFE_CALLBACKS
/**
* Set by the client if its custom get_buffer() callback can be called
* synchronously from another thread, which allows faster multithreaded decoding.
* draw_horiz_band() will be called from other threads regardless of this setting.
* Ignored if the default get_buffer() is used.
* - encoding: Set by user.
* - decoding: Set by user.
*
* @deprecated the custom get_buffer2() callback should always be
* thread-safe. Thread-unsafe get_buffer2() implementations will be
* invalid starting with LIBAVCODEC_VERSION_MAJOR=60; in other words,
* libavcodec will behave as if this field was always set to 1.
* Callers that want to be forward compatible with future libavcodec
* versions should wrap access to this field in
* #if LIBAVCODEC_VERSION_MAJOR < 60
*/
attribute_deprecated
int thread_safe_callbacks;
#endif
/** /**
* The codec may call this to execute several independent things. * The codec may call this to execute several independent things.
* It will return only after finishing all tasks. * It will return only after finishing all tasks.
@ -1495,7 +1536,6 @@ typedef struct AVCodecContext {
* It will return only after finishing all tasks. * It will return only after finishing all tasks.
* The user may replace this with some multithreaded implementation, * The user may replace this with some multithreaded implementation,
* the default implementation will execute the parts serially. * the default implementation will execute the parts serially.
* Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
* @param c context passed also to func * @param c context passed also to func
* @param count the number of things to execute * @param count the number of things to execute
* @param arg2 argument passed unchanged to func * @param arg2 argument passed unchanged to func
@ -1780,17 +1820,6 @@ typedef struct AVCodecContext {
*/ */
int seek_preroll; int seek_preroll;
#if FF_API_DEBUG_MV
/**
* @deprecated unused
*/
attribute_deprecated
int debug_mv;
#define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames
#define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames
#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
#endif
/** /**
* custom intra quantization matrix * custom intra quantization matrix
* - encoding: Set by user, can be NULL. * - encoding: Set by user, can be NULL.
@ -1857,15 +1886,6 @@ typedef struct AVCodecContext {
*/ */
AVBufferRef *hw_frames_ctx; AVBufferRef *hw_frames_ctx;
#if FF_API_SUB_TEXT_FORMAT
/**
* @deprecated unused
*/
attribute_deprecated
int sub_text_format;
#define FF_SUB_TEXT_FMT_ASS 0
#endif
/** /**
* Audio only. The amount of padding (in samples) appended by the encoder to * Audio only. The amount of padding (in samples) appended by the encoder to
* the end of the audio. I.e. this number of decoded samples must be * the end of the audio. I.e. this number of decoded samples must be
@ -2024,9 +2044,26 @@ typedef struct AVCodecContext {
* - decoding: unused * - decoding: unused
*/ */
int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags); int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags);
} AVCodecContext;
struct MpegEncContext; /**
* Audio channel layout.
* - encoding: must be set by the caller, to one of AVCodec.ch_layouts.
* - decoding: may be set by the caller if known e.g. from the container.
* The decoder can then override during decoding as needed.
*/
AVChannelLayout ch_layout;
/**
* Frame counter, set by libavcodec.
*
* - decoding: total number of frames returned from the decoder so far.
* - encoding: total number of frames passed to the encoder so far.
*
* @note the counter is not incremented if encoding/decoding resulted in
* an error.
*/
int64_t frame_num;
} AVCodecContext;
/** /**
* @defgroup lavc_hwaccel AVHWAccel * @defgroup lavc_hwaccel AVHWAccel
@ -2119,7 +2156,6 @@ typedef struct AVHWAccel {
* *
* Meaningful slice information (codec specific) is guaranteed to * Meaningful slice information (codec specific) is guaranteed to
* be parsed at this point. This function is mandatory. * be parsed at this point. This function is mandatory.
* The only exception is XvMC, that works on MB level.
* *
* @param avctx the codec context * @param avctx the codec context
* @param buf the slice data buffer base * @param buf the slice data buffer base
@ -2148,17 +2184,6 @@ typedef struct AVHWAccel {
*/ */
int frame_priv_data_size; int frame_priv_data_size;
/**
* Called for every Macroblock in a slice.
*
* XvMC uses it to replace the ff_mpv_reconstruct_mb().
* Instead of decoding to raw picture, MB parameters are
* stored in an array provided by the video driver.
*
* @param s the mpeg context
*/
void (*decode_mb)(struct MpegEncContext *s);
/** /**
* Initialize the hwaccel private data. * Initialize the hwaccel private data.
* *
@ -2234,6 +2259,22 @@ typedef struct AVHWAccel {
*/ */
#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2) #define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
/**
* Some hardware decoders (namely nvdec) can either output direct decoder
* surfaces, or make an on-device copy and return said copy.
* There is a hard limit on how many decoder surfaces there can be, and it
* cannot be accurately guessed ahead of time.
* For some processing chains, this can be okay, but others will run into the
* limit and in turn produce very confusing errors that require fine tuning of
* more or less obscure options by the user, or in extreme cases cannot be
* resolved at all without inserting an avfilter that forces a copy.
*
* Thus, the hwaccel will by default make a copy for safety and resilience.
* If a users really wants to minimize the amount of copies, they can set this
* flag and ensure their processing chain does not exhaust the surface pool.
*/
#define AV_HWACCEL_FLAG_UNSAFE_OUTPUT (1 << 3)
/** /**
* @} * @}
*/ */
@ -2339,14 +2380,6 @@ void avcodec_free_context(AVCodecContext **avctx);
*/ */
const AVClass *avcodec_get_class(void); const AVClass *avcodec_get_class(void);
#if FF_API_GET_FRAME_CLASS
/**
* @deprecated This function should not be used.
*/
attribute_deprecated
const AVClass *avcodec_get_frame_class(void);
#endif
/** /**
* Get the AVClass for AVSubtitleRect. It can be used in combination with * Get the AVClass for AVSubtitleRect. It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options. * AV_OPT_SEARCH_FAKE_OBJ for examining options.
@ -2384,8 +2417,6 @@ int avcodec_parameters_to_context(AVCodecContext *codec,
* avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
* retrieving a codec. * retrieving a codec.
* *
* @warning This function is not thread safe!
*
* @note Always call this function before using decoding routines (such as * @note Always call this function before using decoding routines (such as
* @ref avcodec_receive_frame()). * @ref avcodec_receive_frame()).
* *
@ -2479,6 +2510,7 @@ void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
int linesize_align[AV_NUM_DATA_POINTERS]); int linesize_align[AV_NUM_DATA_POINTERS]);
#ifdef FF_API_AVCODEC_CHROMA_POS
/** /**
* Converts AVChromaLocation to swscale x/y chroma position. * Converts AVChromaLocation to swscale x/y chroma position.
* *
@ -2487,7 +2519,9 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
* *
* @param xpos horizontal chroma sample position * @param xpos horizontal chroma sample position
* @param ypos vertical chroma sample position * @param ypos vertical chroma sample position
* @deprecated Use av_chroma_location_enum_to_pos() instead.
*/ */
attribute_deprecated
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos); int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
/** /**
@ -2498,8 +2532,11 @@ int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
* *
* @param xpos horizontal chroma sample position * @param xpos horizontal chroma sample position
* @param ypos vertical chroma sample position * @param ypos vertical chroma sample position
* @deprecated Use av_chroma_location_pos_to_enum() instead.
*/ */
attribute_deprecated
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos); enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
#endif
/** /**
* Decode a subtitle message. * Decode a subtitle message.
@ -2529,8 +2566,7 @@ enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
* @param[in] avpkt The input AVPacket containing the input buffer. * @param[in] avpkt The input AVPacket containing the input buffer.
*/ */
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr, int *got_sub_ptr, const AVPacket *avpkt);
AVPacket *avpkt);
/** /**
* Supply raw packet data as input to a decoder. * Supply raw packet data as input to a decoder.
@ -2566,40 +2602,41 @@ int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
* still has frames buffered, it will return them after sending * still has frames buffered, it will return them after sending
* a flush packet. * a flush packet.
* *
* @return 0 on success, otherwise negative error code: * @retval 0 success
* AVERROR(EAGAIN): input is not accepted in the current state - user * @retval AVERROR(EAGAIN) input is not accepted in the current state - user
* must read output with avcodec_receive_frame() (once * must read output with avcodec_receive_frame() (once
* all output is read, the packet should be resent, and * all output is read, the packet should be resent,
* the call will not fail with EAGAIN). * and the call will not fail with EAGAIN).
* AVERROR_EOF: the decoder has been flushed, and no new packets can * @retval AVERROR_EOF the decoder has been flushed, and no new packets can be
* be sent to it (also returned if more than 1 flush * sent to it (also returned if more than 1 flush
* packet is sent) * packet is sent)
* AVERROR(EINVAL): codec not opened, it is an encoder, or requires flush * @retval AVERROR(EINVAL) codec not opened, it is an encoder, or requires flush
* AVERROR(ENOMEM): failed to add packet to internal queue, or similar * @retval AVERROR(ENOMEM) failed to add packet to internal queue, or similar
* other errors: legitimate decoding errors * @retval "another negative error code" legitimate decoding errors
*/ */
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt); int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);
/** /**
* Return decoded output data from a decoder. * Return decoded output data from a decoder or encoder (when the
* AV_CODEC_FLAG_RECON_FRAME flag is used).
* *
* @param avctx codec context * @param avctx codec context
* @param frame This will be set to a reference-counted video or audio * @param frame This will be set to a reference-counted video or audio
* frame (depending on the decoder type) allocated by the * frame (depending on the decoder type) allocated by the
* decoder. Note that the function will always call * codec. Note that the function will always call
* av_frame_unref(frame) before doing anything else. * av_frame_unref(frame) before doing anything else.
* *
* @return * @retval 0 success, a frame was returned
* 0: success, a frame was returned * @retval AVERROR(EAGAIN) output is not available in this state - user must
* AVERROR(EAGAIN): output is not available in this state - user must try * try to send new input
* to send new input * @retval AVERROR_EOF the codec has been fully flushed, and there will be
* AVERROR_EOF: the decoder has been fully flushed, and there will be * no more output frames
* no more output frames * @retval AVERROR(EINVAL) codec not opened, or it is an encoder without the
* AVERROR(EINVAL): codec not opened, or it is an encoder * AV_CODEC_FLAG_RECON_FRAME flag enabled
* AVERROR_INPUT_CHANGED: current decoded frame has changed parameters * @retval AVERROR_INPUT_CHANGED current decoded frame has changed parameters with
* with respect to first decoded frame. Applicable * respect to first decoded frame. Applicable when flag
* when flag AV_CODEC_FLAG_DROPCHANGED is set. * AV_CODEC_FLAG_DROPCHANGED is set.
* other negative values: legitimate decoding errors * @retval "other negative error code" legitimate decoding errors
*/ */
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame); int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);
@ -2626,16 +2663,16 @@ int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);
* If it is not set, frame->nb_samples must be equal to * If it is not set, frame->nb_samples must be equal to
* avctx->frame_size for all frames except the last. * avctx->frame_size for all frames except the last.
* The final frame may be smaller than avctx->frame_size. * The final frame may be smaller than avctx->frame_size.
* @return 0 on success, otherwise negative error code: * @retval 0 success
* AVERROR(EAGAIN): input is not accepted in the current state - user * @retval AVERROR(EAGAIN) input is not accepted in the current state - user must
* must read output with avcodec_receive_packet() (once * read output with avcodec_receive_packet() (once all
* all output is read, the packet should be resent, and * output is read, the packet should be resent, and the
* the call will not fail with EAGAIN). * call will not fail with EAGAIN).
* AVERROR_EOF: the encoder has been flushed, and no new frames can * @retval AVERROR_EOF the encoder has been flushed, and no new frames can
* be sent to it * be sent to it
* AVERROR(EINVAL): codec not opened, it is a decoder, or requires flush * @retval AVERROR(EINVAL) codec not opened, it is a decoder, or requires flush
* AVERROR(ENOMEM): failed to add packet to internal queue, or similar * @retval AVERROR(ENOMEM) failed to add packet to internal queue, or similar
* other errors: legitimate encoding errors * @retval "another negative error code" legitimate encoding errors
*/ */
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame); int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);
@ -2646,13 +2683,13 @@ int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);
* @param avpkt This will be set to a reference-counted packet allocated by the * @param avpkt This will be set to a reference-counted packet allocated by the
* encoder. Note that the function will always call * encoder. Note that the function will always call
* av_packet_unref(avpkt) before doing anything else. * av_packet_unref(avpkt) before doing anything else.
* @return 0 on success, otherwise negative error code: * @retval 0 success
* AVERROR(EAGAIN): output is not available in the current state - user * @retval AVERROR(EAGAIN) output is not available in the current state - user must
* must try to send input * try to send input
* AVERROR_EOF: the encoder has been fully flushed, and there will be * @retval AVERROR_EOF the encoder has been fully flushed, and there will be no
* no more output packets * more output packets
* AVERROR(EINVAL): codec not opened, or it is a decoder * @retval AVERROR(EINVAL) codec not opened, or it is a decoder
* other errors: legitimate encoding errors * @retval "another negative error code" legitimate encoding errors
*/ */
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt); int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);
@ -2766,10 +2803,10 @@ int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
*/ */
enum AVPictureStructure { enum AVPictureStructure {
AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown AV_PICTURE_STRUCTURE_UNKNOWN, ///< unknown
AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field AV_PICTURE_STRUCTURE_TOP_FIELD, ///< coded as top field
AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field AV_PICTURE_STRUCTURE_BOTTOM_FIELD, ///< coded as bottom field
AV_PICTURE_STRUCTURE_FRAME, //< coded as frame AV_PICTURE_STRUCTURE_FRAME, ///< coded as frame
}; };
typedef struct AVCodecParserContext { typedef struct AVCodecParserContext {

65
src/3rdparty/win32_include/libavcodec/bsf.h vendored
View File

@ -30,7 +30,28 @@
#include "packet.h" #include "packet.h"
/** /**
* @addtogroup lavc_core * @defgroup lavc_bsf Bitstream filters
* @ingroup libavc
*
* Bitstream filters transform encoded media data without decoding it. This
* allows e.g. manipulating various header values. Bitstream filters operate on
* @ref AVPacket "AVPackets".
*
* The bitstream filtering API is centered around two structures:
* AVBitStreamFilter and AVBSFContext. The former represents a bitstream filter
* in abstract, the latter a specific filtering process. Obtain an
* AVBitStreamFilter using av_bsf_get_by_name() or av_bsf_iterate(), then pass
* it to av_bsf_alloc() to create an AVBSFContext. Fill in the user-settable
* AVBSFContext fields, as described in its documentation, then call
* av_bsf_init() to prepare the filter context for use.
*
* Submit packets for filtering using av_bsf_send_packet(), obtain filtered
* results with av_bsf_receive_packet(). When no more input packets will be
* sent, submit a NULL AVPacket to signal the end of the stream to the filter.
* av_bsf_receive_packet() will then return trailing packets, if any are
* produced by the filter.
*
* Finally, free the filter context with av_bsf_free().
* @{ * @{
*/ */
@ -107,20 +128,6 @@ typedef struct AVBitStreamFilter {
* code to this class. * code to this class.
*/ */
const AVClass *priv_class; const AVClass *priv_class;
/*****************************************************************
* 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.
*****************************************************************
*/
int priv_data_size;
int (*init)(AVBSFContext *ctx);
int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
void (*close)(AVBSFContext *ctx);
void (*flush)(AVBSFContext *ctx);
} AVBitStreamFilter; } AVBitStreamFilter;
/** /**
@ -146,9 +153,9 @@ const AVBitStreamFilter *av_bsf_iterate(void **opaque);
* av_bsf_init() before sending any data to the filter. * av_bsf_init() before sending any data to the filter.
* *
* @param filter the filter for which to allocate an instance. * @param filter the filter for which to allocate an instance.
* @param ctx a pointer into which the pointer to the newly-allocated context * @param[out] ctx a pointer into which the pointer to the newly-allocated context
* will be written. It must be freed with av_bsf_free() after the * will be written. It must be freed with av_bsf_free() after the
* filtering is done. * filtering is done.
* *
* @return 0 on success, a negative AVERROR code on failure * @return 0 on success, a negative AVERROR code on failure
*/ */
@ -157,6 +164,8 @@ int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
/** /**
* Prepare the filter for use, after all the parameters and options have been * Prepare the filter for use, after all the parameters and options have been
* set. * set.
*
* @param ctx a AVBSFContext previously allocated with av_bsf_alloc()
*/ */
int av_bsf_init(AVBSFContext *ctx); int av_bsf_init(AVBSFContext *ctx);
@ -167,6 +176,7 @@ int av_bsf_init(AVBSFContext *ctx);
* av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
* AVERROR_EOF. * AVERROR_EOF.
* *
* @param ctx an initialized AVBSFContext
* @param pkt the packet to filter. The bitstream filter will take ownership of * @param pkt the packet to filter. The bitstream filter will take ownership of
* the packet and reset the contents of pkt. pkt is not touched if an error occurs. * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
* If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero), * If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero),
@ -174,15 +184,18 @@ int av_bsf_init(AVBSFContext *ctx);
* sending more empty packets does nothing) and will cause the filter to output * sending more empty packets does nothing) and will cause the filter to output
* any packets it may have buffered internally. * any packets it may have buffered internally.
* *
* @return 0 on success. AVERROR(EAGAIN) if packets need to be retrieved from the * @return
* filter (using av_bsf_receive_packet()) before new input can be consumed. Another * - 0 on success.
* negative AVERROR value if an error occurs. * - AVERROR(EAGAIN) if packets need to be retrieved from the filter (using
* av_bsf_receive_packet()) before new input can be consumed.
* - Another negative AVERROR value if an error occurs.
*/ */
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt); int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
/** /**
* Retrieve a filtered packet. * Retrieve a filtered packet.
* *
* @param ctx an initialized AVBSFContext
* @param[out] pkt this struct will be filled with the contents of the filtered * @param[out] pkt this struct will be filled with the contents of the filtered
* packet. It is owned by the caller and must be freed using * packet. It is owned by the caller and must be freed using
* av_packet_unref() when it is no longer needed. * av_packet_unref() when it is no longer needed.
@ -193,10 +206,12 @@ int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
* overwritten by the returned data. On failure, pkt is not * overwritten by the returned data. On failure, pkt is not
* touched. * touched.
* *
* @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the * @return
* filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there * - 0 on success.
* will be no further output from the filter. Another negative AVERROR value if * - AVERROR(EAGAIN) if more packets need to be sent to the filter (using
* an error occurs. * av_bsf_send_packet()) to get more output.
* - AVERROR_EOF if there will be no further output from the filter.
* - Another negative AVERROR value if an error occurs.
* *
* @note one input packet may result in several output packets, so after sending * @note one input packet may result in several output packets, so after sending
* a packet with av_bsf_send_packet(), this function needs to be called * a packet with av_bsf_send_packet(), this function needs to be called

162
src/3rdparty/win32_include/libavcodec/codec.h vendored
View File

@ -31,7 +31,7 @@
#include "libavutil/samplefmt.h" #include "libavutil/samplefmt.h"
#include "libavcodec/codec_id.h" #include "libavcodec/codec_id.h"
#include "libavcodec/version.h" #include "libavcodec/version_major.h"
/** /**
* @addtogroup lavc_core * @addtogroup lavc_core
@ -50,12 +50,6 @@
* avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer. * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
*/ */
#define AV_CODEC_CAP_DR1 (1 << 1) #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 * Encoder or decoder requires flushing with NULL input at the end in order to
* give the complete and correct output. * give the complete and correct output.
@ -125,9 +119,6 @@
* multithreading-capable external libraries. * multithreading-capable external libraries.
*/ */
#define AV_CODEC_CAP_OTHER_THREADS (1 << 15) #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. * Audio encoder supports receiving a different number of samples in each call.
*/ */
@ -143,17 +134,6 @@
*/ */
#define AV_CODEC_CAP_AVOID_PROBING (1 << 17) #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 * Codec is backed by a hardware implementation. Typically used to
* identify a non-hwaccel hardware decoder. For information about hwaccels, use * identify a non-hwaccel hardware decoder. For information about hwaccels, use
@ -169,9 +149,9 @@
#define AV_CODEC_CAP_HYBRID (1 << 19) #define AV_CODEC_CAP_HYBRID (1 << 19)
/** /**
* This codec takes the reordered_opaque field from input AVFrames * This encoder can reorder user opaque values from input AVFrames and return
* and returns it in the corresponding field in AVCodecContext after * them with corresponding output packets.
* encoding. * @see AV_CODEC_FLAG_COPY_OPAQUE
*/ */
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20) #define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
@ -182,6 +162,14 @@
*/ */
#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21) #define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
/**
* The encoder is able to output reconstructed frame data, i.e. raw frames that
* would be produced by decoding the encoded bitstream.
*
* Reconstructed frame output is enabled by the AV_CODEC_FLAG_RECON_FRAME flag.
*/
#define AV_CODEC_CAP_ENCODER_RECON_FRAME (1 << 22)
/** /**
* AVProfile. * AVProfile.
*/ */
@ -190,12 +178,6 @@ typedef struct AVProfile {
const char *name; ///< short name for the profile const char *name; ///< short name for the profile
} AVProfile; } AVProfile;
typedef struct AVCodecDefault AVCodecDefault;
struct AVCodecContext;
struct AVSubtitle;
struct AVPacket;
/** /**
* AVCodec. * AVCodec.
*/ */
@ -224,7 +206,13 @@ typedef struct AVCodec {
const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1 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 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 enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
#if FF_API_OLD_CHANNEL_LAYOUT
/**
* @deprecated use ch_layouts instead
*/
attribute_deprecated
const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0 const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
#endif
const AVClass *priv_class; ///< AVClass for the private context 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} const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
@ -240,120 +228,10 @@ typedef struct AVCodec {
*/ */
const char *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. * Array of supported channel layouts, terminated with a zeroed layout.
* See FF_CODEC_CAP_* in internal.h
*/ */
int caps_internal; const AVChannelLayout *ch_layouts;
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; } AVCodec;
/** /**

32
src/3rdparty/win32_include/libavcodec/codec_id.h vendored
View File

@ -24,6 +24,8 @@
#include "libavutil/avutil.h" #include "libavutil/avutil.h"
#include "libavutil/samplefmt.h" #include "libavutil/samplefmt.h"
#include "version_major.h"
/** /**
* @addtogroup lavc_core * @addtogroup lavc_core
* @{ * @{
@ -251,7 +253,9 @@ enum AVCodecID {
AV_CODEC_ID_AVRP, AV_CODEC_ID_AVRP,
AV_CODEC_ID_012V, AV_CODEC_ID_012V,
AV_CODEC_ID_AVUI, AV_CODEC_ID_AVUI,
#if FF_API_AYUV_CODECID
AV_CODEC_ID_AYUV, AV_CODEC_ID_AYUV,
#endif
AV_CODEC_ID_TARGA_Y216, AV_CODEC_ID_TARGA_Y216,
AV_CODEC_ID_V308, AV_CODEC_ID_V308,
AV_CODEC_ID_V408, AV_CODEC_ID_V408,
@ -308,6 +312,14 @@ enum AVCodecID {
AV_CODEC_ID_SIMBIOSIS_IMX, AV_CODEC_ID_SIMBIOSIS_IMX,
AV_CODEC_ID_SGA_VIDEO, AV_CODEC_ID_SGA_VIDEO,
AV_CODEC_ID_GEM, AV_CODEC_ID_GEM,
AV_CODEC_ID_VBN,
AV_CODEC_ID_JPEGXL,
AV_CODEC_ID_QOI,
AV_CODEC_ID_PHM,
AV_CODEC_ID_RADIANCE_HDR,
AV_CODEC_ID_WBMP,
AV_CODEC_ID_MEDIA100,
AV_CODEC_ID_VQC,
/* various PCM "codecs" */ /* various PCM "codecs" */
AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
@ -401,6 +413,7 @@ enum AVCodecID {
AV_CODEC_ID_ADPCM_IMA_CUNNING, AV_CODEC_ID_ADPCM_IMA_CUNNING,
AV_CODEC_ID_ADPCM_IMA_MOFLEX, AV_CODEC_ID_ADPCM_IMA_MOFLEX,
AV_CODEC_ID_ADPCM_IMA_ACORN, AV_CODEC_ID_ADPCM_IMA_ACORN,
AV_CODEC_ID_ADPCM_XMD,
/* AMR */ /* AMR */
AV_CODEC_ID_AMR_NB = 0x12000, AV_CODEC_ID_AMR_NB = 0x12000,
@ -418,6 +431,8 @@ enum AVCodecID {
AV_CODEC_ID_SDX2_DPCM, AV_CODEC_ID_SDX2_DPCM,
AV_CODEC_ID_GREMLIN_DPCM, AV_CODEC_ID_GREMLIN_DPCM,
AV_CODEC_ID_DERF_DPCM, AV_CODEC_ID_DERF_DPCM,
AV_CODEC_ID_WADY_DPCM,
AV_CODEC_ID_CBD2_DPCM,
/* audio codecs */ /* audio codecs */
AV_CODEC_ID_MP2 = 0x15000, AV_CODEC_ID_MP2 = 0x15000,
@ -516,6 +531,13 @@ enum AVCodecID {
AV_CODEC_ID_HCA, AV_CODEC_ID_HCA,
AV_CODEC_ID_FASTAUDIO, AV_CODEC_ID_FASTAUDIO,
AV_CODEC_ID_MSNSIREN, AV_CODEC_ID_MSNSIREN,
AV_CODEC_ID_DFPWM,
AV_CODEC_ID_BONK,
AV_CODEC_ID_MISC4,
AV_CODEC_ID_APAC,
AV_CODEC_ID_FTR,
AV_CODEC_ID_WAVARC,
AV_CODEC_ID_RKA,
/* subtitle codecs */ /* subtitle codecs */
AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
@ -570,6 +592,16 @@ enum AVCodecID {
* stream (only used by libavformat) */ * stream (only used by libavformat) */
AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
/**
* Dummy null video codec, useful mainly for development and debugging.
* Null encoder/decoder discard all input and never return any output.
*/
AV_CODEC_ID_VNULL,
/**
* Dummy null audio codec, useful mainly for development and debugging.
* Null encoder/decoder discard all input and never return any output.
*/
AV_CODEC_ID_ANULL,
}; };
/** /**

21
src/3rdparty/win32_include/libavcodec/codec_par.h vendored
View File

@ -24,6 +24,7 @@
#include <stdint.h> #include <stdint.h>
#include "libavutil/avutil.h" #include "libavutil/avutil.h"
#include "libavutil/channel_layout.h"
#include "libavutil/rational.h" #include "libavutil/rational.h"
#include "libavutil/pixfmt.h" #include "libavutil/pixfmt.h"
@ -31,15 +32,16 @@
/** /**
* @addtogroup lavc_core * @addtogroup lavc_core
* @{
*/ */
enum AVFieldOrder { enum AVFieldOrder {
AV_FIELD_UNKNOWN, AV_FIELD_UNKNOWN,
AV_FIELD_PROGRESSIVE, AV_FIELD_PROGRESSIVE,
AV_FIELD_TT, //< Top coded_first, top displayed first AV_FIELD_TT, ///< Top coded_first, top displayed first
AV_FIELD_BB, //< Bottom coded first, bottom displayed first AV_FIELD_BB, ///< Bottom coded first, bottom displayed first
AV_FIELD_TB, //< Top coded first, bottom displayed first AV_FIELD_TB, ///< Top coded first, bottom displayed first
AV_FIELD_BT, //< Bottom coded first, top displayed first AV_FIELD_BT, ///< Bottom coded first, top displayed first
}; };
/** /**
@ -154,16 +156,22 @@ typedef struct AVCodecParameters {
*/ */
int video_delay; int video_delay;
#if FF_API_OLD_CHANNEL_LAYOUT
/** /**
* Audio only. The channel layout bitmask. May be 0 if the channel layout is * Audio only. The channel layout bitmask. May be 0 if the channel layout is
* unknown or unspecified, otherwise the number of bits set must be equal to * unknown or unspecified, otherwise the number of bits set must be equal to
* the channels field. * the channels field.
* @deprecated use ch_layout
*/ */
attribute_deprecated
uint64_t channel_layout; uint64_t channel_layout;
/** /**
* Audio only. The number of audio channels. * Audio only. The number of audio channels.
* @deprecated use ch_layout.nb_channels
*/ */
attribute_deprecated
int channels; int channels;
#endif
/** /**
* Audio only. The number of audio samples per second. * Audio only. The number of audio samples per second.
*/ */
@ -198,6 +206,11 @@ typedef struct AVCodecParameters {
* Audio only. Number of samples to skip after a discontinuity. * Audio only. Number of samples to skip after a discontinuity.
*/ */
int seek_preroll; int seek_preroll;
/**
* Audio only. The channel layout and number of channels.
*/
AVChannelLayout ch_layout;
} AVCodecParameters; } AVCodecParameters;
/** /**

22
src/3rdparty/win32_include/libavcodec/defs.h vendored
View File

@ -39,6 +39,28 @@
*/ */
#define AV_INPUT_BUFFER_PADDING_SIZE 64 #define AV_INPUT_BUFFER_PADDING_SIZE 64
/**
* Verify checksums embedded in the bitstream (could be of either encoded or
* decoded data, depending on the format) and print an error message on mismatch.
* If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
* decoder/demuxer returning an error.
*/
#define AV_EF_CRCCHECK (1<<0)
#define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations
#define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length
#define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection
#define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue
#define AV_EF_CAREFUL (1<<16) ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
#define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors
#define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder/muxer should not do as an error
#define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
#define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
#define FF_COMPLIANCE_NORMAL 0
#define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
/** /**
* @ingroup lavc_decoding * @ingroup lavc_decoding
*/ */

8
src/3rdparty/win32_include/libavcodec/mediacodec.h vendored
View File

@ -88,13 +88,15 @@ int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render);
/** /**
* Release a MediaCodec buffer and render it at the given time to the surface * Release a MediaCodec buffer and render it at the given time to the surface
* that is associated with the decoder. The timestamp must be within one second * that is associated with the decoder. The timestamp must be within one second
* of the current java/lang/System#nanoTime() (which is implemented using * of the current `java/lang/System#nanoTime()` (which is implemented using
* CLOCK_MONOTONIC on Android). See the Android MediaCodec documentation * `CLOCK_MONOTONIC` on Android). See the Android MediaCodec documentation
* of android/media/MediaCodec#releaseOutputBuffer(int,long) for more details. * of [`android/media/MediaCodec#releaseOutputBuffer(int,long)`][0] for more details.
* *
* @param buffer the buffer to render * @param buffer the buffer to render
* @param time timestamp in nanoseconds of when to render the buffer * @param time timestamp in nanoseconds of when to render the buffer
* @return 0 on success, < 0 otherwise * @return 0 on success, < 0 otherwise
*
* [0]: https://developer.android.com/reference/android/media/MediaCodec#releaseOutputBuffer(int,%20long)
*/ */
int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time); int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time);

10
src/3rdparty/win32_include/libavcodec/packet.h vendored
View File

@ -28,8 +28,9 @@
#include "libavutil/buffer.h" #include "libavutil/buffer.h"
#include "libavutil/dict.h" #include "libavutil/dict.h"
#include "libavutil/rational.h" #include "libavutil/rational.h"
#include "libavutil/version.h"
#include "libavcodec/version.h" #include "libavcodec/version_major.h"
/** /**
* @defgroup lavc_packet AVPacket * @defgroup lavc_packet AVPacket
@ -160,7 +161,7 @@ enum AVPacketSideDataType {
* the packet may contain "dual mono" audio specific to Japanese DTV * the packet may contain "dual mono" audio specific to Japanese DTV
* and if it is true, recommends only the selected channel to be used. * and if it is true, recommends only the selected channel to be used.
* @code * @code
* u8 selected channels (0=mail/left, 1=sub/right, 2=both) * u8 selected channels (0=main/left, 1=sub/right, 2=both)
* @endcode * @endcode
*/ */
AV_PKT_DATA_JP_DUALMONO, AV_PKT_DATA_JP_DUALMONO,
@ -447,8 +448,13 @@ typedef struct AVPacketList {
#define AV_PKT_FLAG_DISPOSABLE 0x0010 #define AV_PKT_FLAG_DISPOSABLE 0x0010
enum AVSideDataParamChangeFlags { enum AVSideDataParamChangeFlags {
#if FF_API_OLD_CHANNEL_LAYOUT
/**
* @deprecated those are not used by any decoder
*/
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001, AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002, AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
#endif
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004, AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008, AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
}; };

4
src/3rdparty/win32_include/libavcodec/qsv.h vendored
View File

@ -21,7 +21,7 @@
#ifndef AVCODEC_QSV_H #ifndef AVCODEC_QSV_H
#define AVCODEC_QSV_H #define AVCODEC_QSV_H
#include <mfx/mfxvideo.h> #include <mfxvideo.h>
#include "libavutil/buffer.h" #include "libavutil/buffer.h"
@ -61,6 +61,8 @@ typedef struct AVQSVContext {
* required by the encoder and the user-provided value nb_opaque_surfaces. * required by the encoder and the user-provided value nb_opaque_surfaces.
* The array of the opaque surfaces will be exported to the caller through * The array of the opaque surfaces will be exported to the caller through
* the opaque_surfaces field. * the opaque_surfaces field.
*
* The caller must set this field to zero for oneVPL (MFX_VERSION >= 2.0)
*/ */
int opaque_alloc; int opaque_alloc;

2
src/3rdparty/win32_include/libavcodec/vdpau.h vendored
View File

@ -152,6 +152,6 @@ int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
*/ */
AVVDPAUContext *av_vdpau_alloc_context(void); AVVDPAUContext *av_vdpau_alloc_context(void);
/* @}*/ /** @} */
#endif /* AVCODEC_VDPAU_H */ #endif /* AVCODEC_VDPAU_H */

28
src/3rdparty/win32_include/libavcodec/version.h vendored
View File

@ -27,8 +27,9 @@
#include "libavutil/version.h" #include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 59 #include "version_major.h"
#define LIBAVCODEC_VERSION_MINOR 18
#define LIBAVCODEC_VERSION_MINOR 3
#define LIBAVCODEC_VERSION_MICRO 100 #define LIBAVCODEC_VERSION_MICRO 100
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
@ -41,27 +42,4 @@
#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) #define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
/**
* FF_API_* defines may be placed below to indicate public API that will be
* dropped at a future version bump. The defines themselves are not part of
* the public API and may change, break or disappear at any time.
*
* @note, when bumping the major version it is recommended to manually
* disable each FF_API_* in its own commit instead of disabling them all
* at once through the bump. This improves the git bisect-ability of the change.
*/
#define FF_API_OPENH264_SLICE_MODE (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_OPENH264_CABAC (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_UNUSED_CODEC_CAPS (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_THREAD_SAFE_CALLBACKS (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_GET_FRAME_CLASS (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_AUTO_THREADS (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_MPEGVIDEO_OPTS (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_FLAG_TRUNCATED (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_SUB_TEXT_FORMAT (LIBAVCODEC_VERSION_MAJOR < 60)
#endif /* AVCODEC_VERSION_H */ #endif /* AVCODEC_VERSION_H */

52
src/3rdparty/win32_include/libavcodec/version_major.h vendored Normal file
View File

@ -0,0 +1,52 @@
/*
* 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_VERSION_MAJOR_H
#define AVCODEC_VERSION_MAJOR_H
/**
* @file
* @ingroup libavc
* Libavcodec version macros.
*/
#define LIBAVCODEC_VERSION_MAJOR 60
/**
* FF_API_* defines may be placed below to indicate public API that will be
* dropped at a future version bump. The defines themselves are not part of
* the public API and may change, break or disappear at any time.
*
* @note, when bumping the major version it is recommended to manually
* disable each FF_API_* in its own commit instead of disabling them all
* at once through the bump. This improves the git bisect-ability of the change.
*/
#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_IDCT_NONE (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_SVTAV1_OPTS (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_AYUV_CODECID (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_VT_OUTPUT_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_AVCODEC_CHROMA_POS (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_VT_HWACCEL_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 61)
#define FF_API_AVCTX_FRAME_NUMBER (LIBAVCODEC_VERSION_MAJOR < 61)
// reminder to remove CrystalHD decoders on next major bump
#define FF_CODEC_CRYSTAL_HD (LIBAVCODEC_VERSION_MAJOR < 61)
#endif /* AVCODEC_VERSION_MAJOR_H */

29
src/3rdparty/win32_include/libavcodec/videotoolbox.h vendored
View File

@ -29,6 +29,15 @@
* Public libavcodec Videotoolbox header. * Public libavcodec Videotoolbox header.
*/ */
/**
* @defgroup lavc_codec_hwaccel_videotoolbox VideoToolbox Decoder
* @ingroup lavc_codec_hwaccel
*
* Hardware accelerated decoding using VideoToolbox on Apple Platforms
*
* @{
*/
#include <stdint.h> #include <stdint.h>
#define Picture QuickdrawPicture #define Picture QuickdrawPicture
@ -37,6 +46,8 @@
#include "libavcodec/avcodec.h" #include "libavcodec/avcodec.h"
#include "libavutil/attributes.h"
/** /**
* This struct holds all the information that needs to be passed * This struct holds all the information that needs to be passed
* between the caller and libavcodec for initializing Videotoolbox decoding. * between the caller and libavcodec for initializing Videotoolbox decoding.
@ -46,15 +57,17 @@
typedef struct AVVideotoolboxContext { typedef struct AVVideotoolboxContext {
/** /**
* Videotoolbox decompression session object. * Videotoolbox decompression session object.
* Created and freed the caller.
*/ */
VTDecompressionSessionRef session; VTDecompressionSessionRef session;
#if FF_API_VT_OUTPUT_CALLBACK
/** /**
* The output callback that must be passed to the session. * The output callback that must be passed to the session.
* Set by av_videottoolbox_default_init() * Set by av_videottoolbox_default_init()
*/ */
attribute_deprecated
VTDecompressionOutputCallback output_callback; VTDecompressionOutputCallback output_callback;
#endif
/** /**
* CVPixelBuffer Format Type that Videotoolbox will use for decoded frames. * CVPixelBuffer Format Type that Videotoolbox will use for decoded frames.
@ -65,17 +78,17 @@ typedef struct AVVideotoolboxContext {
/** /**
* CoreMedia Format Description that Videotoolbox will use to create the decompression session. * CoreMedia Format Description that Videotoolbox will use to create the decompression session.
* Set by the caller.
*/ */
CMVideoFormatDescriptionRef cm_fmt_desc; CMVideoFormatDescriptionRef cm_fmt_desc;
/** /**
* CoreMedia codec type that Videotoolbox will use to create the decompression session. * CoreMedia codec type that Videotoolbox will use to create the decompression session.
* Set by the caller.
*/ */
int cm_codec_type; int cm_codec_type;
} AVVideotoolboxContext; } AVVideotoolboxContext;
#if FF_API_VT_HWACCEL_CONTEXT
/** /**
* Allocate and initialize a Videotoolbox context. * Allocate and initialize a Videotoolbox context.
* *
@ -88,7 +101,9 @@ typedef struct AVVideotoolboxContext {
* object and free the Videotoolbox context using av_free(). * object and free the Videotoolbox context using av_free().
* *
* @return the newly allocated context or NULL on failure * @return the newly allocated context or NULL on failure
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
*/ */
attribute_deprecated
AVVideotoolboxContext *av_videotoolbox_alloc_context(void); AVVideotoolboxContext *av_videotoolbox_alloc_context(void);
/** /**
@ -98,7 +113,9 @@ AVVideotoolboxContext *av_videotoolbox_alloc_context(void);
* @param avctx the corresponding codec context * @param avctx the corresponding codec context
* *
* @return >= 0 on success, a negative AVERROR code on failure * @return >= 0 on success, a negative AVERROR code on failure
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
*/ */
attribute_deprecated
int av_videotoolbox_default_init(AVCodecContext *avctx); int av_videotoolbox_default_init(AVCodecContext *avctx);
/** /**
@ -109,7 +126,9 @@ int av_videotoolbox_default_init(AVCodecContext *avctx);
* @param vtctx the Videotoolbox context to use * @param vtctx the Videotoolbox context to use
* *
* @return >= 0 on success, a negative AVERROR code on failure * @return >= 0 on success, a negative AVERROR code on failure
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
*/ */
attribute_deprecated
int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *vtctx); int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *vtctx);
/** /**
@ -117,9 +136,13 @@ int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *
* av_videotoolbox_default_init(). * av_videotoolbox_default_init().
* *
* @param avctx the corresponding codec context * @param avctx the corresponding codec context
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
*/ */
attribute_deprecated
void av_videotoolbox_default_free(AVCodecContext *avctx); void av_videotoolbox_default_free(AVCodecContext *avctx);
#endif /* FF_API_VT_HWACCEL_CONTEXT */
/** /**
* @} * @}
*/ */

3
src/3rdparty/win32_include/libavcodec/xvmc.h vendored
View File

@ -27,10 +27,11 @@
* Public libavcodec XvMC header. * Public libavcodec XvMC header.
*/ */
#pragma message("XvMC is no longer supported; this header is deprecated and will be removed")
#include <X11/extensions/XvMC.h> #include <X11/extensions/XvMC.h>
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "version.h"
#include "avcodec.h" #include "avcodec.h"
/** /**

337
src/3rdparty/win32_include/libavformat/avformat.h vendored
View File

@ -319,13 +319,17 @@
#include "libavutil/log.h" #include "libavutil/log.h"
#include "avio.h" #include "avio.h"
#include "libavformat/version_major.h"
#ifndef HAVE_AV_CONFIG_H
/* When included as part of the ffmpeg build, only include the major version
* to avoid unnecessary rebuilds. When included externally, keep including
* the full version information. */
#include "libavformat/version.h" #include "libavformat/version.h"
#endif
struct AVFormatContext; struct AVFormatContext;
struct AVStream;
struct AVDeviceInfoList; struct AVDeviceInfoList;
struct AVDeviceCapabilitiesQuery;
/** /**
* @defgroup metadata_api Public Metadata API * @defgroup metadata_api Public Metadata API
@ -530,114 +534,6 @@ typedef struct AVOutputFormat {
const AVClass *priv_class; ///< AVClass for the private context const AVClass *priv_class; ///< AVClass for the private context
/*****************************************************************
* No fields below this line are part of the public API. They
* may not be used outside of libavformat and can be changed and
* removed at will.
* New public fields should be added right above.
*****************************************************************
*/
/**
* size of private data so that it can be allocated in the wrapper
*/
int priv_data_size;
/**
* Internal flags. See FF_FMT_FLAG_* in internal.h.
*/
int flags_internal;
int (*write_header)(struct AVFormatContext *);
/**
* Write a packet. If AVFMT_ALLOW_FLUSH is set in flags,
* pkt can be NULL in order to flush data buffered in the muxer.
* When flushing, return 0 if there still is more data to flush,
* or 1 if everything was flushed and there is no more buffered
* data.
*/
int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
int (*write_trailer)(struct AVFormatContext *);
/**
* A format-specific function for interleavement.
* If unset, packets will be interleaved by dts.
*
* @param s An AVFormatContext for output. pkt will be added to
* resp. taken from its packet buffer.
* @param[in,out] pkt A packet to be interleaved if has_packet is set;
* also used to return packets. If no packet is returned
* (e.g. on error), pkt is blank on return.
* @param flush 1 if no further packets are available as input and
* all remaining packets should be output.
* @param has_packet If set, pkt contains a packet to be interleaved
* on input; otherwise pkt is blank on input.
* @return 1 if a packet was output, 0 if no packet could be output,
* < 0 if an error occurred
*/
int (*interleave_packet)(struct AVFormatContext *s, AVPacket *pkt,
int flush, int has_packet);
/**
* Test if the given codec can be stored in this container.
*
* @return 1 if the codec is supported, 0 if it is not.
* A negative number if unknown.
* MKTAG('A', 'P', 'I', 'C') if the codec is only supported as AV_DISPOSITION_ATTACHED_PIC
*/
int (*query_codec)(enum AVCodecID id, int std_compliance);
void (*get_output_timestamp)(struct AVFormatContext *s, int stream,
int64_t *dts, int64_t *wall);
/**
* Allows sending messages from application to device.
*/
int (*control_message)(struct AVFormatContext *s, int type,
void *data, size_t data_size);
/**
* Write an uncoded AVFrame.
*
* See av_write_uncoded_frame() for details.
*
* The library will free *frame afterwards, but the muxer can prevent it
* by setting the pointer to NULL.
*/
int (*write_uncoded_frame)(struct AVFormatContext *, int stream_index,
AVFrame **frame, unsigned flags);
/**
* Returns device list with it properties.
* @see avdevice_list_devices() for more details.
*/
int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
enum AVCodecID data_codec; /**< default data codec */
/**
* Initialize format. May allocate data here, and set any AVFormatContext or
* AVStream parameters that need to be set before packets are sent.
* This method must not write output.
*
* Return 0 if streams were fully configured, 1 if not, negative AVERROR on failure
*
* Any allocations made here must be freed in deinit().
*/
int (*init)(struct AVFormatContext *);
/**
* Deinitialize format. If present, this is called whenever the muxer is being
* destroyed, regardless of whether or not the header has been written.
*
* If a trailer is being written, this is called after write_trailer().
*
* This is called if init() fails as well.
*/
void (*deinit)(struct AVFormatContext *);
/**
* Set up any necessary bitstream filtering and extract any extra data needed
* for the global header.
*
* @note pkt might have been directly forwarded by a meta-muxer; therefore
* pkt->stream_index as well as the pkt's timebase might be invalid.
* Return 0 if more packets from this stream must be checked; 1 if not.
*/
int (*check_bitstream)(struct AVFormatContext *s, struct AVStream *st,
const AVPacket *pkt);
} AVOutputFormat; } AVOutputFormat;
/** /**
* @} * @}
@ -879,6 +775,13 @@ typedef struct AVIndexEntry {
*/ */
#define AV_DISPOSITION_TIMED_THUMBNAILS (1 << 11) #define AV_DISPOSITION_TIMED_THUMBNAILS (1 << 11)
/**
* The stream is intended to be mixed with a spatial audio track. For example,
* it could be used for narration or stereo music, and may remain unchanged by
* listener head rotation.
*/
#define AV_DISPOSITION_NON_DIEGETIC (1 << 12)
/** /**
* The subtitle stream contains captions, providing a transcription and possibly * The subtitle stream contains captions, providing a transcription and possibly
* a translation of audio. Typically intended for hearing-impaired audiences. * a translation of audio. Typically intended for hearing-impaired audiences.
@ -935,12 +838,10 @@ const char *av_disposition_to_string(int disposition);
* sizeof(AVStream) must not be used outside libav*. * sizeof(AVStream) must not be used outside libav*.
*/ */
typedef struct AVStream { typedef struct AVStream {
#if FF_API_AVSTREAM_CLASS
/** /**
* A class for @ref avoptions. Set on stream creation. * A class for @ref avoptions. Set on stream creation.
*/ */
const AVClass *av_class; const AVClass *av_class;
#endif
int index; /**< stream index in AVFormatContext */ int index; /**< stream index in AVFormatContext */
/** /**
@ -950,6 +851,17 @@ typedef struct AVStream {
*/ */
int id; int id;
/**
* Codec parameters associated with this stream. Allocated and freed by
* libavformat in avformat_new_stream() and avformat_free_context()
* respectively.
*
* - demuxing: filled by libavformat on stream creation or in
* avformat_find_stream_info()
* - muxing: filled by the caller before avformat_write_header()
*/
AVCodecParameters *codecpar;
void *priv_data; void *priv_data;
/** /**
@ -1085,17 +997,6 @@ typedef struct AVStream {
*/ */
AVRational r_frame_rate; AVRational r_frame_rate;
/**
* Codec parameters associated with this stream. Allocated and freed by
* libavformat in avformat_new_stream() and avformat_free_context()
* respectively.
*
* - demuxing: filled by libavformat on stream creation or in
* avformat_find_stream_info()
* - muxing: filled by the caller before avformat_write_header()
*/
AVCodecParameters *codecpar;
/** /**
* Number of bits in timestamps. Used for wrapping control. * Number of bits in timestamps. Used for wrapping control.
* *
@ -1108,12 +1009,15 @@ typedef struct AVStream {
struct AVCodecParserContext *av_stream_get_parser(const AVStream *s); struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
#if FF_API_GET_END_PTS
/** /**
* Returns the pts of the last muxed packet + its duration * Returns the pts of the last muxed packet + its duration
* *
* the retuned value is undefined when used with a demuxer. * the retuned value is undefined when used with a demuxer.
*/ */
attribute_deprecated
int64_t av_stream_get_end_pts(const AVStream *st); int64_t av_stream_get_end_pts(const AVStream *st);
#endif
#define AV_PROGRAM_RUNNING 1 #define AV_PROGRAM_RUNNING 1
@ -1336,9 +1240,6 @@ typedef struct AVFormatContext {
*/ */
#define AVFMT_FLAG_BITEXACT 0x0400 #define AVFMT_FLAG_BITEXACT 0x0400
#define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down) #define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
#if FF_API_LAVF_PRIV_OPT
#define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (deprecated, does nothing)
#endif
#define AVFMT_FLAG_FAST_SEEK 0x80000 ///< Enable fast, but inaccurate seeks for some formats #define AVFMT_FLAG_FAST_SEEK 0x80000 ///< Enable fast, but inaccurate seeks for some formats
#define AVFMT_FLAG_SHORTEST 0x100000 ///< Stop muxing when the shortest stream stops. #define AVFMT_FLAG_SHORTEST 0x100000 ///< Stop muxing when the shortest stream stops.
#define AVFMT_FLAG_AUTO_BSF 0x200000 ///< Add bitstream filters as requested by the muxer #define AVFMT_FLAG_AUTO_BSF 0x200000 ///< Add bitstream filters as requested by the muxer
@ -1527,12 +1428,13 @@ typedef struct AVFormatContext {
/** /**
* Avoid negative timestamps during muxing. * Avoid negative timestamps during muxing.
* Any value of the AVFMT_AVOID_NEG_TS_* constants. * Any value of the AVFMT_AVOID_NEG_TS_* constants.
* Note, this only works when using av_interleaved_write_frame. (interleave_packet_per_dts is in use) * Note, this works better when using av_interleaved_write_frame().
* - muxing: Set by user * - muxing: Set by user
* - demuxing: unused * - demuxing: unused
*/ */
int avoid_negative_ts; int avoid_negative_ts;
#define AVFMT_AVOID_NEG_TS_AUTO -1 ///< Enabled when required by target format #define AVFMT_AVOID_NEG_TS_AUTO -1 ///< Enabled when required by target format
#define AVFMT_AVOID_NEG_TS_DISABLED 0 ///< Do not shift timestamps even when they are negative.
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE 1 ///< Shift timestamps so they are non negative #define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE 1 ///< Shift timestamps so they are non negative
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO 2 ///< Shift timestamps so that they start at 0 #define AVFMT_AVOID_NEG_TS_MAKE_ZERO 2 ///< Shift timestamps so that they start at 0
@ -1761,10 +1663,15 @@ typedef struct AVFormatContext {
int (*io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int (*io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url,
int flags, AVDictionary **options); int flags, AVDictionary **options);
#if FF_API_AVFORMAT_IO_CLOSE
/** /**
* A callback for closing the streams opened with AVFormatContext.io_open(). * A callback for closing the streams opened with AVFormatContext.io_open().
*
* @deprecated use io_close2
*/ */
attribute_deprecated
void (*io_close)(struct AVFormatContext *s, AVIOContext *pb); void (*io_close)(struct AVFormatContext *s, AVIOContext *pb);
#endif
/** /**
* ',' separated list of disallowed protocols. * ',' separated list of disallowed protocols.
@ -1881,8 +1788,8 @@ const AVOutputFormat *av_muxer_iterate(void **opaque);
/** /**
* Iterate over all registered demuxers. * Iterate over all registered demuxers.
* *
* @param opaque a pointer where libavformat will store the iteration state. Must * @param opaque a pointer where libavformat will store the iteration state.
* point to NULL to start the iteration. * Must point to NULL to start the iteration.
* *
* @return the next registered demuxer or NULL when the iteration is * @return the next registered demuxer or NULL when the iteration is
* finished * finished
@ -1940,12 +1847,13 @@ AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c);
/** /**
* Wrap an existing array as stream side data. * Wrap an existing array as stream side data.
* *
* @param st stream * @param st stream
* @param type side information type * @param type side information type
* @param data the side data array. It must be allocated with the av_malloc() * @param data the side data array. It must be allocated with the av_malloc()
* family of functions. The ownership of the data is transferred to * family of functions. The ownership of the data is transferred to
* st. * st.
* @param size side information size * @param size side information size
*
* @return zero on success, a negative AVERROR code on failure. On failure, * @return zero on success, a negative AVERROR code on failure. On failure,
* the stream is unchanged and the data remains owned by the caller. * the stream is unchanged and the data remains owned by the caller.
*/ */
@ -1956,8 +1864,9 @@ int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
* Allocate new information from stream. * Allocate new information from stream.
* *
* @param stream stream * @param stream stream
* @param type desired side information type * @param type desired side information type
* @param size side information size * @param size side information size
*
* @return pointer to fresh allocated data or NULL otherwise * @return pointer to fresh allocated data or NULL otherwise
*/ */
uint8_t *av_stream_new_side_data(AVStream *stream, uint8_t *av_stream_new_side_data(AVStream *stream,
@ -1966,9 +1875,10 @@ uint8_t *av_stream_new_side_data(AVStream *stream,
* Get side information from stream. * Get side information from stream.
* *
* @param stream stream * @param stream stream
* @param type desired side information type * @param type desired side information type
* @param size If supplied, *size will be set to the size of the side data * @param size If supplied, *size will be set to the size of the side data
* or to zero if the desired side data is not present. * or to zero if the desired side data is not present.
*
* @return pointer to data if present or NULL otherwise * @return pointer to data if present or NULL otherwise
*/ */
uint8_t *av_stream_get_side_data(const AVStream *stream, uint8_t *av_stream_get_side_data(const AVStream *stream,
@ -1986,16 +1896,17 @@ AVProgram *av_new_program(AVFormatContext *s, int id);
* avformat_free_context() can be used to free the context and * avformat_free_context() can be used to free the context and
* everything allocated by the framework within it. * everything allocated by the framework within it.
* *
* @param *ctx is set to the created format context, or to NULL in * @param ctx pointee is set to the created format context,
* case of failure * or to NULL in case of failure
* @param oformat format to use for allocating the context, if NULL * @param oformat format to use for allocating the context, if NULL
* format_name and filename are used instead * format_name and filename are used instead
* @param format_name the name of output format to use for allocating the * @param format_name the name of output format to use for allocating the
* context, if NULL filename is used instead * context, if NULL filename is used instead
* @param filename the name of the filename to use for allocating the * @param filename the name of the filename to use for allocating the
* context, may be NULL * context, may be NULL
* @return >= 0 in case of success, a negative AVERROR code in case of *
* failure * @return >= 0 in case of success, a negative AVERROR code in case of
* failure
*/ */
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat,
const char *format_name, const char *filename); const char *format_name, const char *filename);
@ -2050,15 +1961,16 @@ const AVInputFormat *av_probe_input_format3(const AVProbeData *pd,
* attempt is made. When the maximum probe size is reached, the input format * attempt is made. When the maximum probe size is reached, the input format
* with the highest score is returned. * with the highest score is returned.
* *
* @param pb the bytestream to probe * @param pb the bytestream to probe
* @param fmt the input format is put here * @param fmt the input format is put here
* @param url the url of the stream * @param url the url of the stream
* @param logctx the log context * @param logctx the log context
* @param offset the offset within the bytestream to probe from * @param offset the offset within the bytestream to probe from
* @param max_probe_size the maximum probe buffer size (zero for default) * @param max_probe_size the maximum probe buffer size (zero for default)
*
* @return the score in case of success, a negative value corresponding to an * @return the score in case of success, a negative value corresponding to an
* the maximal score is AVPROBE_SCORE_MAX * the maximal score is AVPROBE_SCORE_MAX
* AVERROR code otherwise * AVERROR code otherwise
*/ */
int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt, int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt,
const char *url, void *logctx, const char *url, void *logctx,
@ -2075,16 +1987,19 @@ int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt,
* Open an input stream and read the header. The codecs are not opened. * Open an input stream and read the header. The codecs are not opened.
* The stream must be closed with avformat_close_input(). * The stream must be closed with avformat_close_input().
* *
* @param ps Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context). * @param ps Pointer to user-supplied AVFormatContext (allocated by
* May be a pointer to NULL, in which case an AVFormatContext is allocated by this * avformat_alloc_context). May be a pointer to NULL, in
* function and written into ps. * which case an AVFormatContext is allocated by this
* Note that a user-supplied AVFormatContext will be freed on failure. * function and written into ps.
* @param url URL of the stream to open. * Note that a user-supplied AVFormatContext will be freed
* @param fmt If non-NULL, this parameter forces a specific input format. * on failure.
* Otherwise the format is autodetected. * @param url URL of the stream to open.
* @param options A dictionary filled with AVFormatContext and demuxer-private options. * @param fmt If non-NULL, this parameter forces a specific input format.
* On return this parameter will be destroyed and replaced with a dict containing * Otherwise the format is autodetected.
* options that were not found. May be NULL. * @param options A dictionary filled with AVFormatContext and demuxer-private
* options.
* On return this parameter will be destroyed and replaced with
* a dict containing options that were not found. May be NULL.
* *
* @return 0 on success, a negative AVERROR on failure. * @return 0 on success, a negative AVERROR on failure.
* *
@ -2123,6 +2038,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
* @param last the last found program, the search will start after this * @param last the last found program, the search will start after this
* program, or from the beginning if it is NULL * program, or from the beginning if it is NULL
* @param s stream index * @param s stream index
*
* @return the next program which belongs to s, NULL if no program is found or * @return the next program which belongs to s, NULL if no program is found or
* the last program is not among the programs of ic. * the last program is not among the programs of ic.
*/ */
@ -2147,10 +2063,12 @@ void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int i
* @param decoder_ret if non-NULL, returns the decoder for the * @param decoder_ret if non-NULL, returns the decoder for the
* selected stream * selected stream
* @param flags flags; none are currently defined * @param flags flags; none are currently defined
*
* @return the non-negative stream number in case of success, * @return the non-negative stream number in case of success,
* AVERROR_STREAM_NOT_FOUND if no stream with the requested type * AVERROR_STREAM_NOT_FOUND if no stream with the requested type
* could be found, * could be found,
* AVERROR_DECODER_NOT_FOUND if streams were found but no decoder * AVERROR_DECODER_NOT_FOUND if streams were found but no decoder
*
* @note If av_find_best_stream returns successfully and decoder_ret is not * @note If av_find_best_stream returns successfully and decoder_ret is not
* NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec. * NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec.
*/ */
@ -2194,13 +2112,14 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt);
* Seek to the keyframe at timestamp. * Seek to the keyframe at timestamp.
* 'timestamp' in 'stream_index'. * 'timestamp' in 'stream_index'.
* *
* @param s media file handle * @param s media file handle
* @param stream_index If stream_index is (-1), a default * @param stream_index If stream_index is (-1), a default stream is selected,
* stream is selected, and timestamp is automatically converted * and timestamp is automatically converted from
* from AV_TIME_BASE units to the stream specific time_base. * AV_TIME_BASE units to the stream specific time_base.
* @param timestamp Timestamp in AVStream.time_base units * @param timestamp Timestamp in AVStream.time_base units or, if no stream
* or, if no stream is specified, in AV_TIME_BASE units. * is specified, in AV_TIME_BASE units.
* @param flags flags which select direction and seeking mode * @param flags flags which select direction and seeking mode
*
* @return >= 0 on success * @return >= 0 on success
*/ */
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
@ -2222,12 +2141,12 @@ int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
* keyframes (this may not be supported by all demuxers). * keyframes (this may not be supported by all demuxers).
* If flags contain AVSEEK_FLAG_BACKWARD, it is ignored. * If flags contain AVSEEK_FLAG_BACKWARD, it is ignored.
* *
* @param s media file handle * @param s media file handle
* @param stream_index index of the stream which is used as time base reference * @param stream_index index of the stream which is used as time base reference
* @param min_ts smallest acceptable timestamp * @param min_ts smallest acceptable timestamp
* @param ts target timestamp * @param ts target timestamp
* @param max_ts largest acceptable timestamp * @param max_ts largest acceptable timestamp
* @param flags flags * @param flags flags
* @return >=0 on success, error code otherwise * @return >=0 on success, error code otherwise
* *
* @note This is part of the new seek API which is still under construction. * @note This is part of the new seek API which is still under construction.
@ -2291,16 +2210,22 @@ void avformat_close_input(AVFormatContext **s);
* Allocate the stream private data and write the stream header to * Allocate the stream private data and write the stream header to
* an output media file. * an output media file.
* *
* @param s Media file handle, must be allocated with avformat_alloc_context(). * @param s Media file handle, must be allocated with
* Its oformat field must be set to the desired output format; * avformat_alloc_context().
* Its pb field must be set to an already opened AVIOContext. * Its \ref AVFormatContext.oformat "oformat" field must be set
* @param options An AVDictionary filled with AVFormatContext and muxer-private options. * to the desired output format;
* On return this parameter will be destroyed and replaced with a dict containing * Its \ref AVFormatContext.pb "pb" field must be set to an
* options that were not found. May be NULL. * already opened ::AVIOContext.
* @param options An ::AVDictionary filled with AVFormatContext and
* muxer-private options.
* On return this parameter will be destroyed and replaced with
* a dict containing options that were not found. May be NULL.
* *
* @return AVSTREAM_INIT_IN_WRITE_HEADER on success if the codec had not already been fully initialized in avformat_init, * @retval AVSTREAM_INIT_IN_WRITE_HEADER On success, if the codec had not already been
* AVSTREAM_INIT_IN_INIT_OUTPUT on success if the codec had already been fully initialized in avformat_init, * fully initialized in avformat_init_output().
* negative AVERROR on failure. * @retval AVSTREAM_INIT_IN_INIT_OUTPUT On success, if the codec had already been fully
* initialized in avformat_init_output().
* @retval AVERROR A negative AVERROR on failure.
* *
* @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_init_output. * @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_init_output.
*/ */
@ -2309,20 +2234,26 @@ int avformat_write_header(AVFormatContext *s, AVDictionary **options);
/** /**
* Allocate the stream private data and initialize the codec, but do not write the header. * Allocate the stream private data and initialize the codec, but do not write the header.
* May optionally be used before avformat_write_header to initialize stream parameters * May optionally be used before avformat_write_header() to initialize stream parameters
* before actually writing the header. * before actually writing the header.
* If using this function, do not pass the same options to avformat_write_header. * If using this function, do not pass the same options to avformat_write_header().
* *
* @param s Media file handle, must be allocated with avformat_alloc_context(). * @param s Media file handle, must be allocated with
* Its oformat field must be set to the desired output format; * avformat_alloc_context().
* Its pb field must be set to an already opened AVIOContext. * Its \ref AVFormatContext.oformat "oformat" field must be set
* @param options An AVDictionary filled with AVFormatContext and muxer-private options. * to the desired output format;
* On return this parameter will be destroyed and replaced with a dict containing * Its \ref AVFormatContext.pb "pb" field must be set to an
* options that were not found. May be NULL. * already opened ::AVIOContext.
* @param options An ::AVDictionary filled with AVFormatContext and
* muxer-private options.
* On return this parameter will be destroyed and replaced with
* a dict containing options that were not found. May be NULL.
* *
* @return AVSTREAM_INIT_IN_WRITE_HEADER on success if the codec requires avformat_write_header to fully initialize, * @retval AVSTREAM_INIT_IN_WRITE_HEADER On success, if the codec requires
* AVSTREAM_INIT_IN_INIT_OUTPUT on success if the codec has been fully initialized, * avformat_write_header to fully initialize.
* negative AVERROR on failure. * @retval AVSTREAM_INIT_IN_INIT_OUTPUT On success, if the codec has been fully
* initialized.
* @retval AVERROR Anegative AVERROR on failure.
* *
* @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_write_header. * @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_write_header.
*/ */
@ -2467,11 +2398,11 @@ int av_write_trailer(AVFormatContext *s);
* there is no match. * there is no match.
* *
* @param short_name if non-NULL checks if short_name matches with the * @param short_name if non-NULL checks if short_name matches with the
* names of the registered formats * names of the registered formats
* @param filename if non-NULL checks if filename terminates with the * @param filename if non-NULL checks if filename terminates with the
* extensions of the registered formats * extensions of the registered formats
* @param mime_type if non-NULL checks if mime_type matches with the * @param mime_type if non-NULL checks if mime_type matches with the
* MIME type of the registered formats * MIME type of the registered formats
*/ */
const AVOutputFormat *av_guess_format(const char *short_name, const AVOutputFormat *av_guess_format(const char *short_name,
const char *filename, const char *filename,
@ -2495,9 +2426,11 @@ enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
* time_base units * time_base units
* @param[out] wall absolute time when that packet whas output, * @param[out] wall absolute time when that packet whas output,
* in microsecond * in microsecond
* @return 0 if OK, AVERROR(ENOSYS) if the format does not support it * @retval 0 Success
* Note: some formats or devices may not allow to measure dts and wall * @retval AVERROR(ENOSYS) The format does not support it
* atomically. *
* @note Some formats or devices may not allow to measure dts and wall
* atomically.
*/ */
int av_get_output_timestamp(struct AVFormatContext *s, int stream, int av_get_output_timestamp(struct AVFormatContext *s, int stream,
int64_t *dts, int64_t *wall); int64_t *dts, int64_t *wall);
@ -2639,7 +2572,7 @@ const AVIndexEntry *avformat_index_get_entry(AVStream *st, int idx);
* Get the AVIndexEntry corresponding to the given timestamp. * Get the AVIndexEntry corresponding to the given timestamp.
* *
* @param st Stream containing the requested AVIndexEntry. * @param st Stream containing the requested AVIndexEntry.
* @param timestamp Timestamp to retrieve the index entry for. * @param wanted_timestamp Timestamp to retrieve the index entry for.
* @param flags If AVSEEK_FLAG_BACKWARD then the returned entry will correspond * @param flags If AVSEEK_FLAG_BACKWARD then the returned entry will correspond
* to the timestamp which is <= the requested one, if backward * to the timestamp which is <= the requested one, if backward
* is 0, then it will be >= * is 0, then it will be >=

26
src/3rdparty/win32_include/libavformat/avio.h vendored
View File

@ -27,12 +27,13 @@
*/ */
#include <stdint.h> #include <stdint.h>
#include <stdio.h>
#include "libavutil/common.h" #include "libavutil/attributes.h"
#include "libavutil/dict.h" #include "libavutil/dict.h"
#include "libavutil/log.h" #include "libavutil/log.h"
#include "libavformat/version.h" #include "libavformat/version_major.h"
/** /**
* Seeking works like for a local file. * Seeking works like for a local file.
@ -100,9 +101,13 @@ typedef struct AVIODirEntry {
int64_t filemode; /**< Unix file mode, -1 if unknown. */ int64_t filemode; /**< Unix file mode, -1 if unknown. */
} AVIODirEntry; } AVIODirEntry;
#if FF_API_AVIODIRCONTEXT
typedef struct AVIODirContext { typedef struct AVIODirContext {
struct URLContext *url_context; struct URLContext *url_context;
} AVIODirContext; } AVIODirContext;
#else
typedef struct AVIODirContext AVIODirContext;
#endif
/** /**
* Different data types that can be returned via the AVIO * Different data types that can be returned via the AVIO
@ -290,16 +295,6 @@ typedef struct AVIOContext {
*/ */
int ignore_boundary_point; int ignore_boundary_point;
#if FF_API_AVIOCONTEXT_WRITTEN
/**
* @deprecated field utilized privately by libavformat. For a public
* statistic of how many bytes were written out, see
* AVIOContext::bytes_written.
*/
attribute_deprecated
int64_t written;
#endif
/** /**
* Maximum reached position before a backward seek in the write buffer, * Maximum reached position before a backward seek in the write buffer,
* used keeping track of already written data for a later flush. * used keeping track of already written data for a later flush.
@ -463,6 +458,7 @@ int avio_put_str16be(AVIOContext *s, const char *str);
* *
* Zero-length ranges are omitted from the output. * Zero-length ranges are omitted from the output.
* *
* @param s the AVIOContext
* @param time the stream time the current bytestream pos corresponds to * @param time the stream time the current bytestream pos corresponds to
* (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not * (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not
* applicable * applicable
@ -518,6 +514,12 @@ int64_t avio_size(AVIOContext *s);
*/ */
int avio_feof(AVIOContext *s); int avio_feof(AVIOContext *s);
/**
* Writes a formatted string to the context taking a va_list.
* @return number of bytes written, < 0 on error.
*/
int avio_vprintf(AVIOContext *s, const char *fmt, va_list ap);
/** /**
* Writes a formatted string to the context. * Writes a formatted string to the context.
* @return number of bytes written, < 0 on error. * @return number of bytes written, < 0 on error.

26
src/3rdparty/win32_include/libavformat/version.h vendored
View File

@ -29,10 +29,9 @@
#include "libavutil/version.h" #include "libavutil/version.h"
// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium) #include "version_major.h"
// Also please add any ticket numbers that you believe might be affected here
#define LIBAVFORMAT_VERSION_MAJOR 59 #define LIBAVFORMAT_VERSION_MINOR 3
#define LIBAVFORMAT_VERSION_MINOR 16
#define LIBAVFORMAT_VERSION_MICRO 100 #define LIBAVFORMAT_VERSION_MICRO 100
#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
@ -45,23 +44,4 @@
#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION) #define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
/**
* FF_API_* defines may be placed below to indicate public API that will be
* dropped at a future version bump. The defines themselves are not part of
* the public API and may change, break or disappear at any time.
*
* @note, when bumping the major version it is recommended to manually
* disable each FF_API_* in its own commit instead of disabling them all
* at once through the bump. This improves the git bisect-ability of the change.
*
*/
#define FF_API_LAVF_PRIV_OPT (LIBAVFORMAT_VERSION_MAJOR < 60)
#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 60)
#define FF_API_AVIOCONTEXT_WRITTEN (LIBAVFORMAT_VERSION_MAJOR < 60)
#define FF_HLS_TS_OPTIONS (LIBAVFORMAT_VERSION_MAJOR < 60)
#define FF_API_AVSTREAM_CLASS (LIBAVFORMAT_VERSION_MAJOR > 59)
#define FF_HTTP_CACHE_REDIRECT_DEFAULT (LIBAVFORMAT_VERSION_MAJOR < 60)
#define FF_API_R_FRAME_RATE 1
#endif /* AVFORMAT_VERSION_H */ #endif /* AVFORMAT_VERSION_H */

52
src/3rdparty/win32_include/libavformat/version_major.h vendored Normal file
View File

@ -0,0 +1,52 @@
/*
* Version macros.
*
* 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 AVFORMAT_VERSION_MAJOR_H
#define AVFORMAT_VERSION_MAJOR_H
/**
* @file
* @ingroup libavf
* Libavformat version macros
*/
// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
// Also please add any ticket numbers that you believe might be affected here
#define LIBAVFORMAT_VERSION_MAJOR 60
/**
* FF_API_* defines may be placed below to indicate public API that will be
* dropped at a future version bump. The defines themselves are not part of
* the public API and may change, break or disappear at any time.
*
* @note, when bumping the major version it is recommended to manually
* disable each FF_API_* in its own commit instead of disabling them all
* at once through the bump. This improves the git bisect-ability of the change.
*
*/
#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 61)
#define FF_API_GET_END_PTS (LIBAVFORMAT_VERSION_MAJOR < 61)
#define FF_API_AVIODIRCONTEXT (LIBAVFORMAT_VERSION_MAJOR < 61)
#define FF_API_AVFORMAT_IO_CLOSE (LIBAVFORMAT_VERSION_MAJOR < 61)
#define FF_API_R_FRAME_RATE 1
#endif /* AVFORMAT_VERSION_MAJOR_H */

7
src/3rdparty/win32_include/libavutil/aes.h vendored
View File

@ -42,6 +42,9 @@ struct AVAES *av_aes_alloc(void);
/** /**
* Initialize an AVAES context. * Initialize an AVAES context.
*
* @param a The AVAES context
* @param key Pointer to the key
* @param key_bits 128, 192 or 256 * @param key_bits 128, 192 or 256
* @param decrypt 0 for encryption, 1 for decryption * @param decrypt 0 for encryption, 1 for decryption
*/ */
@ -49,9 +52,11 @@ int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt);
/** /**
* Encrypt or decrypt a buffer using a previously initialized context. * Encrypt or decrypt a buffer using a previously initialized context.
* @param count number of 16 byte blocks *
* @param a The AVAES context
* @param dst destination array, can be equal to src * @param dst destination array, can be equal to src
* @param src source array, can be equal to dst * @param src source array, can be equal to dst
* @param count number of 16 byte blocks
* @param iv initialization vector for CBC mode, if NULL then ECB will be used * @param iv initialization vector for CBC mode, if NULL then ECB will be used
* @param decrypt 0 for encryption, 1 for decryption * @param decrypt 0 for encryption, 1 for decryption
*/ */

12
src/3rdparty/win32_include/libavutil/aes_ctr.h vendored
View File

@ -22,6 +22,12 @@
#ifndef AVUTIL_AES_CTR_H #ifndef AVUTIL_AES_CTR_H
#define AVUTIL_AES_CTR_H #define AVUTIL_AES_CTR_H
/**
* @defgroup lavu_aes_ctr AES-CTR
* @ingroup lavu_crypto
* @{
*/
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
@ -38,17 +44,23 @@ struct AVAESCTR *av_aes_ctr_alloc(void);
/** /**
* Initialize an AVAESCTR context. * Initialize an AVAESCTR context.
*
* @param a The AVAESCTR context to initialize
* @param key encryption key, must have a length of AES_CTR_KEY_SIZE * @param key encryption key, must have a length of AES_CTR_KEY_SIZE
*/ */
int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key); int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key);
/** /**
* Release an AVAESCTR context. * Release an AVAESCTR context.
*
* @param a The AVAESCTR context
*/ */
void av_aes_ctr_free(struct AVAESCTR *a); void av_aes_ctr_free(struct AVAESCTR *a);
/** /**
* Process a buffer using a previously initialized context. * Process a buffer using a previously initialized context.
*
* @param a The AVAESCTR context
* @param dst destination array, can be equal to src * @param dst destination array, can be equal to src
* @param src source array, can be equal to dst * @param src source array, can be equal to dst
* @param size the size of src and dst * @param size the size of src and dst

72
src/3rdparty/win32_include/libavutil/ambient_viewing_environment.h vendored Normal file
View File

@ -0,0 +1,72 @@
/*
* Copyright (c) 2023 Jan Ekström <jeebjp@gmail.com>
*
* 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 AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H
#define AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H
#include <stddef.h>
#include "frame.h"
#include "rational.h"
/**
* Ambient viewing environment metadata as defined by H.274. The values are
* saved in AVRationals so that they keep their exactness, while allowing for
* easy access to a double value with f.ex. av_q2d.
*
* @note sizeof(AVAmbientViewingEnvironment) is not part of the public ABI, and
* it must be allocated using av_ambient_viewing_environment_alloc.
*/
typedef struct AVAmbientViewingEnvironment {
/**
* Environmental illuminance of the ambient viewing environment in lux.
*/
AVRational ambient_illuminance;
/**
* Normalized x chromaticity coordinate of the environmental ambient light
* in the nominal viewing environment according to the CIE 1931 definition
* of x and y as specified in ISO/CIE 11664-1.
*/
AVRational ambient_light_x;
/**
* Normalized y chromaticity coordinate of the environmental ambient light
* in the nominal viewing environment according to the CIE 1931 definition
* of x and y as specified in ISO/CIE 11664-1.
*/
AVRational ambient_light_y;
} AVAmbientViewingEnvironment;
/**
* Allocate an AVAmbientViewingEnvironment structure.
*
* @return the newly allocated struct or NULL on failure
*/
AVAmbientViewingEnvironment *av_ambient_viewing_environment_alloc(size_t *size);
/**
* Allocate and add an AVAmbientViewingEnvironment structure to an existing
* AVFrame as side data.
*
* @return the newly allocated struct, or NULL on failure
*/
AVAmbientViewingEnvironment *av_ambient_viewing_environment_create_side_data(AVFrame *frame);
#endif /* AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H */

2
src/3rdparty/win32_include/libavutil/attributes.h vendored
View File

@ -110,7 +110,7 @@
* scheduled for removal. * scheduled for removal.
*/ */
#ifndef AV_NOWARN_DEPRECATED #ifndef AV_NOWARN_DEPRECATED
#if AV_GCC_VERSION_AT_LEAST(4,6) #if AV_GCC_VERSION_AT_LEAST(4,6) || defined(__clang__)
# define AV_NOWARN_DEPRECATED(code) \ # define AV_NOWARN_DEPRECATED(code) \
_Pragma("GCC diagnostic push") \ _Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \

3
src/3rdparty/win32_include/libavutil/audio_fifo.h vendored
View File

@ -27,8 +27,7 @@
#ifndef AVUTIL_AUDIO_FIFO_H #ifndef AVUTIL_AUDIO_FIFO_H
#define AVUTIL_AUDIO_FIFO_H #define AVUTIL_AUDIO_FIFO_H
#include "avutil.h" #include "attributes.h"
#include "fifo.h"
#include "samplefmt.h" #include "samplefmt.h"
/** /**

2
src/3rdparty/win32_include/libavutil/avassert.h vendored
View File

@ -28,8 +28,8 @@
#define AVUTIL_AVASSERT_H #define AVUTIL_AVASSERT_H
#include <stdlib.h> #include <stdlib.h>
#include "avutil.h"
#include "log.h" #include "log.h"
#include "macros.h"
/** /**
* assert() equivalent, that is always enabled. * assert() equivalent, that is always enabled.

10
src/3rdparty/win32_include/libavutil/avstring.h vendored
View File

@ -135,6 +135,7 @@ size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_forma
/** /**
* Get the count of continuous non zero chars starting from the beginning. * Get the count of continuous non zero chars starting from the beginning.
* *
* @param s the string whose length to count
* @param len maximum number of characters to check in the string, that * @param len maximum number of characters to check in the string, that
* is the maximum value which is returned by the function * is the maximum value which is returned by the function
*/ */
@ -156,15 +157,6 @@ static inline size_t av_strnlen(const char *s, size_t len)
*/ */
char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2); char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);
#if FF_API_D2STR
/**
* Convert a number to an av_malloced string.
* @deprecated use av_asprintf() with "%f" or a more specific format
*/
attribute_deprecated
char *av_d2str(double d);
#endif
/** /**
* Unescape the given string until a non escaped terminating char, * Unescape the given string until a non escaped terminating char,
* and return the token corresponding to the unescaped string. * and return the token corresponding to the unescaped string.

6
src/3rdparty/win32_include/libavutil/avutil.h vendored
View File

@ -331,12 +331,18 @@ unsigned av_int_list_length_for_size(unsigned elsize,
#define av_int_list_length(list, term) \ #define av_int_list_length(list, term) \
av_int_list_length_for_size(sizeof(*(list)), list, term) av_int_list_length_for_size(sizeof(*(list)), list, term)
#if FF_API_AV_FOPEN_UTF8
/** /**
* Open a file using a UTF-8 filename. * Open a file using a UTF-8 filename.
* The API of this function matches POSIX fopen(), errors are returned through * The API of this function matches POSIX fopen(), errors are returned through
* errno. * errno.
* @deprecated Avoid using it, as on Windows, the FILE* allocated by this
* function may be allocated with a different CRT than the caller
* who uses the FILE*. No replacement provided in public API.
*/ */
attribute_deprecated
FILE *av_fopen_utf8(const char *path, const char *mode); FILE *av_fopen_utf8(const char *path, const char *mode);
#endif
/** /**
* Return the fractional representation of the internal time base. * Return the fractional representation of the internal time base.

78
src/3rdparty/win32_include/libavutil/bprint.h vendored
View File

@ -18,6 +18,12 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
/**
* @file
* @ingroup lavu_avbprint
* AVBPrint public header
*/
#ifndef AVUTIL_BPRINT_H #ifndef AVUTIL_BPRINT_H
#define AVUTIL_BPRINT_H #define AVUTIL_BPRINT_H
@ -26,6 +32,14 @@
#include "attributes.h" #include "attributes.h"
#include "avstring.h" #include "avstring.h"
/**
* @defgroup lavu_avbprint AVBPrint
* @ingroup lavu_data
*
* A buffer to print data progressively
* @{
*/
/** /**
* Define a structure with extra padding to a fixed size * Define a structure with extra padding to a fixed size
* This helps ensuring binary compatibility with future versions. * This helps ensuring binary compatibility with future versions.
@ -48,14 +62,14 @@ typedef struct name { \
* Small buffers are kept in the structure itself, and thus require no * Small buffers are kept in the structure itself, and thus require no
* memory allocation at all (unless the contents of the buffer is needed * memory allocation at all (unless the contents of the buffer is needed
* after the structure goes out of scope). This is almost as lightweight as * after the structure goes out of scope). This is almost as lightweight as
* declaring a local "char buf[512]". * declaring a local `char buf[512]`.
* *
* The length of the string can go beyond the allocated size: the buffer is * The length of the string can go beyond the allocated size: the buffer is
* then truncated, but the functions still keep account of the actual total * then truncated, but the functions still keep account of the actual total
* length. * length.
* *
* In other words, buf->len can be greater than buf->size and records the * In other words, AVBPrint.len can be greater than AVBPrint.size and records
* total length of what would have been to the buffer if there had been * the total length of what would have been to the buffer if there had been
* enough memory. * enough memory.
* *
* Append operations do not need to be tested for failure: if a memory * Append operations do not need to be tested for failure: if a memory
@ -63,20 +77,17 @@ typedef struct name { \
* is still updated. This situation can be tested with * is still updated. This situation can be tested with
* av_bprint_is_complete(). * av_bprint_is_complete().
* *
* The size_max field determines several possible behaviours: * The AVBPrint.size_max field determines several possible behaviours:
* * - `size_max = -1` (= `UINT_MAX`) or any large value will let the buffer be
* size_max = -1 (= UINT_MAX) or any large value will let the buffer be * reallocated as necessary, with an amortized linear cost.
* reallocated as necessary, with an amortized linear cost. * - `size_max = 0` prevents writing anything to the buffer: only the total
* * length is computed. The write operations can then possibly be repeated in
* size_max = 0 prevents writing anything to the buffer: only the total * a buffer with exactly the necessary size
* length is computed. The write operations can then possibly be repeated in * (using `size_init = size_max = len + 1`).
* a buffer with exactly the necessary size * - `size_max = 1` is automatically replaced by the exact size available in the
* (using size_init = size_max = len + 1). * structure itself, thus ensuring no dynamic memory allocation. The
* * internal buffer is large enough to hold a reasonable paragraph of text,
* size_max = 1 is automatically replaced by the exact size available in the * such as the current paragraph.
* structure itself, thus ensuring no dynamic memory allocation. The
* internal buffer is large enough to hold a reasonable paragraph of text,
* such as the current paragraph.
*/ */
FF_PAD_STRUCTURE(AVBPrint, 1024, FF_PAD_STRUCTURE(AVBPrint, 1024,
@ -88,12 +99,31 @@ FF_PAD_STRUCTURE(AVBPrint, 1024,
) )
/** /**
* @name Max size special values
* Convenience macros for special values for av_bprint_init() size_max * Convenience macros for special values for av_bprint_init() size_max
* parameter. * parameter.
* @{
*/
/**
* Buffer will be reallocated as necessary, with an amortized linear cost.
*/ */
#define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1) #define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1)
/**
* Use the exact size available in the AVBPrint structure itself.
*
* Thus ensuring no dynamic memory allocation. The internal buffer is large
* enough to hold a reasonable paragraph of text, such as the current paragraph.
*/
#define AV_BPRINT_SIZE_AUTOMATIC 1 #define AV_BPRINT_SIZE_AUTOMATIC 1
/**
* Do not write anything to the buffer, only calculate the total length.
*
* The write operations can then possibly be repeated in a buffer with
* exactly the necessary size (using `size_init = size_max = AVBPrint.len + 1`).
*/
#define AV_BPRINT_SIZE_COUNT_ONLY 0 #define AV_BPRINT_SIZE_COUNT_ONLY 0
/** @} */
/** /**
* Init a print buffer. * Init a print buffer.
@ -101,12 +131,12 @@ FF_PAD_STRUCTURE(AVBPrint, 1024,
* @param buf buffer to init * @param buf buffer to init
* @param size_init initial size (including the final 0) * @param size_init initial size (including the final 0)
* @param size_max maximum size; * @param size_max maximum size;
* 0 means do not write anything, just count the length; * - `0` means do not write anything, just count the length
* 1 is replaced by the maximum value for automatic storage; * - `1` is replaced by the maximum value for automatic storage
* any large value means that the internal buffer will be * any large value means that the internal buffer will be
* reallocated as needed up to that limit; -1 is converted to * reallocated as needed up to that limit
* UINT_MAX, the largest limit possible. * - `-1` is converted to `UINT_MAX`, the largest limit possible.
* Check also AV_BPRINT_SIZE_* macros. * Check also `AV_BPRINT_SIZE_*` macros.
*/ */
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max); void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max);
@ -216,4 +246,6 @@ int av_bprint_finalize(AVBPrint *buf, char **ret_str);
void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,
enum AVEscapeMode mode, int flags); enum AVEscapeMode mode, int flags);
/** @} */
#endif /* AVUTIL_BPRINT_H */ #endif /* AVUTIL_BPRINT_H */

2
src/3rdparty/win32_include/libavutil/bswap.h vendored
View File

@ -40,6 +40,8 @@
# include "arm/bswap.h" # include "arm/bswap.h"
#elif ARCH_AVR32 #elif ARCH_AVR32
# include "avr32/bswap.h" # include "avr32/bswap.h"
#elif ARCH_RISCV
# include "riscv/bswap.h"
#elif ARCH_SH4 #elif ARCH_SH4
# include "sh4/bswap.h" # include "sh4/bswap.h"
#elif ARCH_X86 #elif ARCH_X86

2
src/3rdparty/win32_include/libavutil/camellia.h vendored
View File

@ -59,7 +59,7 @@ int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits);
* @param dst destination array, can be equal to src * @param dst destination array, can be equal to src
* @param src source array, can be equal to dst * @param src source array, can be equal to dst
* @param count number of 16 byte blocks * @param count number of 16 byte blocks
* @paran iv initialization vector for CBC mode, NULL for ECB mode * @param iv initialization vector for CBC mode, NULL for ECB mode
* @param decrypt 0 for encryption, 1 for decryption * @param decrypt 0 for encryption, 1 for decryption
*/ */
void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt); void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);

615
src/3rdparty/win32_include/libavutil/channel_layout.h vendored
View File

@ -23,17 +23,132 @@
#define AVUTIL_CHANNEL_LAYOUT_H #define AVUTIL_CHANNEL_LAYOUT_H
#include <stdint.h> #include <stdint.h>
#include <stdlib.h>
#include "version.h"
#include "attributes.h"
/** /**
* @file * @file
* audio channel layout utility functions * @ingroup lavu_audio_channels
* Public libavutil channel layout APIs header.
*/ */
/** /**
* @addtogroup lavu_audio * @defgroup lavu_audio_channels Audio channels
* @ingroup lavu_audio
*
* Audio channel layout utility functions
*
* @{ * @{
*/ */
enum AVChannel {
///< Invalid channel index
AV_CHAN_NONE = -1,
AV_CHAN_FRONT_LEFT,
AV_CHAN_FRONT_RIGHT,
AV_CHAN_FRONT_CENTER,
AV_CHAN_LOW_FREQUENCY,
AV_CHAN_BACK_LEFT,
AV_CHAN_BACK_RIGHT,
AV_CHAN_FRONT_LEFT_OF_CENTER,
AV_CHAN_FRONT_RIGHT_OF_CENTER,
AV_CHAN_BACK_CENTER,
AV_CHAN_SIDE_LEFT,
AV_CHAN_SIDE_RIGHT,
AV_CHAN_TOP_CENTER,
AV_CHAN_TOP_FRONT_LEFT,
AV_CHAN_TOP_FRONT_CENTER,
AV_CHAN_TOP_FRONT_RIGHT,
AV_CHAN_TOP_BACK_LEFT,
AV_CHAN_TOP_BACK_CENTER,
AV_CHAN_TOP_BACK_RIGHT,
/** Stereo downmix. */
AV_CHAN_STEREO_LEFT = 29,
/** See above. */
AV_CHAN_STEREO_RIGHT,
AV_CHAN_WIDE_LEFT,
AV_CHAN_WIDE_RIGHT,
AV_CHAN_SURROUND_DIRECT_LEFT,
AV_CHAN_SURROUND_DIRECT_RIGHT,
AV_CHAN_LOW_FREQUENCY_2,
AV_CHAN_TOP_SIDE_LEFT,
AV_CHAN_TOP_SIDE_RIGHT,
AV_CHAN_BOTTOM_FRONT_CENTER,
AV_CHAN_BOTTOM_FRONT_LEFT,
AV_CHAN_BOTTOM_FRONT_RIGHT,
/** Channel is empty can be safely skipped. */
AV_CHAN_UNUSED = 0x200,
/** Channel contains data, but its position is unknown. */
AV_CHAN_UNKNOWN = 0x300,
/**
* Range of channels between AV_CHAN_AMBISONIC_BASE and
* AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.
*
* Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and
* AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is
* `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.
*
* @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel
* orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels
* implicitly by their position in the stream.
*/
AV_CHAN_AMBISONIC_BASE = 0x400,
// leave space for 1024 ids, which correspond to maximum order-32 harmonics,
// which should be enough for the foreseeable use cases
AV_CHAN_AMBISONIC_END = 0x7ff,
};
enum AVChannelOrder {
/**
* Only the channel count is specified, without any further information
* about the channel order.
*/
AV_CHANNEL_ORDER_UNSPEC,
/**
* The native channel order, i.e. the channels are in the same order in
* which they are defined in the AVChannel enum. This supports up to 63
* different channels.
*/
AV_CHANNEL_ORDER_NATIVE,
/**
* The channel order does not correspond to any other predefined order and
* is stored as an explicit map. For example, this could be used to support
* layouts with 64 or more channels, or with empty/skipped (AV_CHAN_SILENCE)
* channels at arbitrary positions.
*/
AV_CHANNEL_ORDER_CUSTOM,
/**
* The audio is represented as the decomposition of the sound field into
* spherical harmonics. Each channel corresponds to a single expansion
* component. Channels are ordered according to ACN (Ambisonic Channel
* Number).
*
* The channel with the index n in the stream contains the spherical
* harmonic of degree l and order m given by
* @code{.unparsed}
* l = floor(sqrt(n)),
* m = n - l * (l + 1).
* @endcode
*
* Conversely given a spherical harmonic of degree l and order m, the
* corresponding channel index n is given by
* @code{.unparsed}
* n = l * (l + 1) + m.
* @endcode
*
* Normalization is assumed to be SN3D (Schmidt Semi-Normalization)
* as defined in AmbiX format $ 2.1.
*/
AV_CHANNEL_ORDER_AMBISONIC,
};
/** /**
* @defgroup channel_masks Audio channel masks * @defgroup channel_masks Audio channel masks
* *
@ -46,41 +161,46 @@
* *
* @{ * @{
*/ */
#define AV_CH_FRONT_LEFT 0x00000001 #define AV_CH_FRONT_LEFT (1ULL << AV_CHAN_FRONT_LEFT )
#define AV_CH_FRONT_RIGHT 0x00000002 #define AV_CH_FRONT_RIGHT (1ULL << AV_CHAN_FRONT_RIGHT )
#define AV_CH_FRONT_CENTER 0x00000004 #define AV_CH_FRONT_CENTER (1ULL << AV_CHAN_FRONT_CENTER )
#define AV_CH_LOW_FREQUENCY 0x00000008 #define AV_CH_LOW_FREQUENCY (1ULL << AV_CHAN_LOW_FREQUENCY )
#define AV_CH_BACK_LEFT 0x00000010 #define AV_CH_BACK_LEFT (1ULL << AV_CHAN_BACK_LEFT )
#define AV_CH_BACK_RIGHT 0x00000020 #define AV_CH_BACK_RIGHT (1ULL << AV_CHAN_BACK_RIGHT )
#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040 #define AV_CH_FRONT_LEFT_OF_CENTER (1ULL << AV_CHAN_FRONT_LEFT_OF_CENTER )
#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080 #define AV_CH_FRONT_RIGHT_OF_CENTER (1ULL << AV_CHAN_FRONT_RIGHT_OF_CENTER)
#define AV_CH_BACK_CENTER 0x00000100 #define AV_CH_BACK_CENTER (1ULL << AV_CHAN_BACK_CENTER )
#define AV_CH_SIDE_LEFT 0x00000200 #define AV_CH_SIDE_LEFT (1ULL << AV_CHAN_SIDE_LEFT )
#define AV_CH_SIDE_RIGHT 0x00000400 #define AV_CH_SIDE_RIGHT (1ULL << AV_CHAN_SIDE_RIGHT )
#define AV_CH_TOP_CENTER 0x00000800 #define AV_CH_TOP_CENTER (1ULL << AV_CHAN_TOP_CENTER )
#define AV_CH_TOP_FRONT_LEFT 0x00001000 #define AV_CH_TOP_FRONT_LEFT (1ULL << AV_CHAN_TOP_FRONT_LEFT )
#define AV_CH_TOP_FRONT_CENTER 0x00002000 #define AV_CH_TOP_FRONT_CENTER (1ULL << AV_CHAN_TOP_FRONT_CENTER )
#define AV_CH_TOP_FRONT_RIGHT 0x00004000 #define AV_CH_TOP_FRONT_RIGHT (1ULL << AV_CHAN_TOP_FRONT_RIGHT )
#define AV_CH_TOP_BACK_LEFT 0x00008000 #define AV_CH_TOP_BACK_LEFT (1ULL << AV_CHAN_TOP_BACK_LEFT )
#define AV_CH_TOP_BACK_CENTER 0x00010000 #define AV_CH_TOP_BACK_CENTER (1ULL << AV_CHAN_TOP_BACK_CENTER )
#define AV_CH_TOP_BACK_RIGHT 0x00020000 #define AV_CH_TOP_BACK_RIGHT (1ULL << AV_CHAN_TOP_BACK_RIGHT )
#define AV_CH_STEREO_LEFT 0x20000000 ///< Stereo downmix. #define AV_CH_STEREO_LEFT (1ULL << AV_CHAN_STEREO_LEFT )
#define AV_CH_STEREO_RIGHT 0x40000000 ///< See AV_CH_STEREO_LEFT. #define AV_CH_STEREO_RIGHT (1ULL << AV_CHAN_STEREO_RIGHT )
#define AV_CH_WIDE_LEFT 0x0000000080000000ULL #define AV_CH_WIDE_LEFT (1ULL << AV_CHAN_WIDE_LEFT )
#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL #define AV_CH_WIDE_RIGHT (1ULL << AV_CHAN_WIDE_RIGHT )
#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL #define AV_CH_SURROUND_DIRECT_LEFT (1ULL << AV_CHAN_SURROUND_DIRECT_LEFT )
#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL #define AV_CH_SURROUND_DIRECT_RIGHT (1ULL << AV_CHAN_SURROUND_DIRECT_RIGHT)
#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL #define AV_CH_LOW_FREQUENCY_2 (1ULL << AV_CHAN_LOW_FREQUENCY_2 )
#define AV_CH_TOP_SIDE_LEFT 0x0000001000000000ULL #define AV_CH_TOP_SIDE_LEFT (1ULL << AV_CHAN_TOP_SIDE_LEFT )
#define AV_CH_TOP_SIDE_RIGHT 0x0000002000000000ULL #define AV_CH_TOP_SIDE_RIGHT (1ULL << AV_CHAN_TOP_SIDE_RIGHT )
#define AV_CH_BOTTOM_FRONT_CENTER 0x0000004000000000ULL #define AV_CH_BOTTOM_FRONT_CENTER (1ULL << AV_CHAN_BOTTOM_FRONT_CENTER )
#define AV_CH_BOTTOM_FRONT_LEFT 0x0000008000000000ULL #define AV_CH_BOTTOM_FRONT_LEFT (1ULL << AV_CHAN_BOTTOM_FRONT_LEFT )
#define AV_CH_BOTTOM_FRONT_RIGHT 0x0000010000000000ULL #define AV_CH_BOTTOM_FRONT_RIGHT (1ULL << AV_CHAN_BOTTOM_FRONT_RIGHT )
#if FF_API_OLD_CHANNEL_LAYOUT
/** Channel mask value used for AVCodecContext.request_channel_layout /** Channel mask value used for AVCodecContext.request_channel_layout
to indicate that the user requests the channel order of the decoder output to indicate that the user requests the channel order of the decoder output
to be the native codec channel order. */ to be the native codec channel order.
@deprecated channel order is now indicated in a special field in
AVChannelLayout
*/
#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL #define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL
#endif
/** /**
* @} * @}
@ -112,7 +232,9 @@
#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) #define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) #define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) #define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
#define AV_CH_LAYOUT_7POINT1_TOP_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT) #define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
#define AV_CH_LAYOUT_CUBE (AV_CH_LAYOUT_QUAD|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT)
#define AV_CH_LAYOUT_HEXADECAGONAL (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT) #define AV_CH_LAYOUT_HEXADECAGONAL (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT) #define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
#define AV_CH_LAYOUT_22POINT2 (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_LOW_FREQUENCY_2|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_CENTER|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_SIDE_LEFT|AV_CH_TOP_SIDE_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_BOTTOM_FRONT_CENTER|AV_CH_BOTTOM_FRONT_LEFT|AV_CH_BOTTOM_FRONT_RIGHT) #define AV_CH_LAYOUT_22POINT2 (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_LOW_FREQUENCY_2|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_CENTER|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_SIDE_LEFT|AV_CH_TOP_SIDE_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_BOTTOM_FRONT_CENTER|AV_CH_BOTTOM_FRONT_LEFT|AV_CH_BOTTOM_FRONT_RIGHT)
@ -128,6 +250,164 @@ enum AVMatrixEncoding {
AV_MATRIX_ENCODING_NB AV_MATRIX_ENCODING_NB
}; };
/**
* @}
*/
/**
* An AVChannelCustom defines a single channel within a custom order layout
*
* Unlike most structures in FFmpeg, sizeof(AVChannelCustom) is a part of the
* public ABI.
*
* No new fields may be added to it without a major version bump.
*/
typedef struct AVChannelCustom {
enum AVChannel id;
char name[16];
void *opaque;
} AVChannelCustom;
/**
* An AVChannelLayout holds information about the channel layout of audio data.
*
* A channel layout here is defined as a set of channels ordered in a specific
* way (unless the channel order is AV_CHANNEL_ORDER_UNSPEC, in which case an
* AVChannelLayout carries only the channel count).
* All orders may be treated as if they were AV_CHANNEL_ORDER_UNSPEC by
* ignoring everything but the channel count, as long as av_channel_layout_check()
* considers they are valid.
*
* Unlike most structures in FFmpeg, sizeof(AVChannelLayout) is a part of the
* public ABI and may be used by the caller. E.g. it may be allocated on stack
* or embedded in caller-defined structs.
*
* AVChannelLayout can be initialized as follows:
* - default initialization with {0}, followed by setting all used fields
* correctly;
* - by assigning one of the predefined AV_CHANNEL_LAYOUT_* initializers;
* - with a constructor function, such as av_channel_layout_default(),
* av_channel_layout_from_mask() or av_channel_layout_from_string().
*
* The channel layout must be unitialized with av_channel_layout_uninit()
*
* Copying an AVChannelLayout via assigning is forbidden,
* av_channel_layout_copy() must be used instead (and its return value should
* be checked)
*
* No new fields may be added to it without a major version bump, except for
* new elements of the union fitting in sizeof(uint64_t).
*/
typedef struct AVChannelLayout {
/**
* Channel order used in this layout.
* This is a mandatory field.
*/
enum AVChannelOrder order;
/**
* Number of channels in this layout. Mandatory field.
*/
int nb_channels;
/**
* Details about which channels are present in this layout.
* For AV_CHANNEL_ORDER_UNSPEC, this field is undefined and must not be
* used.
*/
union {
/**
* This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used
* for AV_CHANNEL_ORDER_AMBISONIC to signal non-diegetic channels.
* It is a bitmask, where the position of each set bit means that the
* AVChannel with the corresponding value is present.
*
* I.e. when (mask & (1 << AV_CHAN_FOO)) is non-zero, then AV_CHAN_FOO
* is present in the layout. Otherwise it is not present.
*
* @note when a channel layout using a bitmask is constructed or
* modified manually (i.e. not using any of the av_channel_layout_*
* functions), the code doing it must ensure that the number of set bits
* is equal to nb_channels.
*/
uint64_t mask;
/**
* This member must be used when the channel order is
* AV_CHANNEL_ORDER_CUSTOM. It is a nb_channels-sized array, with each
* element signalling the presence of the AVChannel with the
* corresponding value in map[i].id.
*
* I.e. when map[i].id is equal to AV_CHAN_FOO, then AV_CH_FOO is the
* i-th channel in the audio data.
*
* When map[i].id is in the range between AV_CHAN_AMBISONIC_BASE and
* AV_CHAN_AMBISONIC_END (inclusive), the channel contains an ambisonic
* component with ACN index (as defined above)
* n = map[i].id - AV_CHAN_AMBISONIC_BASE.
*
* map[i].name may be filled with a 0-terminated string, in which case
* it will be used for the purpose of identifying the channel with the
* convenience functions below. Otherise it must be zeroed.
*/
AVChannelCustom *map;
} u;
/**
* For some private data of the user.
*/
void *opaque;
} AVChannelLayout;
#define AV_CHANNEL_LAYOUT_MASK(nb, m) \
{ .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = (nb), .u = { .mask = (m) }}
/**
* @name Common pre-defined channel layouts
* @{
*/
#define AV_CHANNEL_LAYOUT_MONO AV_CHANNEL_LAYOUT_MASK(1, AV_CH_LAYOUT_MONO)
#define AV_CHANNEL_LAYOUT_STEREO AV_CHANNEL_LAYOUT_MASK(2, AV_CH_LAYOUT_STEREO)
#define AV_CHANNEL_LAYOUT_2POINT1 AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_2POINT1)
#define AV_CHANNEL_LAYOUT_2_1 AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_2_1)
#define AV_CHANNEL_LAYOUT_SURROUND AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_SURROUND)
#define AV_CHANNEL_LAYOUT_3POINT1 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_3POINT1)
#define AV_CHANNEL_LAYOUT_4POINT0 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_4POINT0)
#define AV_CHANNEL_LAYOUT_4POINT1 AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_4POINT1)
#define AV_CHANNEL_LAYOUT_2_2 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_2_2)
#define AV_CHANNEL_LAYOUT_QUAD AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_QUAD)
#define AV_CHANNEL_LAYOUT_5POINT0 AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_5POINT0)
#define AV_CHANNEL_LAYOUT_5POINT1 AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_5POINT1)
#define AV_CHANNEL_LAYOUT_5POINT0_BACK AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_5POINT0_BACK)
#define AV_CHANNEL_LAYOUT_5POINT1_BACK AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_5POINT1_BACK)
#define AV_CHANNEL_LAYOUT_6POINT0 AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_6POINT0)
#define AV_CHANNEL_LAYOUT_6POINT0_FRONT AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_6POINT0_FRONT)
#define AV_CHANNEL_LAYOUT_HEXAGONAL AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_HEXAGONAL)
#define AV_CHANNEL_LAYOUT_6POINT1 AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1)
#define AV_CHANNEL_LAYOUT_6POINT1_BACK AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1_BACK)
#define AV_CHANNEL_LAYOUT_6POINT1_FRONT AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1_FRONT)
#define AV_CHANNEL_LAYOUT_7POINT0 AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_7POINT0)
#define AV_CHANNEL_LAYOUT_7POINT0_FRONT AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_7POINT0_FRONT)
#define AV_CHANNEL_LAYOUT_7POINT1 AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1)
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_WIDE)
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_WIDE_BACK)
#define AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_TOP_BACK)
#define AV_CHANNEL_LAYOUT_OCTAGONAL AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_OCTAGONAL)
#define AV_CHANNEL_LAYOUT_CUBE AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_CUBE)
#define AV_CHANNEL_LAYOUT_HEXADECAGONAL AV_CHANNEL_LAYOUT_MASK(16, AV_CH_LAYOUT_HEXADECAGONAL)
#define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX AV_CHANNEL_LAYOUT_MASK(2, AV_CH_LAYOUT_STEREO_DOWNMIX)
#define AV_CHANNEL_LAYOUT_22POINT2 AV_CHANNEL_LAYOUT_MASK(24, AV_CH_LAYOUT_22POINT2)
#define AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER \
{ .order = AV_CHANNEL_ORDER_AMBISONIC, .nb_channels = 4, .u = { .mask = 0 }}
/** @} */
struct AVBPrint;
#if FF_API_OLD_CHANNEL_LAYOUT
/**
* @name Deprecated Functions
* @{
*/
/** /**
* Return a channel layout id that matches name, or 0 if no match is found. * Return a channel layout id that matches name, or 0 if no match is found.
* *
@ -144,7 +424,10 @@ enum AVMatrixEncoding {
* AV_CH_* macros). * AV_CH_* macros).
* *
* Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7" * Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7"
*
* @deprecated use av_channel_layout_from_string()
*/ */
attribute_deprecated
uint64_t av_get_channel_layout(const char *name); uint64_t av_get_channel_layout(const char *name);
/** /**
@ -158,7 +441,9 @@ uint64_t av_get_channel_layout(const char *name);
* @param[out] nb_channels number of channels * @param[out] nb_channels number of channels
* *
* @return 0 on success, AVERROR(EINVAL) if the parsing fails. * @return 0 on success, AVERROR(EINVAL) if the parsing fails.
* @deprecated use av_channel_layout_from_string()
*/ */
attribute_deprecated
int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels); int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
/** /**
@ -167,47 +452,66 @@ int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, i
* *
* @param buf put here the string containing the channel layout * @param buf put here the string containing the channel layout
* @param buf_size size in bytes of the buffer * @param buf_size size in bytes of the buffer
* @param nb_channels number of channels
* @param channel_layout channel layout bitset
* @deprecated use av_channel_layout_describe()
*/ */
attribute_deprecated
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout); void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
struct AVBPrint;
/** /**
* Append a description of a channel layout to a bprint buffer. * Append a description of a channel layout to a bprint buffer.
* @deprecated use av_channel_layout_describe()
*/ */
attribute_deprecated
void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout); void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
/** /**
* Return the number of channels in the channel layout. * Return the number of channels in the channel layout.
* @deprecated use AVChannelLayout.nb_channels
*/ */
attribute_deprecated
int av_get_channel_layout_nb_channels(uint64_t channel_layout); int av_get_channel_layout_nb_channels(uint64_t channel_layout);
/** /**
* Return default channel layout for a given number of channels. * Return default channel layout for a given number of channels.
*
* @deprecated use av_channel_layout_default()
*/ */
attribute_deprecated
int64_t av_get_default_channel_layout(int nb_channels); int64_t av_get_default_channel_layout(int nb_channels);
/** /**
* Get the index of a channel in channel_layout. * Get the index of a channel in channel_layout.
* *
* @param channel_layout channel layout bitset
* @param channel a channel layout describing exactly one channel which must be * @param channel a channel layout describing exactly one channel which must be
* present in channel_layout. * present in channel_layout.
* *
* @return index of channel in channel_layout on success, a negative AVERROR * @return index of channel in channel_layout on success, a negative AVERROR
* on error. * on error.
*
* @deprecated use av_channel_layout_index_from_channel()
*/ */
attribute_deprecated
int av_get_channel_layout_channel_index(uint64_t channel_layout, int av_get_channel_layout_channel_index(uint64_t channel_layout,
uint64_t channel); uint64_t channel);
/** /**
* Get the channel with the given index in channel_layout. * Get the channel with the given index in channel_layout.
* @deprecated use av_channel_layout_channel_from_index()
*/ */
attribute_deprecated
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index); uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
/** /**
* Get the name of a given channel. * Get the name of a given channel.
* *
* @return channel name on success, NULL on error. * @return channel name on success, NULL on error.
*
* @deprecated use av_channel_name()
*/ */
attribute_deprecated
const char *av_get_channel_name(uint64_t channel); const char *av_get_channel_name(uint64_t channel);
/** /**
@ -215,7 +519,9 @@ const char *av_get_channel_name(uint64_t channel);
* *
* @param channel a channel layout with a single channel * @param channel a channel layout with a single channel
* @return channel description on success, NULL on error * @return channel description on success, NULL on error
* @deprecated use av_channel_description()
*/ */
attribute_deprecated
const char *av_get_channel_description(uint64_t channel); const char *av_get_channel_description(uint64_t channel);
/** /**
@ -226,12 +532,251 @@ const char *av_get_channel_description(uint64_t channel);
* @param[out] name name of the layout * @param[out] name name of the layout
* @return 0 if the layout exists, * @return 0 if the layout exists,
* <0 if index is beyond the limits * <0 if index is beyond the limits
* @deprecated use av_channel_layout_standard()
*/ */
attribute_deprecated
int av_get_standard_channel_layout(unsigned index, uint64_t *layout, int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
const char **name); const char **name);
/** /**
* @} * @}
*/
#endif
/**
* Get a human readable string in an abbreviated form describing a given channel.
* This is the inverse function of @ref av_channel_from_string().
*
* @param buf pre-allocated buffer where to put the generated string
* @param buf_size size in bytes of the buffer.
* @param channel the AVChannel whose name to get
* @return amount of bytes needed to hold the output string, or a negative AVERROR
* on failure. If the returned value is bigger than buf_size, then the
* string was truncated.
*/
int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel);
/**
* bprint variant of av_channel_name().
*
* @note the string will be appended to the bprint buffer.
*/
void av_channel_name_bprint(struct AVBPrint *bp, enum AVChannel channel_id);
/**
* Get a human readable string describing a given channel.
*
* @param buf pre-allocated buffer where to put the generated string
* @param buf_size size in bytes of the buffer.
* @param channel the AVChannel whose description to get
* @return amount of bytes needed to hold the output string, or a negative AVERROR
* on failure. If the returned value is bigger than buf_size, then the
* string was truncated.
*/
int av_channel_description(char *buf, size_t buf_size, enum AVChannel channel);
/**
* bprint variant of av_channel_description().
*
* @note the string will be appended to the bprint buffer.
*/
void av_channel_description_bprint(struct AVBPrint *bp, enum AVChannel channel_id);
/**
* This is the inverse function of @ref av_channel_name().
*
* @return the channel with the given name
* AV_CHAN_NONE when name does not identify a known channel
*/
enum AVChannel av_channel_from_string(const char *name);
/**
* Initialize a native channel layout from a bitmask indicating which channels
* are present.
*
* @param channel_layout the layout structure to be initialized
* @param mask bitmask describing the channel layout
*
* @return 0 on success
* AVERROR(EINVAL) for invalid mask values
*/
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask);
/**
* Initialize a channel layout from a given string description.
* The input string can be represented by:
* - the formal channel layout name (returned by av_channel_layout_describe())
* - single or multiple channel names (returned by av_channel_name(), eg. "FL",
* or concatenated with "+", each optionally containing a custom name after
* a "@", eg. "FL@Left+FR@Right+LFE")
* - a decimal or hexadecimal value of a native channel layout (eg. "4" or "0x4")
* - the number of channels with default layout (eg. "4c")
* - the number of unordered channels (eg. "4C" or "4 channels")
* - the ambisonic order followed by optional non-diegetic channels (eg.
* "ambisonic 2+stereo")
*
* @param channel_layout input channel layout
* @param str string describing the channel layout
* @return 0 channel layout was detected, AVERROR_INVALIDATATA otherwise
*/
int av_channel_layout_from_string(AVChannelLayout *channel_layout,
const char *str);
/**
* Get the default channel layout for a given number of channels.
*
* @param ch_layout the layout structure to be initialized
* @param nb_channels number of channels
*/
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels);
/**
* Iterate over all standard channel layouts.
*
* @param opaque a pointer where libavutil will store the iteration state. Must
* point to NULL to start the iteration.
*
* @return the standard channel layout or NULL when the iteration is
* finished
*/
const AVChannelLayout *av_channel_layout_standard(void **opaque);
/**
* Free any allocated data in the channel layout and reset the channel
* count to 0.
*
* @param channel_layout the layout structure to be uninitialized
*/
void av_channel_layout_uninit(AVChannelLayout *channel_layout);
/**
* Make a copy of a channel layout. This differs from just assigning src to dst
* in that it allocates and copies the map for AV_CHANNEL_ORDER_CUSTOM.
*
* @note the destination channel_layout will be always uninitialized before copy.
*
* @param dst destination channel layout
* @param src source channel layout
* @return 0 on success, a negative AVERROR on error.
*/
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src);
/**
* Get a human-readable string describing the channel layout properties.
* The string will be in the same format that is accepted by
* @ref av_channel_layout_from_string(), allowing to rebuild the same
* channel layout, except for opaque pointers.
*
* @param channel_layout channel layout to be described
* @param buf pre-allocated buffer where to put the generated string
* @param buf_size size in bytes of the buffer.
* @return amount of bytes needed to hold the output string, or a negative AVERROR
* on failure. If the returned value is bigger than buf_size, then the
* string was truncated.
*/
int av_channel_layout_describe(const AVChannelLayout *channel_layout,
char *buf, size_t buf_size);
/**
* bprint variant of av_channel_layout_describe().
*
* @note the string will be appended to the bprint buffer.
* @return 0 on success, or a negative AVERROR value on failure.
*/
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout,
struct AVBPrint *bp);
/**
* Get the channel with the given index in a channel layout.
*
* @param channel_layout input channel layout
* @param idx index of the channel
* @return channel with the index idx in channel_layout on success or
* AV_CHAN_NONE on failure (if idx is not valid or the channel order is
* unspecified)
*/
enum AVChannel
av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx);
/**
* Get the index of a given channel in a channel layout. In case multiple
* channels are found, only the first match will be returned.
*
* @param channel_layout input channel layout
* @param channel the channel whose index to obtain
* @return index of channel in channel_layout on success or a negative number if
* channel is not present in channel_layout.
*/
int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout,
enum AVChannel channel);
/**
* Get the index in a channel layout of a channel described by the given string.
* In case multiple channels are found, only the first match will be returned.
*
* This function accepts channel names in the same format as
* @ref av_channel_from_string().
*
* @param channel_layout input channel layout
* @param name string describing the channel whose index to obtain
* @return a channel index described by the given string, or a negative AVERROR
* value.
*/
int av_channel_layout_index_from_string(const AVChannelLayout *channel_layout,
const char *name);
/**
* Get a channel described by the given string.
*
* This function accepts channel names in the same format as
* @ref av_channel_from_string().
*
* @param channel_layout input channel layout
* @param name string describing the channel to obtain
* @return a channel described by the given string in channel_layout on success
* or AV_CHAN_NONE on failure (if the string is not valid or the channel
* order is unspecified)
*/
enum AVChannel
av_channel_layout_channel_from_string(const AVChannelLayout *channel_layout,
const char *name);
/**
* Find out what channels from a given set are present in a channel layout,
* without regard for their positions.
*
* @param channel_layout input channel layout
* @param mask a combination of AV_CH_* representing a set of channels
* @return a bitfield representing all the channels from mask that are present
* in channel_layout
*/
uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout,
uint64_t mask);
/**
* Check whether a channel layout is valid, i.e. can possibly describe audio
* data.
*
* @param channel_layout input channel layout
* @return 1 if channel_layout is valid, 0 otherwise.
*/
int av_channel_layout_check(const AVChannelLayout *channel_layout);
/**
* Check whether two channel layouts are semantically the same, i.e. the same
* channels are present on the same positions in both.
*
* If one of the channel layouts is AV_CHANNEL_ORDER_UNSPEC, while the other is
* not, they are considered to be unequal. If both are AV_CHANNEL_ORDER_UNSPEC,
* they are considered equal iff the channel counts are the same in both.
*
* @param chl input channel layout
* @param chl1 input channel layout
* @return 0 if chl and chl1 are equal, 1 if they are not equal. A negative
* AVERROR code if one or both are invalid.
*/
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1);
/**
* @} * @}
*/ */

1
src/3rdparty/win32_include/libavutil/common.h vendored
View File

@ -41,7 +41,6 @@
#include "attributes.h" #include "attributes.h"
#include "macros.h" #include "macros.h"
#include "version.h"
//rounded division & shift //rounded division & shift
#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))

11
src/3rdparty/win32_include/libavutil/cpu.h vendored
View File

@ -54,6 +54,7 @@
#define AV_CPU_FLAG_BMI1 0x20000 ///< Bit Manipulation Instruction Set 1 #define AV_CPU_FLAG_BMI1 0x20000 ///< Bit Manipulation Instruction Set 1
#define AV_CPU_FLAG_BMI2 0x40000 ///< Bit Manipulation Instruction Set 2 #define AV_CPU_FLAG_BMI2 0x40000 ///< Bit Manipulation Instruction Set 2
#define AV_CPU_FLAG_AVX512 0x100000 ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used #define AV_CPU_FLAG_AVX512 0x100000 ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used
#define AV_CPU_FLAG_AVX512ICL 0x200000 ///< F/CD/BW/DQ/VL/VNNI/IFMA/VBMI/VBMI2/VPOPCNTDQ/BITALG/GFNI/VAES/VPCLMULQDQ
#define AV_CPU_FLAG_SLOW_GATHER 0x2000000 ///< CPU has slow gathers. #define AV_CPU_FLAG_SLOW_GATHER 0x2000000 ///< CPU has slow gathers.
#define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard #define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard
@ -77,6 +78,16 @@
#define AV_CPU_FLAG_LSX (1 << 0) #define AV_CPU_FLAG_LSX (1 << 0)
#define AV_CPU_FLAG_LASX (1 << 1) #define AV_CPU_FLAG_LASX (1 << 1)
// RISC-V extensions
#define AV_CPU_FLAG_RVI (1 << 0) ///< I (full GPR bank)
#define AV_CPU_FLAG_RVF (1 << 1) ///< F (single precision FP)
#define AV_CPU_FLAG_RVD (1 << 2) ///< D (double precision FP)
#define AV_CPU_FLAG_RVV_I32 (1 << 3) ///< Vectors of 8/16/32-bit int's */
#define AV_CPU_FLAG_RVV_F32 (1 << 4) ///< Vectors of float's */
#define AV_CPU_FLAG_RVV_I64 (1 << 5) ///< Vectors of 64-bit int's */
#define AV_CPU_FLAG_RVV_F64 (1 << 6) ///< Vectors of double's
#define AV_CPU_FLAG_RVB_BASIC (1 << 7) ///< Basic bit-manipulations
/** /**
* Return the flags which specify extensions supported by the CPU. * Return the flags which specify extensions supported by the CPU.
* The returned value is affected by av_force_cpu_flags() if that was used * The returned value is affected by av_force_cpu_flags() if that was used

3
src/3rdparty/win32_include/libavutil/crc.h vendored
View File

@ -84,7 +84,10 @@ const AVCRC *av_crc_get_table(AVCRCId crc_id);
/** /**
* Calculate the CRC of a block. * Calculate the CRC of a block.
* @param ctx initialized AVCRC array (see av_crc_init())
* @param crc CRC of previous blocks if any or initial value for CRC * @param crc CRC of previous blocks if any or initial value for CRC
* @param buffer buffer whose CRC to calculate
* @param length length of the buffer
* @return CRC updated with the data from the given block * @return CRC updated with the data from the given block
* *
* @see av_crc_init() "le" parameter * @see av_crc_init() "le" parameter

150
src/3rdparty/win32_include/libavutil/csp.h vendored Normal file
View File

@ -0,0 +1,150 @@
/*
* Copyright (c) 2015 Kevin Wheatley <kevin.j.wheatley@gmail.com>
* Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
* Copyright (c) 2023 Leo Izen <leo.izen@gmail.com>
*
* 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 AVUTIL_CSP_H
#define AVUTIL_CSP_H
#include "pixfmt.h"
#include "rational.h"
/**
* @file
* Colorspace value utility functions for libavutil.
* @ingroup lavu_math_csp
* @author Ronald S. Bultje <rsbultje@gmail.com>
* @author Leo Izen <leo.izen@gmail.com>
* @author Kevin Wheatley <kevin.j.wheatley@gmail.com>
*/
/**
* @defgroup lavu_math_csp Colorspace Utility
* @ingroup lavu_math
* @{
*/
/**
* Struct containing luma coefficients to be used for RGB to YUV/YCoCg, or similar
* calculations.
*/
typedef struct AVLumaCoefficients {
AVRational cr, cg, cb;
} AVLumaCoefficients;
/**
* Struct containing chromaticity x and y values for the standard CIE 1931
* chromaticity definition.
*/
typedef struct AVCIExy {
AVRational x, y;
} AVCIExy;
/**
* Struct defining the red, green, and blue primary locations in terms of CIE
* 1931 chromaticity x and y.
*/
typedef struct AVPrimaryCoefficients {
AVCIExy r, g, b;
} AVPrimaryCoefficients;
/**
* Struct defining white point location in terms of CIE 1931 chromaticity x
* and y.
*/
typedef AVCIExy AVWhitepointCoefficients;
/**
* Struct that contains both white point location and primaries location, providing
* the complete description of a color gamut.
*/
typedef struct AVColorPrimariesDesc {
AVWhitepointCoefficients wp;
AVPrimaryCoefficients prim;
} AVColorPrimariesDesc;
/**
* Function pointer representing a double -> double transfer function that performs
* an EOTF transfer inversion. This function outputs linear light.
*/
typedef double (*av_csp_trc_function)(double);
/**
* Retrieves the Luma coefficients necessary to construct a conversion matrix
* from an enum constant describing the colorspace.
* @param csp An enum constant indicating YUV or similar colorspace.
* @return The Luma coefficients associated with that colorspace, or NULL
* if the constant is unknown to libavutil.
*/
const AVLumaCoefficients *av_csp_luma_coeffs_from_avcsp(enum AVColorSpace csp);
/**
* Retrieves a complete gamut description from an enum constant describing the
* color primaries.
* @param prm An enum constant indicating primaries
* @return A description of the colorspace gamut associated with that enum
* constant, or NULL if the constant is unknown to libavutil.
*/
const AVColorPrimariesDesc *av_csp_primaries_desc_from_id(enum AVColorPrimaries prm);
/**
* Detects which enum AVColorPrimaries constant corresponds to the given complete
* gamut description.
* @see enum AVColorPrimaries
* @param prm A description of the colorspace gamut
* @return The enum constant associated with this gamut, or
* AVCOL_PRI_UNSPECIFIED if no clear match can be idenitified.
*/
enum AVColorPrimaries av_csp_primaries_id_from_desc(const AVColorPrimariesDesc *prm);
/**
* Determine a suitable 'gamma' value to match the supplied
* AVColorTransferCharacteristic.
*
* See Apple Technical Note TN2257 (https://developer.apple.com/library/mac/technotes/tn2257/_index.html)
*
* This function returns the gamma exponent for the OETF. For example, sRGB is approximated
* by gamma 2.2, not by gamma 0.45455.
*
* @return Will return an approximation to the simple gamma function matching
* the supplied Transfer Characteristic, Will return 0.0 for any
* we cannot reasonably match against.
*/
double av_csp_approximate_trc_gamma(enum AVColorTransferCharacteristic trc);
/**
* Determine the function needed to apply the given
* AVColorTransferCharacteristic to linear input.
*
* The function returned should expect a nominal domain and range of [0.0-1.0]
* values outside of this range maybe valid depending on the chosen
* characteristic function.
*
* @return Will return pointer to the function matching the
* supplied Transfer Characteristic. If unspecified will
* return NULL:
*/
av_csp_trc_function av_csp_trc_func_from_id(enum AVColorTransferCharacteristic trc);
/**
* @}
*/
#endif /* AVUTIL_CSP_H */

8
src/3rdparty/win32_include/libavutil/des.h vendored
View File

@ -43,6 +43,8 @@ AVDES *av_des_alloc(void);
/** /**
* @brief Initializes an AVDES context. * @brief Initializes an AVDES context.
* *
* @param d pointer to a AVDES structure to initialize
* @param key pointer to the key to use
* @param key_bits must be 64 or 192 * @param key_bits must be 64 or 192
* @param decrypt 0 for encryption/CBC-MAC, 1 for decryption * @param decrypt 0 for encryption/CBC-MAC, 1 for decryption
* @return zero on success, negative value otherwise * @return zero on success, negative value otherwise
@ -52,9 +54,10 @@ int av_des_init(struct AVDES *d, const uint8_t *key, int key_bits, int decrypt);
/** /**
* @brief Encrypts / decrypts using the DES algorithm. * @brief Encrypts / decrypts using the DES algorithm.
* *
* @param count number of 8 byte blocks * @param d pointer to the AVDES structure
* @param dst destination array, can be equal to src, must be 8-byte aligned * @param dst destination array, can be equal to src, must be 8-byte aligned
* @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL * @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
* @param count number of 8 byte blocks
* @param iv initialization vector for CBC mode, if NULL then ECB will be used, * @param iv initialization vector for CBC mode, if NULL then ECB will be used,
* must be 8-byte aligned * must be 8-byte aligned
* @param decrypt 0 for encryption, 1 for decryption * @param decrypt 0 for encryption, 1 for decryption
@ -64,9 +67,10 @@ void av_des_crypt(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count,
/** /**
* @brief Calculates CBC-MAC using the DES algorithm. * @brief Calculates CBC-MAC using the DES algorithm.
* *
* @param count number of 8 byte blocks * @param d pointer to the AVDES structure
* @param dst destination array, can be equal to src, must be 8-byte aligned * @param dst destination array, can be equal to src, must be 8-byte aligned
* @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL * @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
* @param count number of 8 byte blocks
*/ */
void av_des_mac(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count); void av_des_mac(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count);

1
src/3rdparty/win32_include/libavutil/detection_bbox.h vendored
View File

@ -93,6 +93,7 @@ av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
* AVDetectionBBox, and initializes the variables. * AVDetectionBBox, and initializes the variables.
* Can be freed with a normal av_free() call. * Can be freed with a normal av_free() call.
* *
* @param nb_bboxes number of AVDetectionBBox structures to allocate
* @param out_size if non-NULL, the size in bytes of the resulting data array is * @param out_size if non-NULL, the size in bytes of the resulting data array is
* written here. * written here.
*/ */

125
src/3rdparty/win32_include/libavutil/dict.h vendored
View File

@ -39,13 +39,15 @@
* @brief Simple key:value store * @brief Simple key:value store
* *
* @{ * @{
* Dictionaries are used for storing key:value pairs. To create * Dictionaries are used for storing key-value pairs.
* an AVDictionary, simply pass an address of a NULL pointer to *
* av_dict_set(). NULL can be used as an empty dictionary wherever * - To **create an AVDictionary**, simply pass an address of a NULL
* a pointer to an AVDictionary is required. * pointer to av_dict_set(). NULL can be used as an empty dictionary
* Use av_dict_get() to retrieve an entry or iterate over all * wherever a pointer to an AVDictionary is required.
* entries and finally av_dict_free() to free the dictionary * - To **insert an entry**, use av_dict_set().
* and all its contents. * - Use av_dict_get() to **retrieve an entry**.
* - To **iterate over all entries**, use av_dict_iterate().
* - In order to **free the dictionary and all its contents**, use av_dict_free().
* *
@code @code
AVDictionary *d = NULL; // "create" an empty dictionary AVDictionary *d = NULL; // "create" an empty dictionary
@ -57,13 +59,18 @@
char *v = av_strdup("value"); // you can avoid copying them like this char *v = av_strdup("value"); // you can avoid copying them like this
av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL); av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) { while ((t = av_dict_iterate(d, t))) {
<....> // iterate over all entries in d <....> // iterate over all entries in d
} }
av_dict_free(&d); av_dict_free(&d);
@endcode @endcode
*/ */
/**
* @name AVDictionary Flags
* Flags that influence behavior of the matching of keys or insertion to the dictionary.
* @{
*/
#define AV_DICT_MATCH_CASE 1 /**< Only get an entry with exact-case key match. Only relevant in av_dict_get(). */ #define AV_DICT_MATCH_CASE 1 /**< Only get an entry with exact-case key match. Only relevant in av_dict_get(). */
#define AV_DICT_IGNORE_SUFFIX 2 /**< Return first entry in a dictionary whose first part corresponds to the search key, #define AV_DICT_IGNORE_SUFFIX 2 /**< Return first entry in a dictionary whose first part corresponds to the search key,
ignoring the suffix of the found key string. Only relevant in av_dict_get(). */ ignoring the suffix of the found key string. Only relevant in av_dict_get(). */
@ -71,10 +78,13 @@
allocated with av_malloc() or another memory allocation function. */ allocated with av_malloc() or another memory allocation function. */
#define AV_DICT_DONT_STRDUP_VAL 8 /**< Take ownership of a value that's been #define AV_DICT_DONT_STRDUP_VAL 8 /**< Take ownership of a value that's been
allocated with av_malloc() or another memory allocation function. */ allocated with av_malloc() or another memory allocation function. */
#define AV_DICT_DONT_OVERWRITE 16 ///< Don't overwrite existing entries. #define AV_DICT_DONT_OVERWRITE 16 /**< Don't overwrite existing entries. */
#define AV_DICT_APPEND 32 /**< If the entry already exists, append to it. Note that no #define AV_DICT_APPEND 32 /**< If the entry already exists, append to it. Note that no
delimiter is added, the strings are simply concatenated. */ delimiter is added, the strings are simply concatenated. */
#define AV_DICT_MULTIKEY 64 /**< Allow to store several equal keys in the dictionary */ #define AV_DICT_MULTIKEY 64 /**< Allow to store several equal keys in the dictionary */
/**
* @}
*/
typedef struct AVDictionaryEntry { typedef struct AVDictionaryEntry {
char *key; char *key;
@ -89,18 +99,44 @@ typedef struct AVDictionary AVDictionary;
* The returned entry key or value must not be changed, or it will * The returned entry key or value must not be changed, or it will
* cause undefined behavior. * cause undefined behavior.
* *
* To iterate through all the dictionary entries, you can set the matching key * @param prev Set to the previous matching element to find the next.
* to the null string "" and set the AV_DICT_IGNORE_SUFFIX flag. * If set to NULL the first matching element is returned.
* @param key Matching key
* @param flags A collection of AV_DICT_* flags controlling how the
* entry is retrieved
* *
* @param prev Set to the previous matching element to find the next. * @return Found entry or NULL in case no matching entry was found in the dictionary
* If set to NULL the first matching element is returned.
* @param key matching key
* @param flags a collection of AV_DICT_* flags controlling how the entry is retrieved
* @return found entry or NULL in case no matching entry was found in the dictionary
*/ */
AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key, AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
const AVDictionaryEntry *prev, int flags); const AVDictionaryEntry *prev, int flags);
/**
* Iterate over a dictionary
*
* Iterates through all entries in the dictionary.
*
* @warning The returned AVDictionaryEntry key/value must not be changed.
*
* @warning As av_dict_set() invalidates all previous entries returned
* by this function, it must not be called while iterating over the dict.
*
* Typical usage:
* @code
* const AVDictionaryEntry *e = NULL;
* while ((e = av_dict_iterate(m, e))) {
* // ...
* }
* @endcode
*
* @param m The dictionary to iterate over
* @param prev Pointer to the previous AVDictionaryEntry, NULL initially
*
* @retval AVDictionaryEntry* The next element in the dictionary
* @retval NULL No more elements in the dictionary
*/
const AVDictionaryEntry *av_dict_iterate(const AVDictionary *m,
const AVDictionaryEntry *prev);
/** /**
* Get number of entries in dictionary. * Get number of entries in dictionary.
* *
@ -115,23 +151,24 @@ int av_dict_count(const AVDictionary *m);
* Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set, * Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,
* these arguments will be freed on error. * these arguments will be freed on error.
* *
* Warning: Adding a new entry to a dictionary invalidates all existing entries * @warning Adding a new entry to a dictionary invalidates all existing entries
* previously returned with av_dict_get. * previously returned with av_dict_get() or av_dict_iterate().
* *
* @param pm pointer to a pointer to a dictionary struct. If *pm is NULL * @param pm Pointer to a pointer to a dictionary struct. If *pm is NULL
* a dictionary struct is allocated and put in *pm. * a dictionary struct is allocated and put in *pm.
* @param key entry key to add to *pm (will either be av_strduped or added as a new key depending on flags) * @param key Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
* @param value entry value to add to *pm (will be av_strduped or added as a new key depending on flags). * @param value Entry value to add to *pm (will be av_strduped or added as a new key depending on flags).
* Passing a NULL value will cause an existing entry to be deleted. * Passing a NULL value will cause an existing entry to be deleted.
* @return >= 0 on success otherwise an error code <0 *
* @return >= 0 on success otherwise an error code <0
*/ */
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags); int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
/** /**
* Convenience wrapper for av_dict_set that converts the value to a string * Convenience wrapper for av_dict_set() that converts the value to a string
* and stores it. * and stores it.
* *
* Note: If AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error. * Note: If ::AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.
*/ */
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags); int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
@ -141,14 +178,15 @@ int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags
* In case of failure, all the successfully set entries are stored in * In case of failure, all the successfully set entries are stored in
* *pm. You may need to manually free the created dictionary. * *pm. You may need to manually free the created dictionary.
* *
* @param key_val_sep a 0-terminated list of characters used to separate * @param key_val_sep A 0-terminated list of characters used to separate
* key from value * key from value
* @param pairs_sep a 0-terminated list of characters used to separate * @param pairs_sep A 0-terminated list of characters used to separate
* two pairs from each other * two pairs from each other
* @param flags flags to use when adding to dictionary. * @param flags Flags to use when adding to the dictionary.
* AV_DICT_DONT_STRDUP_KEY and AV_DICT_DONT_STRDUP_VAL * ::AV_DICT_DONT_STRDUP_KEY and ::AV_DICT_DONT_STRDUP_VAL
* are ignored since the key/value tokens will always * are ignored since the key/value tokens will always
* be duplicated. * be duplicated.
*
* @return 0 on success, negative AVERROR code on failure * @return 0 on success, negative AVERROR code on failure
*/ */
int av_dict_parse_string(AVDictionary **pm, const char *str, int av_dict_parse_string(AVDictionary **pm, const char *str,
@ -157,11 +195,14 @@ int av_dict_parse_string(AVDictionary **pm, const char *str,
/** /**
* Copy entries from one AVDictionary struct into another. * Copy entries from one AVDictionary struct into another.
* @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL, *
* this function will allocate a struct for you and put it in *dst * @note Metadata is read using the ::AV_DICT_IGNORE_SUFFIX flag
* @param src pointer to source AVDictionary struct *
* @param flags flags to use when setting entries in *dst * @param dst Pointer to a pointer to a AVDictionary struct to copy into. If *dst is NULL,
* @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag * this function will allocate a struct for you and put it in *dst
* @param src Pointer to the source AVDictionary struct to copy items from.
* @param flags Flags to use when setting entries in *dst
*
* @return 0 on success, negative AVERROR code on failure. If dst was allocated * @return 0 on success, negative AVERROR code on failure. If dst was allocated
* by this function, callers should free the associated memory. * by this function, callers should free the associated memory.
*/ */
@ -180,13 +221,15 @@ void av_dict_free(AVDictionary **m);
* Such string may be passed back to av_dict_parse_string(). * Such string may be passed back to av_dict_parse_string().
* @note String is escaped with backslashes ('\'). * @note String is escaped with backslashes ('\').
* *
* @param[in] m dictionary * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
*
* @param[in] m The dictionary
* @param[out] buffer Pointer to buffer that will be allocated with string containg entries. * @param[out] buffer Pointer to buffer that will be allocated with string containg entries.
* Buffer must be freed by the caller when is no longer needed. * Buffer must be freed by the caller when is no longer needed.
* @param[in] key_val_sep character used to separate key from value * @param[in] key_val_sep Character used to separate key from value
* @param[in] pairs_sep character used to separate two pairs from each other * @param[in] pairs_sep Character used to separate two pairs from each other
*
* @return >= 0 on success, negative on error * @return >= 0 on success, negative on error
* @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
*/ */
int av_dict_get_string(const AVDictionary *m, char **buffer, int av_dict_get_string(const AVDictionary *m, char **buffer,
const char key_val_sep, const char pairs_sep); const char key_val_sep, const char pairs_sep);

21
src/3rdparty/win32_include/libavutil/display.h vendored
View File

@ -20,6 +20,7 @@
/** /**
* @file * @file
* @ingroup lavu_video_display
* Display matrix * Display matrix
*/ */
@ -27,18 +28,11 @@
#define AVUTIL_DISPLAY_H #define AVUTIL_DISPLAY_H
#include <stdint.h> #include <stdint.h>
#include "common.h"
/** /**
* @addtogroup lavu_video
* @{
*
* @defgroup lavu_video_display Display transformation matrix functions * @defgroup lavu_video_display Display transformation matrix functions
* @{ * @ingroup lavu_video
*/ *
/**
* @addtogroup lavu_video_display
* The display transformation matrix specifies an affine transformation that * The display transformation matrix specifies an affine transformation that
* should be applied to video frames for correct presentation. It is compatible * should be applied to video frames for correct presentation. It is compatible
* with the matrices stored in the ISO/IEC 14496-12 container format. * with the matrices stored in the ISO/IEC 14496-12 container format.
@ -72,6 +66,8 @@
* q' = (b * p + d * q + y) / z; * q' = (b * p + d * q + y) / z;
* z = u * p + v * q + w * z = u * p + v * q + w
* @endcode * @endcode
*
* @{
*/ */
/** /**
@ -91,8 +87,8 @@ double av_display_rotation_get(const int32_t matrix[9]);
* Initialize a transformation matrix describing a pure clockwise * Initialize a transformation matrix describing a pure clockwise
* rotation by the specified angle (in degrees). * rotation by the specified angle (in degrees).
* *
* @param matrix an allocated transformation matrix (will be fully overwritten * @param[out] matrix a transformation matrix (will be fully overwritten
* by this function) * by this function)
* @param angle rotation angle in degrees. * @param angle rotation angle in degrees.
*/ */
void av_display_rotation_set(int32_t matrix[9], double angle); void av_display_rotation_set(int32_t matrix[9], double angle);
@ -100,14 +96,13 @@ void av_display_rotation_set(int32_t matrix[9], double angle);
/** /**
* Flip the input matrix horizontally and/or vertically. * Flip the input matrix horizontally and/or vertically.
* *
* @param matrix an allocated transformation matrix * @param[in,out] matrix a transformation matrix
* @param hflip whether the matrix should be flipped horizontally * @param hflip whether the matrix should be flipped horizontally
* @param vflip whether the matrix should be flipped vertically * @param vflip whether the matrix should be flipped vertically
*/ */
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip); void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip);
/** /**
* @}
* @} * @}
*/ */

7
src/3rdparty/win32_include/libavutil/eval.h vendored
View File

@ -26,8 +26,6 @@
#ifndef AVUTIL_EVAL_H #ifndef AVUTIL_EVAL_H
#define AVUTIL_EVAL_H #define AVUTIL_EVAL_H
#include "avutil.h"
typedef struct AVExpr AVExpr; typedef struct AVExpr AVExpr;
/** /**
@ -44,6 +42,7 @@ typedef struct AVExpr AVExpr;
* @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
* @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
* @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
* @param log_offset log level offset, can be used to silence error messages
* @param log_ctx parent logging context * @param log_ctx parent logging context
* @return >= 0 in case of success, a negative value corresponding to an * @return >= 0 in case of success, a negative value corresponding to an
* AVERROR code otherwise * AVERROR code otherwise
@ -67,6 +66,7 @@ int av_expr_parse_and_eval(double *res, const char *s,
* @param funcs1 NULL terminated array of function pointers for functions which take 1 argument * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument
* @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
* @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
* @param log_offset log level offset, can be used to silence error messages
* @param log_ctx parent logging context * @param log_ctx parent logging context
* @return >= 0 in case of success, a negative value corresponding to an * @return >= 0 in case of success, a negative value corresponding to an
* AVERROR code otherwise * AVERROR code otherwise
@ -80,6 +80,7 @@ int av_expr_parse(AVExpr **expr, const char *s,
/** /**
* Evaluate a previously parsed expression. * Evaluate a previously parsed expression.
* *
* @param e the AVExpr to evaluate
* @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names * @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names
* @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
* @return the value of the expression * @return the value of the expression
@ -89,6 +90,7 @@ double av_expr_eval(AVExpr *e, const double *const_values, void *opaque);
/** /**
* Track the presence of variables and their number of occurrences in a parsed expression * Track the presence of variables and their number of occurrences in a parsed expression
* *
* @param e the AVExpr to track variables in
* @param counter a zero-initialized array where the count of each variable will be stored * @param counter a zero-initialized array where the count of each variable will be stored
* @param size size of array * @param size size of array
* @return 0 on success, a negative value indicates that no expression or array was passed * @return 0 on success, a negative value indicates that no expression or array was passed
@ -100,6 +102,7 @@ int av_expr_count_vars(AVExpr *e, unsigned *counter, int size);
* Track the presence of user provided functions and their number of occurrences * Track the presence of user provided functions and their number of occurrences
* in a parsed expression. * in a parsed expression.
* *
* @param e the AVExpr to track user provided functions in
* @param counter a zero-initialized array where the count of each function will be stored * @param counter a zero-initialized array where the count of each function will be stored
* if you passed 5 functions with 2 arguments to av_expr_parse() * if you passed 5 functions with 2 arguments to av_expr_parse()
* then for arg=2 this will use upto 5 entries. * then for arg=2 this will use upto 5 entries.

2
src/3rdparty/win32_include/libavutil/ffversion.h vendored
View File

@ -1,5 +1,5 @@
/* Automatically generated by version.sh, do not manually edit! */ /* Automatically generated by version.sh, do not manually edit! */
#ifndef AVUTIL_FFVERSION_H #ifndef AVUTIL_FFVERSION_H
#define AVUTIL_FFVERSION_H #define AVUTIL_FFVERSION_H
#define FFMPEG_VERSION "5.0" #define FFMPEG_VERSION "6.0"
#endif /* AVUTIL_FFVERSION_H */ #endif /* AVUTIL_FFVERSION_H */

277
src/3rdparty/win32_include/libavutil/fifo.h vendored
View File

@ -18,16 +18,229 @@
/** /**
* @file * @file
* a very simple circular buffer FIFO implementation * @ingroup lavu_fifo
* A generic FIFO API
*/ */
#ifndef AVUTIL_FIFO_H #ifndef AVUTIL_FIFO_H
#define AVUTIL_FIFO_H #define AVUTIL_FIFO_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "avutil.h"
#include "attributes.h"
#include "attributes.h"
#include "version.h"
/**
* @defgroup lavu_fifo AVFifo
* @ingroup lavu_data
*
* @{
* A generic FIFO API
*/
typedef struct AVFifo AVFifo;
/**
* Callback for writing or reading from a FIFO, passed to (and invoked from) the
* av_fifo_*_cb() functions. It may be invoked multiple times from a single
* av_fifo_*_cb() call and may process less data than the maximum size indicated
* by nb_elems.
*
* @param opaque the opaque pointer provided to the av_fifo_*_cb() function
* @param buf the buffer for reading or writing the data, depending on which
* av_fifo_*_cb function is called
* @param nb_elems On entry contains the maximum number of elements that can be
* read from / written into buf. On success, the callback should
* update it to contain the number of elements actually written.
*
* @return 0 on success, a negative error code on failure (will be returned from
* the invoking av_fifo_*_cb() function)
*/
typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems);
/**
* Automatically resize the FIFO on writes, so that the data fits. This
* automatic resizing happens up to a limit that can be modified with
* av_fifo_auto_grow_limit().
*/
#define AV_FIFO_FLAG_AUTO_GROW (1 << 0)
/**
* Allocate and initialize an AVFifo with a given element size.
*
* @param elems initial number of elements that can be stored in the FIFO
* @param elem_size Size in bytes of a single element. Further operations on
* the returned FIFO will implicitly use this element size.
* @param flags a combination of AV_FIFO_FLAG_*
*
* @return newly-allocated AVFifo on success, a negative error code on failure
*/
AVFifo *av_fifo_alloc2(size_t elems, size_t elem_size,
unsigned int flags);
/**
* @return Element size for FIFO operations. This element size is set at
* FIFO allocation and remains constant during its lifetime
*/
size_t av_fifo_elem_size(const AVFifo *f);
/**
* Set the maximum size (in elements) to which the FIFO can be resized
* automatically. Has no effect unless AV_FIFO_FLAG_AUTO_GROW is used.
*/
void av_fifo_auto_grow_limit(AVFifo *f, size_t max_elems);
/**
* @return number of elements available for reading from the given FIFO.
*/
size_t av_fifo_can_read(const AVFifo *f);
/**
* @return Number of elements that can be written into the given FIFO without
* growing it.
*
* In other words, this number of elements or less is guaranteed to fit
* into the FIFO. More data may be written when the
* AV_FIFO_FLAG_AUTO_GROW flag was specified at FIFO creation, but this
* may involve memory allocation, which can fail.
*/
size_t av_fifo_can_write(const AVFifo *f);
/**
* Enlarge an AVFifo.
*
* On success, the FIFO will be large enough to hold exactly
* inc + av_fifo_can_read() + av_fifo_can_write()
* elements. In case of failure, the old FIFO is kept unchanged.
*
* @param f AVFifo to resize
* @param inc number of elements to allocate for, in addition to the current
* allocated size
* @return a non-negative number on success, a negative error code on failure
*/
int av_fifo_grow2(AVFifo *f, size_t inc);
/**
* Write data into a FIFO.
*
* In case nb_elems > av_fifo_can_write(f) and the AV_FIFO_FLAG_AUTO_GROW flag
* was not specified at FIFO creation, nothing is written and an error
* is returned.
*
* Calling function is guaranteed to succeed if nb_elems <= av_fifo_can_write(f).
*
* @param f the FIFO buffer
* @param buf Data to be written. nb_elems * av_fifo_elem_size(f) bytes will be
* read from buf on success.
* @param nb_elems number of elements to write into FIFO
*
* @return a non-negative number on success, a negative error code on failure
*/
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems);
/**
* Write data from a user-provided callback into a FIFO.
*
* @param f the FIFO buffer
* @param read_cb Callback supplying the data to the FIFO. May be called
* multiple times.
* @param opaque opaque user data to be provided to read_cb
* @param nb_elems Should point to the maximum number of elements that can be
* written. Will be updated to contain the number of elements
* actually written.
*
* @return non-negative number on success, a negative error code on failure
*/
int av_fifo_write_from_cb(AVFifo *f, AVFifoCB read_cb,
void *opaque, size_t *nb_elems);
/**
* Read data from a FIFO.
*
* In case nb_elems > av_fifo_can_read(f), nothing is read and an error
* is returned.
*
* @param f the FIFO buffer
* @param buf Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes
* will be written into buf on success.
* @param nb_elems number of elements to read from FIFO
*
* @return a non-negative number on success, a negative error code on failure
*/
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems);
/**
* Feed data from a FIFO into a user-provided callback.
*
* @param f the FIFO buffer
* @param write_cb Callback the data will be supplied to. May be called
* multiple times.
* @param opaque opaque user data to be provided to write_cb
* @param nb_elems Should point to the maximum number of elements that can be
* read. Will be updated to contain the total number of elements
* actually sent to the callback.
*
* @return non-negative number on success, a negative error code on failure
*/
int av_fifo_read_to_cb(AVFifo *f, AVFifoCB write_cb,
void *opaque, size_t *nb_elems);
/**
* Read data from a FIFO without modifying FIFO state.
*
* Returns an error if an attempt is made to peek to nonexistent elements
* (i.e. if offset + nb_elems is larger than av_fifo_can_read(f)).
*
* @param f the FIFO buffer
* @param buf Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes
* will be written into buf.
* @param nb_elems number of elements to read from FIFO
* @param offset number of initial elements to skip.
*
* @return a non-negative number on success, a negative error code on failure
*/
int av_fifo_peek(AVFifo *f, void *buf, size_t nb_elems, size_t offset);
/**
* Feed data from a FIFO into a user-provided callback.
*
* @param f the FIFO buffer
* @param write_cb Callback the data will be supplied to. May be called
* multiple times.
* @param opaque opaque user data to be provided to write_cb
* @param nb_elems Should point to the maximum number of elements that can be
* read. Will be updated to contain the total number of elements
* actually sent to the callback.
* @param offset number of initial elements to skip; offset + *nb_elems must not
* be larger than av_fifo_can_read(f).
*
* @return a non-negative number on success, a negative error code on failure
*/
int av_fifo_peek_to_cb(AVFifo *f, AVFifoCB write_cb, void *opaque,
size_t *nb_elems, size_t offset);
/**
* Discard the specified amount of data from an AVFifo.
* @param size number of elements to discard, MUST NOT be larger than
* av_fifo_can_read(f)
*/
void av_fifo_drain2(AVFifo *f, size_t size);
/*
* Empty the AVFifo.
* @param f AVFifo to reset
*/
void av_fifo_reset2(AVFifo *f);
/**
* Free an AVFifo and reset pointer to NULL.
* @param f Pointer to an AVFifo to free. *f == NULL is allowed.
*/
void av_fifo_freep2(AVFifo **f);
#if FF_API_FIFO_OLD_API
typedef struct AVFifoBuffer { typedef struct AVFifoBuffer {
uint8_t *buffer; uint8_t *buffer;
uint8_t *rptr, *wptr, *end; uint8_t *rptr, *wptr, *end;
@ -38,7 +251,9 @@ typedef struct AVFifoBuffer {
* Initialize an AVFifoBuffer. * Initialize an AVFifoBuffer.
* @param size of FIFO * @param size of FIFO
* @return AVFifoBuffer or NULL in case of memory allocation failure * @return AVFifoBuffer or NULL in case of memory allocation failure
* @deprecated use av_fifo_alloc2()
*/ */
attribute_deprecated
AVFifoBuffer *av_fifo_alloc(unsigned int size); AVFifoBuffer *av_fifo_alloc(unsigned int size);
/** /**
@ -46,25 +261,33 @@ AVFifoBuffer *av_fifo_alloc(unsigned int size);
* @param nmemb number of elements * @param nmemb number of elements
* @param size size of the single element * @param size size of the single element
* @return AVFifoBuffer or NULL in case of memory allocation failure * @return AVFifoBuffer or NULL in case of memory allocation failure
* @deprecated use av_fifo_alloc2()
*/ */
attribute_deprecated
AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size); AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size);
/** /**
* Free an AVFifoBuffer. * Free an AVFifoBuffer.
* @param f AVFifoBuffer to free * @param f AVFifoBuffer to free
* @deprecated use the AVFifo API with av_fifo_freep2()
*/ */
attribute_deprecated
void av_fifo_free(AVFifoBuffer *f); void av_fifo_free(AVFifoBuffer *f);
/** /**
* Free an AVFifoBuffer and reset pointer to NULL. * Free an AVFifoBuffer and reset pointer to NULL.
* @param f AVFifoBuffer to free * @param f AVFifoBuffer to free
* @deprecated use the AVFifo API with av_fifo_freep2()
*/ */
attribute_deprecated
void av_fifo_freep(AVFifoBuffer **f); void av_fifo_freep(AVFifoBuffer **f);
/** /**
* Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied. * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
* @param f AVFifoBuffer to reset * @param f AVFifoBuffer to reset
* @deprecated use av_fifo_reset2() with the new AVFifo-API
*/ */
attribute_deprecated
void av_fifo_reset(AVFifoBuffer *f); void av_fifo_reset(AVFifoBuffer *f);
/** /**
@ -72,7 +295,9 @@ void av_fifo_reset(AVFifoBuffer *f);
* amount of data you can read from it. * amount of data you can read from it.
* @param f AVFifoBuffer to read from * @param f AVFifoBuffer to read from
* @return size * @return size
* @deprecated use av_fifo_can_read() with the new AVFifo-API
*/ */
attribute_deprecated
int av_fifo_size(const AVFifoBuffer *f); int av_fifo_size(const AVFifoBuffer *f);
/** /**
@ -80,7 +305,9 @@ int av_fifo_size(const AVFifoBuffer *f);
* amount of data you can write into it. * amount of data you can write into it.
* @param f AVFifoBuffer to write into * @param f AVFifoBuffer to write into
* @return size * @return size
* @deprecated use av_fifo_can_write() with the new AVFifo-API
*/ */
attribute_deprecated
int av_fifo_space(const AVFifoBuffer *f); int av_fifo_space(const AVFifoBuffer *f);
/** /**
@ -91,7 +318,13 @@ int av_fifo_space(const AVFifoBuffer *f);
* @param buf_size number of bytes to read * @param buf_size number of bytes to read
* @param func generic read function * @param func generic read function
* @param dest data destination * @param dest data destination
*
* @return a non-negative number on success, a negative error code on failure
*
* @deprecated use the new AVFifo-API with av_fifo_peek() when func == NULL,
* av_fifo_peek_to_cb() otherwise
*/ */
attribute_deprecated
int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void (*func)(void*, void*, int)); int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void (*func)(void*, void*, int));
/** /**
@ -101,7 +334,13 @@ int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_siz
* @param buf_size number of bytes to read * @param buf_size number of bytes to read
* @param func generic read function * @param func generic read function
* @param dest data destination * @param dest data destination
*
* @return a non-negative number on success, a negative error code on failure
*
* @deprecated use the new AVFifo-API with av_fifo_peek() when func == NULL,
* av_fifo_peek_to_cb() otherwise
*/ */
attribute_deprecated
int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int)); int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
/** /**
@ -110,7 +349,13 @@ int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)
* @param buf_size number of bytes to read * @param buf_size number of bytes to read
* @param func generic read function * @param func generic read function
* @param dest data destination * @param dest data destination
*
* @return a non-negative number on success, a negative error code on failure
*
* @deprecated use the new AVFifo-API with av_fifo_read() when func == NULL,
* av_fifo_read_to_cb() otherwise
*/ */
attribute_deprecated
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int)); int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
/** /**
@ -124,8 +369,12 @@ int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)
* func must return the number of bytes written to dest_buf, or <= 0 to * func must return the number of bytes written to dest_buf, or <= 0 to
* indicate no more data available to write. * indicate no more data available to write.
* If func is NULL, src is interpreted as a simple byte array for source data. * If func is NULL, src is interpreted as a simple byte array for source data.
* @return the number of bytes written to the FIFO * @return the number of bytes written to the FIFO or a negative error code on failure
*
* @deprecated use the new AVFifo-API with av_fifo_write() when func == NULL,
* av_fifo_write_from_cb() otherwise
*/ */
attribute_deprecated
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int)); int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int));
/** /**
@ -135,7 +384,11 @@ int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void
* @param f AVFifoBuffer to resize * @param f AVFifoBuffer to resize
* @param size new AVFifoBuffer size in bytes * @param size new AVFifoBuffer size in bytes
* @return <0 for failure, >=0 otherwise * @return <0 for failure, >=0 otherwise
*
* @deprecated use the new AVFifo-API with av_fifo_grow2() to increase FIFO size,
* decreasing FIFO size is not supported
*/ */
attribute_deprecated
int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size); int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
/** /**
@ -146,16 +399,24 @@ int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
* @param f AVFifoBuffer to resize * @param f AVFifoBuffer to resize
* @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size() * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size()
* @return <0 for failure, >=0 otherwise * @return <0 for failure, >=0 otherwise
*
* @deprecated use the new AVFifo-API with av_fifo_grow2(); note that unlike
* this function it adds to the allocated size, rather than to the used size
*/ */
attribute_deprecated
int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space); int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space);
/** /**
* Read and discard the specified amount of data from an AVFifoBuffer. * Read and discard the specified amount of data from an AVFifoBuffer.
* @param f AVFifoBuffer to read from * @param f AVFifoBuffer to read from
* @param size amount of data to read in bytes * @param size amount of data to read in bytes
*
* @deprecated use the new AVFifo-API with av_fifo_drain2()
*/ */
attribute_deprecated
void av_fifo_drain(AVFifoBuffer *f, int size); void av_fifo_drain(AVFifoBuffer *f, int size);
#if FF_API_FIFO_PEEK2
/** /**
* Return a pointer to the data stored in a FIFO buffer at a certain offset. * Return a pointer to the data stored in a FIFO buffer at a certain offset.
* The FIFO buffer is not modified. * The FIFO buffer is not modified.
@ -165,7 +426,9 @@ void av_fifo_drain(AVFifoBuffer *f, int size);
* than the used buffer size or the returned pointer will * than the used buffer size or the returned pointer will
* point outside to the buffer data. * point outside to the buffer data.
* The used buffer size can be checked with av_fifo_size(). * The used buffer size can be checked with av_fifo_size().
* @deprecated use the new AVFifo-API with av_fifo_peek() or av_fifo_peek_to_cb()
*/ */
attribute_deprecated
static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs) static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
{ {
uint8_t *ptr = f->rptr + offs; uint8_t *ptr = f->rptr + offs;
@ -175,5 +438,11 @@ static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
ptr = f->end - (f->buffer - ptr); ptr = f->end - (f->buffer - ptr);
return ptr; return ptr;
} }
#endif
#endif
/**
* @}
*/
#endif /* AVUTIL_FIFO_H */ #endif /* AVUTIL_FIFO_H */

11
src/3rdparty/win32_include/libavutil/file.h vendored
View File

@ -19,9 +19,11 @@
#ifndef AVUTIL_FILE_H #ifndef AVUTIL_FILE_H
#define AVUTIL_FILE_H #define AVUTIL_FILE_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "avutil.h" #include "version.h"
#include "attributes.h"
/** /**
* @file * @file
@ -37,6 +39,9 @@
* case *bufptr will be set to NULL and *size will be set to 0. * case *bufptr will be set to NULL and *size will be set to 0.
* The returned buffer must be released with av_file_unmap(). * The returned buffer must be released with av_file_unmap().
* *
* @param filename path to the file
* @param[out] bufptr pointee is set to the mapped or allocated buffer
* @param[out] size pointee is set to the size in bytes of the buffer
* @param log_offset loglevel offset used for logging * @param log_offset loglevel offset used for logging
* @param log_ctx context used for logging * @param log_ctx context used for logging
* @return a non negative number in case of success, a negative value * @return a non negative number in case of success, a negative value
@ -49,11 +54,13 @@ int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
/** /**
* Unmap or free the buffer bufptr created by av_file_map(). * Unmap or free the buffer bufptr created by av_file_map().
* *
* @param bufptr the buffer previously created with av_file_map()
* @param size size in bytes of bufptr, must be the same as returned * @param size size in bytes of bufptr, must be the same as returned
* by av_file_map() * by av_file_map()
*/ */
void av_file_unmap(uint8_t *bufptr, size_t size); void av_file_unmap(uint8_t *bufptr, size_t size);
#if FF_API_AV_FOPEN_UTF8
/** /**
* Wrapper to work around the lack of mkstemp() on mingw. * Wrapper to work around the lack of mkstemp() on mingw.
* Also, tries to create file in /tmp first, if possible. * Also, tries to create file in /tmp first, if possible.
@ -66,6 +73,8 @@ void av_file_unmap(uint8_t *bufptr, size_t size);
* libraries and could interfere with the calling application. * libraries and could interfere with the calling application.
* @deprecated as fd numbers cannot be passed saftely between libs on some platforms * @deprecated as fd numbers cannot be passed saftely between libs on some platforms
*/ */
attribute_deprecated
int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx); int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx);
#endif
#endif /* AVUTIL_FILE_H */ #endif /* AVUTIL_FILE_H */

60
src/3rdparty/win32_include/libavutil/frame.h vendored
View File

@ -30,6 +30,7 @@
#include "avutil.h" #include "avutil.h"
#include "buffer.h" #include "buffer.h"
#include "channel_layout.h"
#include "dict.h" #include "dict.h"
#include "rational.h" #include "rational.h"
#include "samplefmt.h" #include "samplefmt.h"
@ -201,6 +202,18 @@ enum AVFrameSideDataType {
* libavutil/dovi_meta.h. * libavutil/dovi_meta.h.
*/ */
AV_FRAME_DATA_DOVI_METADATA, AV_FRAME_DATA_DOVI_METADATA,
/**
* HDR Vivid dynamic metadata associated with a video frame. The payload is
* an AVDynamicHDRVivid type and contains information for color
* volume transform - CUVA 005.1-2021.
*/
AV_FRAME_DATA_DYNAMIC_HDR_VIVID,
/**
* Ambient viewing environment metadata, as defined by H.274.
*/
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT,
}; };
enum AVActiveFormatDescription { enum AVActiveFormatDescription {
@ -438,14 +451,18 @@ typedef struct AVFrame {
*/ */
AVRational time_base; AVRational time_base;
#if FF_API_FRAME_PICTURE_NUMBER
/** /**
* picture number in bitstream order * picture number in bitstream order
*/ */
attribute_deprecated
int coded_picture_number; int coded_picture_number;
/** /**
* picture number in display order * picture number in display order
*/ */
attribute_deprecated
int display_picture_number; int display_picture_number;
#endif
/** /**
* quality (between 1 (good) and FF_LAMBDA_MAX (bad)) * quality (between 1 (good) and FF_LAMBDA_MAX (bad))
@ -478,6 +495,7 @@ typedef struct AVFrame {
*/ */
int palette_has_changed; int palette_has_changed;
#if FF_API_REORDERED_OPAQUE
/** /**
* reordered opaque 64 bits (generally an integer or a double precision float * reordered opaque 64 bits (generally an integer or a double precision float
* PTS but can be anything). * PTS but can be anything).
@ -485,18 +503,26 @@ typedef struct AVFrame {
* that time, * that time,
* the decoder reorders values as needed and sets AVFrame.reordered_opaque * the decoder reorders values as needed and sets AVFrame.reordered_opaque
* to exactly one of the values provided by the user through AVCodecContext.reordered_opaque * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque
*
* @deprecated Use AV_CODEC_FLAG_COPY_OPAQUE instead
*/ */
attribute_deprecated
int64_t reordered_opaque; int64_t reordered_opaque;
#endif
/** /**
* Sample rate of the audio data. * Sample rate of the audio data.
*/ */
int sample_rate; int sample_rate;
#if FF_API_OLD_CHANNEL_LAYOUT
/** /**
* Channel layout of the audio data. * Channel layout of the audio data.
* @deprecated use ch_layout instead
*/ */
attribute_deprecated
uint64_t channel_layout; uint64_t channel_layout;
#endif
/** /**
* AVBuffer references backing the data for this frame. All the pointers in * AVBuffer references backing the data for this frame. All the pointers in
@ -592,13 +618,18 @@ typedef struct AVFrame {
*/ */
int64_t pkt_pos; int64_t pkt_pos;
#if FF_API_PKT_DURATION
/** /**
* duration of the corresponding packet, expressed in * duration of the corresponding packet, expressed in
* AVStream->time_base units, 0 if unknown. * AVStream->time_base units, 0 if unknown.
* - encoding: unused * - encoding: unused
* - decoding: Read by user. * - decoding: Read by user.
*
* @deprecated use duration instead
*/ */
attribute_deprecated
int64_t pkt_duration; int64_t pkt_duration;
#endif
/** /**
* metadata. * metadata.
@ -620,12 +651,16 @@ typedef struct AVFrame {
#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4 #define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4
#define FF_DECODE_ERROR_DECODE_SLICES 8 #define FF_DECODE_ERROR_DECODE_SLICES 8
#if FF_API_OLD_CHANNEL_LAYOUT
/** /**
* number of audio channels, only used for audio. * number of audio channels, only used for audio.
* - encoding: unused * - encoding: unused
* - decoding: Read by user. * - decoding: Read by user.
* @deprecated use ch_layout instead
*/ */
attribute_deprecated
int channels; int channels;
#endif
/** /**
* size of the corresponding packet containing the compressed * size of the corresponding packet containing the compressed
@ -681,18 +716,19 @@ typedef struct AVFrame {
* for the target frame's private_ref field. * for the target frame's private_ref field.
*/ */
AVBufferRef *private_ref; AVBufferRef *private_ref;
/**
* Channel layout of the audio data.
*/
AVChannelLayout ch_layout;
/**
* Duration of the frame, in the same units as pts. 0 if unknown.
*/
int64_t duration;
} AVFrame; } AVFrame;
#if FF_API_COLORSPACE_NAME
/**
* Get the name of a colorspace.
* @return a static string identifying the colorspace; can be NULL.
* @deprecated use av_color_space_name()
*/
attribute_deprecated
const char *av_get_colorspace_name(enum AVColorSpace val);
#endif
/** /**
* Allocate an AVFrame and set its fields to default values. The resulting * Allocate an AVFrame and set its fields to default values. The resulting
* struct must be freed using av_frame_free(). * struct must be freed using av_frame_free().
@ -760,7 +796,7 @@ void av_frame_move_ref(AVFrame *dst, AVFrame *src);
* The following fields must be set on frame before calling this function: * The following fields must be set on frame before calling this function:
* - format (pixel format for video, sample format for audio) * - format (pixel format for video, sample format for audio)
* - width and height for video * - width and height for video
* - nb_samples and channel_layout for audio * - nb_samples and ch_layout for audio
* *
* This function will fill AVFrame.data and AVFrame.buf arrays and, if * This function will fill AVFrame.data and AVFrame.buf arrays and, if
* necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf. * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.
@ -797,7 +833,8 @@ int av_frame_is_writable(AVFrame *frame);
* Ensure that the frame data is writable, avoiding data copy if possible. * Ensure that the frame data is writable, avoiding data copy if possible.
* *
* Do nothing if the frame is writable, allocate new buffers and copy the data * Do nothing if the frame is writable, allocate new buffers and copy the data
* if it is not. * if it is not. Non-refcounted frames behave as non-writable, i.e. a copy
* is always made.
* *
* @return 0 on success, a negative AVERROR on error. * @return 0 on success, a negative AVERROR on error.
* *
@ -832,6 +869,7 @@ int av_frame_copy_props(AVFrame *dst, const AVFrame *src);
/** /**
* Get the buffer reference a given data plane is stored in. * Get the buffer reference a given data plane is stored in.
* *
* @param frame the frame to get the plane's buffer from
* @param plane index of the data plane of interest in frame->extended_data. * @param plane index of the data plane of interest in frame->extended_data.
* *
* @return the buffer reference that contains the plane or NULL if the input * @return the buffer reference that contains the plane or NULL if the input

285
src/3rdparty/win32_include/libavutil/hdr_dynamic_vivid_metadata.h vendored Normal file
View File

@ -0,0 +1,285 @@
/*
* Copyright (c) 2021 Limin Wang <lance.lmwang at gmail.com>
*
* 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 AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H
#define AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H
#include "frame.h"
#include "rational.h"
/**
* Color tone mapping parameters at a processing window in a dynamic metadata for
* CUVA 005.1:2021.
*/
typedef struct AVHDRVividColorToneMappingParams {
/**
* The nominal maximum display luminance of the targeted system display,
* in multiples of 1.0/4095 candelas per square metre. The value shall be in
* the range of 0.0 to 1.0, inclusive.
*/
AVRational targeted_system_display_maximum_luminance;
/**
* This flag indicates that transfer the base paramter(for value of 1)
*/
int base_enable_flag;
/**
* base_param_m_p in the base parameter,
* in multiples of 1.0/16383. The value shall be in
* the range of 0.0 to 1.0, inclusive.
*/
AVRational base_param_m_p;
/**
* base_param_m_m in the base parameter,
* in multiples of 1.0/10. The value shall be in
* the range of 0.0 to 6.3, inclusive.
*/
AVRational base_param_m_m;
/**
* base_param_m_a in the base parameter,
* in multiples of 1.0/1023. The value shall be in
* the range of 0.0 to 1.0 inclusive.
*/
AVRational base_param_m_a;
/**
* base_param_m_b in the base parameter,
* in multiples of 1/1023. The value shall be in
* the range of 0.0 to 1.0, inclusive.
*/
AVRational base_param_m_b;
/**
* base_param_m_n in the base parameter,
* in multiples of 1.0/10. The value shall be in
* the range of 0.0 to 6.3, inclusive.
*/
AVRational base_param_m_n;
/**
* indicates k1_0 in the base parameter,
* base_param_k1 <= 1: k1_0 = base_param_k1
* base_param_k1 > 1: reserved
*/
int base_param_k1;
/**
* indicates k2_0 in the base parameter,
* base_param_k2 <= 1: k2_0 = base_param_k2
* base_param_k2 > 1: reserved
*/
int base_param_k2;
/**
* indicates k3_0 in the base parameter,
* base_param_k3 == 1: k3_0 = base_param_k3
* base_param_k3 == 2: k3_0 = maximum_maxrgb
* base_param_k3 > 2: reserved
*/
int base_param_k3;
/**
* This flag indicates that delta mode of base paramter(for value of 1)
*/
int base_param_Delta_enable_mode;
/**
* base_param_Delta in the base parameter,
* in multiples of 1.0/127. The value shall be in
* the range of 0.0 to 1.0, inclusive.
*/
AVRational base_param_Delta;
/**
* indicates 3Spline_enable_flag in the base parameter,
* This flag indicates that transfer three Spline of base paramter(for value of 1)
*/
int three_Spline_enable_flag;
/**
* The number of three Spline. The value shall be in the range
* of 1 to 2, inclusive.
*/
int three_Spline_num;
/**
* The mode of three Spline. the value shall be in the range
* of 0 to 3, inclusive.
*/
int three_Spline_TH_mode;
/**
* three_Spline_TH_enable_MB is in the range of 0.0 to 1.0, inclusive
* and in multiples of 1.0/255.
*
*/
AVRational three_Spline_TH_enable_MB;
/**
* 3Spline_TH_enable of three Spline.
* The value shall be in the range of 0.0 to 1.0, inclusive.
* and in multiples of 1.0/4095.
*/
AVRational three_Spline_TH_enable;
/**
* 3Spline_TH_Delta1 of three Spline.
* The value shall be in the range of 0.0 to 0.25, inclusive,
* and in multiples of 0.25/1023.
*/
AVRational three_Spline_TH_Delta1;
/**
* 3Spline_TH_Delta2 of three Spline.
* The value shall be in the range of 0.0 to 0.25, inclusive,
* and in multiples of 0.25/1023.
*/
AVRational three_Spline_TH_Delta2;
/**
* 3Spline_enable_Strength of three Spline.
* The value shall be in the range of 0.0 to 1.0, inclusive,
* and in multiples of 1.0/255.
*/
AVRational three_Spline_enable_Strength;
} AVHDRVividColorToneMappingParams;
/**
* Color transform parameters at a processing window in a dynamic metadata for
* CUVA 005.1:2021.
*/
typedef struct AVHDRVividColorTransformParams {
/**
* Indicates the minimum brightness of the displayed content.
* The values should be in the range of 0.0 to 1.0,
* inclusive and in multiples of 1/4095.
*/
AVRational minimum_maxrgb;
/**
* Indicates the average brightness of the displayed content.
* The values should be in the range of 0.0 to 1.0,
* inclusive and in multiples of 1/4095.
*/
AVRational average_maxrgb;
/**
* Indicates the variance brightness of the displayed content.
* The values should be in the range of 0.0 to 1.0,
* inclusive and in multiples of 1/4095.
*/
AVRational variance_maxrgb;
/**
* Indicates the maximum brightness of the displayed content.
* The values should be in the range of 0.0 to 1.0, inclusive
* and in multiples of 1/4095.
*/
AVRational maximum_maxrgb;
/**
* This flag indicates that the metadata for the tone mapping function in
* the processing window is present (for value of 1).
*/
int tone_mapping_mode_flag;
/**
* The number of tone mapping param. The value shall be in the range
* of 1 to 2, inclusive.
*/
int tone_mapping_param_num;
/**
* The color tone mapping parameters.
*/
AVHDRVividColorToneMappingParams tm_params[2];
/**
* This flag indicates that the metadata for the color saturation mapping in
* the processing window is present (for value of 1).
*/
int color_saturation_mapping_flag;
/**
* The number of color saturation param. The value shall be in the range
* of 0 to 7, inclusive.
*/
int color_saturation_num;
/**
* Indicates the color correction strength parameter.
* The values should be in the range of 0.0 to 2.0, inclusive
* and in multiples of 1/128.
*/
AVRational color_saturation_gain[8];
} AVHDRVividColorTransformParams;
/**
* This struct represents dynamic metadata for color volume transform -
* CUVA 005.1:2021 standard
*
* To be used as payload of a AVFrameSideData or AVPacketSideData with the
* appropriate type.
*
* @note The struct should be allocated with
* av_dynamic_hdr_vivid_alloc() and its size is not a part of
* the public ABI.
*/
typedef struct AVDynamicHDRVivid {
/**
* The system start code. The value shall be set to 0x01.
*/
uint8_t system_start_code;
/**
* The number of processing windows. The value shall be set to 0x01
* if the system_start_code is 0x01.
*/
uint8_t num_windows;
/**
* The color transform parameters for every processing window.
*/
AVHDRVividColorTransformParams params[3];
} AVDynamicHDRVivid;
/**
* Allocate an AVDynamicHDRVivid structure and set its fields to
* default values. The resulting struct can be freed using av_freep().
*
* @return An AVDynamicHDRVivid filled with default values or NULL
* on failure.
*/
AVDynamicHDRVivid *av_dynamic_hdr_vivid_alloc(size_t *size);
/**
* Allocate a complete AVDynamicHDRVivid and add it to the frame.
* @param frame The frame which side data is added to.
*
* @return The AVDynamicHDRVivid structure to be filled by caller or NULL
* on failure.
*/
AVDynamicHDRVivid *av_dynamic_hdr_vivid_create_side_data(AVFrame *frame);
#endif /* AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H */

7
src/3rdparty/win32_include/libavutil/hwcontext.h vendored
View File

@ -249,7 +249,7 @@ const char *av_hwdevice_get_type_name(enum AVHWDeviceType type);
/** /**
* Iterate over supported device types. * Iterate over supported device types.
* *
* @param type AV_HWDEVICE_TYPE_NONE initially, then the previous type * @param prev AV_HWDEVICE_TYPE_NONE initially, then the previous type
* returned by this function in subsequent iterations. * returned by this function in subsequent iterations.
* @return The next usable device type from enum AVHWDeviceType, or * @return The next usable device type from enum AVHWDeviceType, or
* AV_HWDEVICE_TYPE_NONE if there are no more. * AV_HWDEVICE_TYPE_NONE if there are no more.
@ -571,6 +571,10 @@ enum {
* possible with the given arguments and hwframe setup, while other return * possible with the given arguments and hwframe setup, while other return
* values indicate that it failed somehow. * values indicate that it failed somehow.
* *
* On failure, the destination frame will be left blank, except for the
* hw_frames_ctx/format fields thay may have been set by the caller - those will
* be preserved as they were.
*
* @param dst Destination frame, to contain the mapping. * @param dst Destination frame, to contain the mapping.
* @param src Source frame, to be mapped. * @param src Source frame, to be mapped.
* @param flags Some combination of AV_HWFRAME_MAP_* flags. * @param flags Some combination of AV_HWFRAME_MAP_* flags.
@ -587,6 +591,7 @@ int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags);
* *
* @param derived_frame_ctx On success, a reference to the newly created * @param derived_frame_ctx On success, a reference to the newly created
* AVHWFramesContext. * AVHWFramesContext.
* @param format The AVPixelFormat for the derived context.
* @param derived_device_ctx A reference to the device to create the new * @param derived_device_ctx A reference to the device to create the new
* AVHWFramesContext on. * AVHWFramesContext on.
* @param source_frame_ctx A reference to an existing AVHWFramesContext * @param source_frame_ctx A reference to an existing AVHWFramesContext

25
src/3rdparty/win32_include/libavutil/hwcontext_mediacodec.h vendored
View File

@ -31,6 +31,31 @@ typedef struct AVMediaCodecDeviceContext {
* This is the default surface used by decoders on this device. * This is the default surface used by decoders on this device.
*/ */
void *surface; void *surface;
/**
* Pointer to ANativeWindow.
*
* It both surface and native_window is NULL, try to create it
* automatically if create_window is true and OS support
* createPersistentInputSurface.
*
* It can be used as output surface for decoder and input surface for
* encoder.
*/
void *native_window;
/**
* Enable createPersistentInputSurface automatically.
*
* Disabled by default.
*
* It can be enabled by setting this flag directly, or by setting
* AVDictionary of av_hwdevice_ctx_create(), with "create_window" as key.
* The second method is useful for ffmpeg cmdline, e.g., we can enable it
* via:
* -init_hw_device mediacodec=mediacodec,create_window=1
*/
int create_window;
} AVMediaCodecDeviceContext; } AVMediaCodecDeviceContext;
#endif /* AVUTIL_HWCONTEXT_MEDIACODEC_H */ #endif /* AVUTIL_HWCONTEXT_MEDIACODEC_H */

13
src/3rdparty/win32_include/libavutil/hwcontext_qsv.h vendored
View File

@ -19,7 +19,7 @@
#ifndef AVUTIL_HWCONTEXT_QSV_H #ifndef AVUTIL_HWCONTEXT_QSV_H
#define AVUTIL_HWCONTEXT_QSV_H #define AVUTIL_HWCONTEXT_QSV_H
#include <mfx/mfxvideo.h> #include <mfxvideo.h>
/** /**
* @file * @file
@ -34,6 +34,17 @@
*/ */
typedef struct AVQSVDeviceContext { typedef struct AVQSVDeviceContext {
mfxSession session; mfxSession session;
/**
* The mfxLoader handle used for mfxSession creation
*
* This field is only available for oneVPL user. For non-oneVPL user, this
* field must be set to NULL.
*
* Filled by the user before calling av_hwdevice_ctx_init() and should be
* cast to mfxLoader handle. Deallocating the AVHWDeviceContext will always
* release this interface.
*/
void *loader;
} AVQSVDeviceContext; } AVQSVDeviceContext;
/** /**

1
src/3rdparty/win32_include/libavutil/hwcontext_videotoolbox.h vendored
View File

@ -23,6 +23,7 @@
#include <VideoToolbox/VideoToolbox.h> #include <VideoToolbox/VideoToolbox.h>
#include "frame.h"
#include "pixfmt.h" #include "pixfmt.h"
/** /**

24
src/3rdparty/win32_include/libavutil/imgutils.h vendored
View File

@ -27,8 +27,10 @@
* @{ * @{
*/ */
#include "avutil.h" #include <stddef.h>
#include <stdint.h>
#include "pixdesc.h" #include "pixdesc.h"
#include "pixfmt.h"
#include "rational.h" #include "rational.h"
/** /**
@ -46,6 +48,7 @@
* component in the plane with the max pixel step. * component in the plane with the max pixel step.
* @param max_pixstep_comps an array which is filled with the component * @param max_pixstep_comps an array which is filled with the component
* for each plane which has the max pixel step. May be NULL. * for each plane which has the max pixel step. May be NULL.
* @param pixdesc the AVPixFmtDescriptor for the image, describing its format
*/ */
void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
const AVPixFmtDescriptor *pixdesc); const AVPixFmtDescriptor *pixdesc);
@ -63,6 +66,8 @@ int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane);
* width width. * width width.
* *
* @param linesizes array to be filled with the linesize for each plane * @param linesizes array to be filled with the linesize for each plane
* @param pix_fmt the AVPixelFormat of the image
* @param width width of the image in pixels
* @return >= 0 in case of success, a negative error code otherwise * @return >= 0 in case of success, a negative error code otherwise
*/ */
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width); int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width);
@ -71,6 +76,8 @@ int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int wi
* Fill plane sizes for an image with pixel format pix_fmt and height height. * Fill plane sizes for an image with pixel format pix_fmt and height height.
* *
* @param size the array to be filled with the size of each image plane * @param size the array to be filled with the size of each image plane
* @param pix_fmt the AVPixelFormat of the image
* @param height height of the image in pixels
* @param linesizes the array containing the linesize for each * @param linesizes the array containing the linesize for each
* plane, should be filled by av_image_fill_linesizes() * plane, should be filled by av_image_fill_linesizes()
* @return >= 0 in case of success, a negative error code otherwise * @return >= 0 in case of success, a negative error code otherwise
@ -86,6 +93,8 @@ int av_image_fill_plane_sizes(size_t size[4], enum AVPixelFormat pix_fmt,
* height height. * height height.
* *
* @param data pointers array to be filled with the pointer for each image plane * @param data pointers array to be filled with the pointer for each image plane
* @param pix_fmt the AVPixelFormat of the image
* @param height height of the image in pixels
* @param ptr the pointer to a buffer which will contain the image * @param ptr the pointer to a buffer which will contain the image
* @param linesizes the array containing the linesize for each * @param linesizes the array containing the linesize for each
* plane, should be filled by av_image_fill_linesizes() * plane, should be filled by av_image_fill_linesizes()
@ -101,6 +110,11 @@ int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int hei
* The allocated image buffer has to be freed by using * The allocated image buffer has to be freed by using
* av_freep(&pointers[0]). * av_freep(&pointers[0]).
* *
* @param pointers array to be filled with the pointer for each image plane
* @param linesizes the array filled with the linesize for each plane
* @param w width of the image in pixels
* @param h height of the image in pixels
* @param pix_fmt the AVPixelFormat of the image
* @param align the value to use for buffer size alignment * @param align the value to use for buffer size alignment
* @return the size in bytes required for the image buffer, a negative * @return the size in bytes required for the image buffer, a negative
* error code in case of failure * error code in case of failure
@ -117,8 +131,11 @@ int av_image_alloc(uint8_t *pointers[4], int linesizes[4],
* bytewidth must be contained by both absolute values of dst_linesize * bytewidth must be contained by both absolute values of dst_linesize
* and src_linesize, otherwise the function behavior is undefined. * and src_linesize, otherwise the function behavior is undefined.
* *
* @param dst destination plane to copy to
* @param dst_linesize linesize for the image plane in dst * @param dst_linesize linesize for the image plane in dst
* @param src source plane to copy from
* @param src_linesize linesize for the image plane in src * @param src_linesize linesize for the image plane in src
* @param height height (number of lines) of the plane
*/ */
void av_image_copy_plane(uint8_t *dst, int dst_linesize, void av_image_copy_plane(uint8_t *dst, int dst_linesize,
const uint8_t *src, int src_linesize, const uint8_t *src, int src_linesize,
@ -145,8 +162,13 @@ void av_image_copy_plane_uc_from(uint8_t *dst, ptrdiff_t dst_linesize,
/** /**
* Copy image in src_data to dst_data. * Copy image in src_data to dst_data.
* *
* @param dst_data destination image data buffer to copy to
* @param dst_linesizes linesizes for the image in dst_data * @param dst_linesizes linesizes for the image in dst_data
* @param src_data source image data buffer to copy from
* @param src_linesizes linesizes for the image in src_data * @param src_linesizes linesizes for the image in src_data
* @param pix_fmt the AVPixelFormat of the image
* @param width width of the image in pixels
* @param height height of the image in pixels
*/ */
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
const uint8_t *src_data[4], const int src_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4],

5
src/3rdparty/win32_include/libavutil/lfg.h vendored
View File

@ -27,7 +27,7 @@
/** /**
* Context structure for the Lagged Fibonacci PRNG. * Context structure for the Lagged Fibonacci PRNG.
* The exact layout, types and content of this struct may change and should * The exact layout, types and content of this struct may change and should
* not be accessed directly. Only its sizeof() is guranteed to stay the same * not be accessed directly. Only its `sizeof()` is guaranteed to stay the same
* to allow easy instanciation. * to allow easy instanciation.
*/ */
typedef struct AVLFG { typedef struct AVLFG {
@ -40,7 +40,7 @@ void av_lfg_init(AVLFG *c, unsigned int seed);
/** /**
* Seed the state of the ALFG using binary data. * Seed the state of the ALFG using binary data.
* *
* Return value: 0 on success, negative value (AVERROR) on failure. * @return 0 on success, negative value (AVERROR) on failure.
*/ */
int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length); int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length);
@ -73,6 +73,7 @@ static inline unsigned int av_mlfg_get(AVLFG *c){
* Get the next two numbers generated by a Box-Muller Gaussian * Get the next two numbers generated by a Box-Muller Gaussian
* generator using the random numbers issued by lfg. * generator using the random numbers issued by lfg.
* *
* @param lfg pointer to the contex structure
* @param out array where the two generated numbers are placed * @param out array where the two generated numbers are placed
*/ */
void av_bmg_get(AVLFG *lfg, double out[2]); void av_bmg_get(AVLFG *lfg, double out[2]);

2
src/3rdparty/win32_include/libavutil/log.h vendored
View File

@ -22,8 +22,8 @@
#define AVUTIL_LOG_H #define AVUTIL_LOG_H
#include <stdarg.h> #include <stdarg.h>
#include "avutil.h"
#include "attributes.h" #include "attributes.h"
#include "version.h"
typedef enum { typedef enum {
AV_CLASS_CATEGORY_NA = 0, AV_CLASS_CATEGORY_NA = 0,

6
src/3rdparty/win32_include/libavutil/mathematics.h vendored
View File

@ -111,7 +111,8 @@ enum AVRounding {
/** /**
* Compute the greatest common divisor of two integer operands. * Compute the greatest common divisor of two integer operands.
* *
* @param a,b Operands * @param a Operand
* @param b Operand
* @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0; * @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;
* if a == 0 and b == 0, returns 0. * if a == 0 and b == 0, returns 0.
*/ */
@ -186,7 +187,8 @@ int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
* av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02) * av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)
* @endcode * @endcode
* *
* @param a,b Operands * @param a Operand
* @param b Operand
* @param mod Divisor; must be a power of 2 * @param mod Divisor; must be a power of 2
* @return * @return
* - a negative value if `a % mod < b % mod` * - a negative value if `a % mod < b % mod`

114
src/3rdparty/win32_include/libavutil/mem.h vendored
View File

@ -51,86 +51,6 @@
* @{ * @{
*/ */
#if FF_API_DECLARE_ALIGNED
/**
*
* @defgroup lavu_mem_macros Alignment Macros
* Helper macros for declaring aligned variables.
* @{
*/
/**
* @def DECLARE_ALIGNED(n,t,v)
* Declare a variable that is aligned in memory.
*
* @code{.c}
* DECLARE_ALIGNED(16, uint16_t, aligned_int) = 42;
* DECLARE_ALIGNED(32, uint8_t, aligned_array)[128];
*
* // The default-alignment equivalent would be
* uint16_t aligned_int = 42;
* uint8_t aligned_array[128];
* @endcode
*
* @param n Minimum alignment in bytes
* @param t Type of the variable (or array element)
* @param v Name of the variable
*/
/**
* @def DECLARE_ASM_ALIGNED(n,t,v)
* Declare an aligned variable appropriate for use in inline assembly code.
*
* @code{.c}
* DECLARE_ASM_ALIGNED(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008);
* @endcode
*
* @param n Minimum alignment in bytes
* @param t Type of the variable (or array element)
* @param v Name of the variable
*/
/**
* @def DECLARE_ASM_CONST(n,t,v)
* Declare a static constant aligned variable appropriate for use in inline
* assembly code.
*
* @code{.c}
* DECLARE_ASM_CONST(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008);
* @endcode
*
* @param n Minimum alignment in bytes
* @param t Type of the variable (or array element)
* @param v Name of the variable
*/
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
#define DECLARE_ASM_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
#define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v
#elif defined(__DJGPP__)
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (FFMIN(n, 16)))) v
#define DECLARE_ASM_ALIGNED(n,t,v) t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
#define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
#elif defined(__GNUC__) || defined(__clang__)
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
#define DECLARE_ASM_ALIGNED(n,t,v) t av_used __attribute__ ((aligned (n))) v
#define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v
#elif defined(_MSC_VER)
#define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v
#define DECLARE_ASM_ALIGNED(n,t,v) __declspec(align(n)) t v
#define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v
#else
#define DECLARE_ALIGNED(n,t,v) t v
#define DECLARE_ASM_ALIGNED(n,t,v) t v
#define DECLARE_ASM_CONST(n,t,v) static const t v
#endif
/**
* @}
*/
#endif
/** /**
* @defgroup lavu_mem_attrs Function Attributes * @defgroup lavu_mem_attrs Function Attributes
* Function attributes applicable to memory handling functions. * Function attributes applicable to memory handling functions.
@ -239,19 +159,10 @@ av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
*/ */
void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2); void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
#if FF_API_AV_MALLOCZ_ARRAY
/**
* @deprecated use av_calloc()
*/
attribute_deprecated
void *av_mallocz_array(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
#endif
/** /**
* Allocate, reallocate, or free a block of memory. * Allocate, reallocate, or free a block of memory.
* *
* If `ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is * If `ptr` is `NULL` and `size` > 0, allocate a new block. Otherwise, expand or
* zero, free the memory block pointed to by `ptr`. Otherwise, expand or
* shrink that block of memory according to `size`. * shrink that block of memory according to `size`.
* *
* @param ptr Pointer to a memory block already allocated with * @param ptr Pointer to a memory block already allocated with
@ -260,10 +171,11 @@ void *av_mallocz_array(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size
* reallocated * reallocated
* *
* @return Pointer to a newly-reallocated block or `NULL` if the block * @return Pointer to a newly-reallocated block or `NULL` if the block
* cannot be reallocated or the function is used to free the memory block * cannot be reallocated
* *
* @warning Unlike av_malloc(), the returned pointer is not guaranteed to be * @warning Unlike av_malloc(), the returned pointer is not guaranteed to be
* correctly aligned. * correctly aligned. The returned pointer must be freed after even
* if size is zero.
* @see av_fast_realloc() * @see av_fast_realloc()
* @see av_reallocp() * @see av_reallocp()
*/ */
@ -311,8 +223,7 @@ void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
/** /**
* Allocate, reallocate, or free an array. * Allocate, reallocate, or free an array.
* *
* If `ptr` is `NULL` and `nmemb` > 0, allocate a new block. If * If `ptr` is `NULL` and `nmemb` > 0, allocate a new block.
* `nmemb` is zero, free the memory block pointed to by `ptr`.
* *
* @param ptr Pointer to a memory block already allocated with * @param ptr Pointer to a memory block already allocated with
* av_realloc() or `NULL` * av_realloc() or `NULL`
@ -320,19 +231,19 @@ void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
* @param size Size of the single element of the array * @param size Size of the single element of the array
* *
* @return Pointer to a newly-reallocated block or NULL if the block * @return Pointer to a newly-reallocated block or NULL if the block
* cannot be reallocated or the function is used to free the memory block * cannot be reallocated
* *
* @warning Unlike av_malloc(), the allocated memory is not guaranteed to be * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
* correctly aligned. * correctly aligned. The returned pointer must be freed after even if
* nmemb is zero.
* @see av_reallocp_array() * @see av_reallocp_array()
*/ */
av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size); av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
/** /**
* Allocate, reallocate, or free an array through a pointer to a pointer. * Allocate, reallocate an array through a pointer to a pointer.
* *
* If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block. If `nmemb` is * If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block.
* zero, free the memory block pointed to by `*ptr`.
* *
* @param[in,out] ptr Pointer to a pointer to a memory block already * @param[in,out] ptr Pointer to a pointer to a memory block already
* allocated with av_realloc(), or a pointer to `NULL`. * allocated with av_realloc(), or a pointer to `NULL`.
@ -343,7 +254,7 @@ av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
* @return Zero on success, an AVERROR error code on failure * @return Zero on success, an AVERROR error code on failure
* *
* @warning Unlike av_malloc(), the allocated memory is not guaranteed to be * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
* correctly aligned. * correctly aligned. *ptr must be freed after even if nmemb is zero.
*/ */
int av_reallocp_array(void *ptr, size_t nmemb, size_t size); int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
@ -668,7 +579,8 @@ void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
/** /**
* Multiply two `size_t` values checking for overflow. * Multiply two `size_t` values checking for overflow.
* *
* @param[in] a,b Operands of multiplication * @param[in] a Operand of multiplication
* @param[in] b Operand of multiplication
* @param[out] r Pointer to the result of the operation * @param[out] r Pointer to the result of the operation
* @return 0 on success, AVERROR(EINVAL) on overflow * @return 0 on success, AVERROR(EINVAL) on overflow
*/ */

12
src/3rdparty/win32_include/libavutil/opt.h vendored
View File

@ -29,6 +29,7 @@
#include "rational.h" #include "rational.h"
#include "avutil.h" #include "avutil.h"
#include "channel_layout.h"
#include "dict.h" #include "dict.h"
#include "log.h" #include "log.h"
#include "pixfmt.h" #include "pixfmt.h"
@ -237,8 +238,11 @@ enum AVOptionType{
AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational
AV_OPT_TYPE_DURATION, AV_OPT_TYPE_DURATION,
AV_OPT_TYPE_COLOR, AV_OPT_TYPE_COLOR,
#if FF_API_OLD_CHANNEL_LAYOUT
AV_OPT_TYPE_CHANNEL_LAYOUT, AV_OPT_TYPE_CHANNEL_LAYOUT,
#endif
AV_OPT_TYPE_BOOL, AV_OPT_TYPE_BOOL,
AV_OPT_TYPE_CHLAYOUT,
}; };
/** /**
@ -693,7 +697,11 @@ int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_
int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags); int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags);
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags); int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags);
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags); int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags);
#if FF_API_OLD_CHANNEL_LAYOUT
attribute_deprecated
int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags); int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags);
#endif
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *layout, int search_flags);
/** /**
* @note Any old dictionary present is discarded and replaced with a copy of the new one. The * @note Any old dictionary present is discarded and replaced with a copy of the new one. The
* caller still owns val is and responsible for freeing it. * caller still owns val is and responsible for freeing it.
@ -748,7 +756,11 @@ int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_
int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt); int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt);
int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt); int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt);
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val); int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val);
#if FF_API_OLD_CHANNEL_LAYOUT
attribute_deprecated
int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout); int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout);
#endif
int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *layout);
/** /**
* @param[out] out_val The returned dictionary is a copy of the actual value and must * @param[out] out_val The returned dictionary is a copy of the actual value and must
* be freed with av_dict_free() by the caller * be freed with av_dict_free() by the caller

24
src/3rdparty/win32_include/libavutil/parseutils.h vendored
View File

@ -79,6 +79,8 @@ int av_parse_video_rate(AVRational *rate, const char *str);
/** /**
* Put the RGBA values that correspond to color_string in rgba_color. * Put the RGBA values that correspond to color_string in rgba_color.
* *
* @param rgba_color 4-elements array of uint8_t values, where the respective
* red, green, blue and alpha component values are written.
* @param color_string a string specifying a color. It can be the name of * @param color_string a string specifying a color. It can be the name of
* a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence, * a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence,
* possibly followed by "@" and a string representing the alpha * possibly followed by "@" and a string representing the alpha
@ -92,6 +94,8 @@ int av_parse_video_rate(AVRational *rate, const char *str);
* @param slen length of the initial part of color_string containing the * @param slen length of the initial part of color_string containing the
* color. It can be set to -1 if color_string is a null terminated string * color. It can be set to -1 if color_string is a null terminated string
* containing nothing else than the color. * containing nothing else than the color.
* @param log_ctx a pointer to an arbitrary struct of which the first field
* is a pointer to an AVClass struct (used for av_log()). Can be NULL.
* @return >= 0 in case of success, a negative value in case of * @return >= 0 in case of success, a negative value in case of
* failure (for example if color_string cannot be parsed). * failure (for example if color_string cannot be parsed).
*/ */
@ -106,7 +110,7 @@ int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
* av_parse_color(). * av_parse_color().
* *
* @param color_idx index of the requested color, starting from 0 * @param color_idx index of the requested color, starting from 0
* @param rgbp if not NULL, will point to a 3-elements array with the color value in RGB * @param rgb if not NULL, will point to a 3-elements array with the color value in RGB
* @return the color name string or NULL if color_idx is not in the array * @return the color name string or NULL if color_idx is not in the array
*/ */
const char *av_get_known_color_name(int color_idx, const uint8_t **rgb); const char *av_get_known_color_name(int color_idx, const uint8_t **rgb);
@ -162,19 +166,19 @@ int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info
* by the standard strptime(). * by the standard strptime().
* *
* The supported input field descriptors are listed below. * The supported input field descriptors are listed below.
* - %H: the hour as a decimal number, using a 24-hour clock, in the * - `%%H`: the hour as a decimal number, using a 24-hour clock, in the
* range '00' through '23' * range '00' through '23'
* - %J: hours as a decimal number, in the range '0' through INT_MAX * - `%%J`: hours as a decimal number, in the range '0' through INT_MAX
* - %M: the minute as a decimal number, using a 24-hour clock, in the * - `%%M`: the minute as a decimal number, using a 24-hour clock, in the
* range '00' through '59' * range '00' through '59'
* - %S: the second as a decimal number, using a 24-hour clock, in the * - `%%S`: the second as a decimal number, using a 24-hour clock, in the
* range '00' through '59' * range '00' through '59'
* - %Y: the year as a decimal number, using the Gregorian calendar * - `%%Y`: the year as a decimal number, using the Gregorian calendar
* - %m: the month as a decimal number, in the range '1' through '12' * - `%%m`: the month as a decimal number, in the range '1' through '12'
* - %d: the day of the month as a decimal number, in the range '1' * - `%%d`: the day of the month as a decimal number, in the range '1'
* through '31' * through '31'
* - %T: alias for '%H:%M:%S' * - `%%T`: alias for `%%H:%%M:%%S`
* - %%: a literal '%' * - `%%`: a literal `%`
* *
* @return a pointer to the first character not processed in this function * @return a pointer to the first character not processed in this function
* call. In case the input string contains more characters than * call. In case the input string contains more characters than

37
src/3rdparty/win32_include/libavutil/pixdesc.h vendored
View File

@ -264,6 +264,28 @@ const char *av_chroma_location_name(enum AVChromaLocation location);
*/ */
int av_chroma_location_from_name(const char *name); int av_chroma_location_from_name(const char *name);
/**
* Converts AVChromaLocation to swscale x/y chroma position.
*
* The positions represent the chroma (0,0) position in a coordinates system
* with luma (0,0) representing the origin and luma(1,1) representing 256,256
*
* @param xpos horizontal chroma sample position
* @param ypos vertical chroma sample position
*/
int av_chroma_location_enum_to_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
/**
* Converts swscale x/y chroma position to AVChromaLocation.
*
* The positions represent the chroma (0,0) position in a coordinates system
* with luma (0,0) representing the origin and luma(1,1) representing 256,256
*
* @param xpos horizontal chroma sample position
* @param ypos vertical chroma sample position
*/
enum AVChromaLocation av_chroma_location_pos_to_enum(int xpos, int ypos);
/** /**
* Return the pixel format corresponding to name. * Return the pixel format corresponding to name.
* *
@ -357,12 +379,15 @@ void av_write_image_line(const uint16_t *src, uint8_t *data[4],
*/ */
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt); enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt);
#define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */ #define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */
#define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */ #define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */
#define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */ #define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */
#define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */ #define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */
#define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */ #define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */
#define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */ #define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
#define FF_LOSS_EXCESS_RESOLUTION 0x0040 /**< loss due to unneeded extra resolution */
#define FF_LOSS_EXCESS_DEPTH 0x0080 /**< loss due to unneeded extra color depth */
/** /**
* Compute what kind of losses will occur when converting from one specific * Compute what kind of losses will occur when converting from one specific

1
src/3rdparty/win32_include/libavutil/pixelutils.h vendored
View File

@ -21,7 +21,6 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "common.h"
/** /**
* Sum of abs(src1[x] - src2[x]) * Sum of abs(src1[x] - src2[x])

70
src/3rdparty/win32_include/libavutil/pixfmt.h vendored
View File

@ -206,8 +206,36 @@ enum AVPixelFormat {
AV_PIX_FMT_GBRAP16BE, ///< planar GBRA 4:4:4:4 64bpp, big-endian AV_PIX_FMT_GBRAP16BE, ///< planar GBRA 4:4:4:4 64bpp, big-endian
AV_PIX_FMT_GBRAP16LE, ///< planar GBRA 4:4:4:4 64bpp, little-endian AV_PIX_FMT_GBRAP16LE, ///< planar GBRA 4:4:4:4 64bpp, little-endian
/** /**
* HW acceleration through QSV, data[3] contains a pointer to the * HW acceleration through QSV, data[3] contains a pointer to the
* mfxFrameSurface1 structure. * mfxFrameSurface1 structure.
*
* Before FFmpeg 5.0:
* mfxFrameSurface1.Data.MemId contains a pointer when importing
* the following frames as QSV frames:
*
* VAAPI:
* mfxFrameSurface1.Data.MemId contains a pointer to VASurfaceID
*
* DXVA2:
* mfxFrameSurface1.Data.MemId contains a pointer to IDirect3DSurface9
*
* FFmpeg 5.0 and above:
* mfxFrameSurface1.Data.MemId contains a pointer to the mfxHDLPair
* structure when importing the following frames as QSV frames:
*
* VAAPI:
* mfxHDLPair.first contains a VASurfaceID pointer.
* mfxHDLPair.second is always MFX_INFINITE.
*
* DXVA2:
* mfxHDLPair.first contains IDirect3DSurface9 pointer.
* mfxHDLPair.second is always MFX_INFINITE.
*
* D3D11:
* mfxHDLPair.first contains a ID3D11Texture2D pointer.
* mfxHDLPair.second contains the texture array index of the frame if the
* ID3D11Texture2D is an array texture, or always MFX_INFINITE if it is a
* normal texture.
*/ */
AV_PIX_FMT_QSV, AV_PIX_FMT_QSV,
/** /**
@ -260,7 +288,9 @@ enum AVPixelFormat {
AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
#if FF_API_XVMC
AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
#endif
AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
@ -360,11 +390,36 @@ enum AVPixelFormat {
AV_PIX_FMT_P410LE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian AV_PIX_FMT_P410LE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
AV_PIX_FMT_P216BE, ///< interleaved chroma YUV 4:2:2, 32bpp, big-endian AV_PIX_FMT_P216BE, ///< interleaved chroma YUV 4:2:2, 32bpp, big-endian
AV_PIX_FMT_P216LE, ///< interleaved chroma YUV 4:2:2, 32bpp, liddle-endian AV_PIX_FMT_P216LE, ///< interleaved chroma YUV 4:2:2, 32bpp, little-endian
AV_PIX_FMT_P416BE, ///< interleaved chroma YUV 4:4:4, 48bpp, big-endian AV_PIX_FMT_P416BE, ///< interleaved chroma YUV 4:4:4, 48bpp, big-endian
AV_PIX_FMT_P416LE, ///< interleaved chroma YUV 4:4:4, 48bpp, little-endian AV_PIX_FMT_P416LE, ///< interleaved chroma YUV 4:4:4, 48bpp, little-endian
AV_PIX_FMT_VUYA, ///< packed VUYA 4:4:4, 32bpp, VUYAVUYA...
AV_PIX_FMT_RGBAF16BE, ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian
AV_PIX_FMT_RGBAF16LE, ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian
AV_PIX_FMT_VUYX, ///< packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
AV_PIX_FMT_P012LE, ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian
AV_PIX_FMT_P012BE, ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian
AV_PIX_FMT_Y212BE, ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian
AV_PIX_FMT_Y212LE, ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian
AV_PIX_FMT_XV30BE, ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined
AV_PIX_FMT_XV30LE, ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined
AV_PIX_FMT_XV36BE, ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian, variant of Y412 where alpha channel is left undefined
AV_PIX_FMT_XV36LE, ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian, variant of Y412 where alpha channel is left undefined
AV_PIX_FMT_RGBF32BE, ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian
AV_PIX_FMT_RGBF32LE, ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian
AV_PIX_FMT_RGBAF32BE, ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian
AV_PIX_FMT_RGBAF32LE, ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian
AV_PIX_FMT_NB ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions AV_PIX_FMT_NB ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
}; };
@ -451,9 +506,13 @@ enum AVPixelFormat {
#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE) #define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE)
#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE) #define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE) #define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE)
#define AV_PIX_FMT_P012 AV_PIX_FMT_NE(P012BE, P012LE)
#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE) #define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE)
#define AV_PIX_FMT_Y210 AV_PIX_FMT_NE(Y210BE, Y210LE) #define AV_PIX_FMT_Y210 AV_PIX_FMT_NE(Y210BE, Y210LE)
#define AV_PIX_FMT_Y212 AV_PIX_FMT_NE(Y212BE, Y212LE)
#define AV_PIX_FMT_XV30 AV_PIX_FMT_NE(XV30BE, XV30LE)
#define AV_PIX_FMT_XV36 AV_PIX_FMT_NE(XV36BE, XV36LE)
#define AV_PIX_FMT_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE) #define AV_PIX_FMT_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE)
#define AV_PIX_FMT_X2BGR10 AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE) #define AV_PIX_FMT_X2BGR10 AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE)
@ -462,6 +521,11 @@ enum AVPixelFormat {
#define AV_PIX_FMT_P216 AV_PIX_FMT_NE(P216BE, P216LE) #define AV_PIX_FMT_P216 AV_PIX_FMT_NE(P216BE, P216LE)
#define AV_PIX_FMT_P416 AV_PIX_FMT_NE(P416BE, P416LE) #define AV_PIX_FMT_P416 AV_PIX_FMT_NE(P416BE, P416LE)
#define AV_PIX_FMT_RGBAF16 AV_PIX_FMT_NE(RGBAF16BE, RGBAF16LE)
#define AV_PIX_FMT_RGBF32 AV_PIX_FMT_NE(RGBF32BE, RGBF32LE)
#define AV_PIX_FMT_RGBAF32 AV_PIX_FMT_NE(RGBAF32BE, RGBAF32LE)
/** /**
* Chromaticity coordinates of the source primaries. * Chromaticity coordinates of the source primaries.
* These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273. * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273.

3
src/3rdparty/win32_include/libavutil/rational.h vendored
View File

@ -179,7 +179,8 @@ AVRational av_d2q(double d, int max) av_const;
* Find which of the two rationals is closer to another rational. * Find which of the two rationals is closer to another rational.
* *
* @param q Rational to be compared against * @param q Rational to be compared against
* @param q1,q2 Rationals to be tested * @param q1 Rational to be tested
* @param q2 Rational to be tested
* @return One of the following values: * @return One of the following values:
* - 1 if `q1` is nearer to `q` than `q2` * - 1 if `q1` is nearer to `q` than `q2`
* - -1 if `q2` is nearer to `q` than `q1` * - -1 if `q2` is nearer to `q` than `q1`

3
src/3rdparty/win32_include/libavutil/rc4.h vendored
View File

@ -42,6 +42,8 @@ AVRC4 *av_rc4_alloc(void);
/** /**
* @brief Initializes an AVRC4 context. * @brief Initializes an AVRC4 context.
* *
* @param d pointer to the AVRC4 context
* @param key buffer containig the key
* @param key_bits must be a multiple of 8 * @param key_bits must be a multiple of 8
* @param decrypt 0 for encryption, 1 for decryption, currently has no effect * @param decrypt 0 for encryption, 1 for decryption, currently has no effect
* @return zero on success, negative value otherwise * @return zero on success, negative value otherwise
@ -51,6 +53,7 @@ int av_rc4_init(struct AVRC4 *d, const uint8_t *key, int key_bits, int decrypt);
/** /**
* @brief Encrypts / decrypts using the RC4 algorithm. * @brief Encrypts / decrypts using the RC4 algorithm.
* *
* @param d pointer to the AVRC4 context
* @param count number of bytes * @param count number of bytes
* @param dst destination array, can be equal to src * @param dst destination array, can be equal to src
* @param src source array, can be equal to dst, may be NULL * @param src source array, can be equal to dst, may be NULL

4
src/3rdparty/win32_include/libavutil/samplefmt.h vendored
View File

@ -21,9 +21,6 @@
#include <stdint.h> #include <stdint.h>
#include "avutil.h"
#include "attributes.h"
/** /**
* @addtogroup lavu_audio * @addtogroup lavu_audio
* @{ * @{
@ -216,6 +213,7 @@ int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
* @param[out] linesize aligned size for audio buffer(s), may be NULL * @param[out] linesize aligned size for audio buffer(s), may be NULL
* @param nb_channels number of audio channels * @param nb_channels number of audio channels
* @param nb_samples number of samples per channel * @param nb_samples number of samples per channel
* @param sample_fmt the sample format
* @param align buffer size alignment (0 = default, 1 = no alignment) * @param align buffer size alignment (0 = default, 1 = no alignment)
* @return >=0 on success or a negative error code on failure * @return >=0 on success or a negative error code on failure
* @todo return the size of the allocated buffer in case of success at the next bump * @todo return the size of the allocated buffer in case of success at the next bump

13
src/3rdparty/win32_include/libavutil/spherical.h vendored
View File

@ -20,6 +20,7 @@
/** /**
* @file * @file
* @ingroup lavu_video_spherical
* Spherical video * Spherical video
*/ */
@ -30,19 +31,14 @@
#include <stdint.h> #include <stdint.h>
/** /**
* @addtogroup lavu_video
* @{
*
* @defgroup lavu_video_spherical Spherical video mapping * @defgroup lavu_video_spherical Spherical video mapping
* @{ * @ingroup lavu_video
*/ *
/**
* @addtogroup lavu_video_spherical
* A spherical video file contains surfaces that need to be mapped onto a * A spherical video file contains surfaces that need to be mapped onto a
* sphere. Depending on how the frame was converted, a different distortion * sphere. Depending on how the frame was converted, a different distortion
* transformation or surface recomposition function needs to be applied before * transformation or surface recomposition function needs to be applied before
* the video should be mapped and displayed. * the video should be mapped and displayed.
* @{
*/ */
/** /**
@ -225,7 +221,6 @@ const char *av_spherical_projection_name(enum AVSphericalProjection projection);
*/ */
int av_spherical_from_name(const char *name); int av_spherical_from_name(const char *name);
/** /**
* @}
* @} * @}
*/ */

16
src/3rdparty/win32_include/libavutil/stereo3d.h vendored
View File

@ -20,6 +20,7 @@
/** /**
* @file * @file
* @ingroup lavu_video_stereo3d
* Stereoscopic video * Stereoscopic video
*/ */
@ -31,19 +32,15 @@
#include "frame.h" #include "frame.h"
/** /**
* @addtogroup lavu_video
* @{
*
* @defgroup lavu_video_stereo3d Stereo3D types and functions * @defgroup lavu_video_stereo3d Stereo3D types and functions
* @{ * @ingroup lavu_video
*/ *
/**
* @addtogroup lavu_video_stereo3d
* A stereoscopic video file consists in multiple views embedded in a single * A stereoscopic video file consists in multiple views embedded in a single
* frame, usually describing two views of a scene. This file describes all * frame, usually describing two views of a scene. This file describes all
* possible codec-independent view arrangements. * possible codec-independent view arrangements.
* */ *
* @{
*/
/** /**
* List of possible 3D Types * List of possible 3D Types
@ -226,7 +223,6 @@ const char *av_stereo3d_type_name(unsigned int type);
int av_stereo3d_from_name(const char *name); int av_stereo3d_from_name(const char *name);
/** /**
* @}
* @} * @}
*/ */

2
src/3rdparty/win32_include/libavutil/twofish.h vendored
View File

@ -59,7 +59,7 @@ int av_twofish_init(struct AVTWOFISH *ctx, const uint8_t *key, int key_bits);
* @param dst destination array, can be equal to src * @param dst destination array, can be equal to src
* @param src source array, can be equal to dst * @param src source array, can be equal to dst
* @param count number of 16 byte blocks * @param count number of 16 byte blocks
* @paran iv initialization vector for CBC mode, NULL for ECB mode * @param iv initialization vector for CBC mode, NULL for ECB mode
* @param decrypt 0 for encryption, 1 for decryption * @param decrypt 0 for encryption, 1 for decryption
*/ */
void av_twofish_crypt(struct AVTWOFISH *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt); void av_twofish_crypt(struct AVTWOFISH *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);

80
src/3rdparty/win32_include/libavutil/tx.h vendored
View File

@ -38,50 +38,75 @@ typedef struct AVComplexInt32 {
enum AVTXType { enum AVTXType {
/** /**
* Standard complex to complex FFT with sample data type AVComplexFloat. * Standard complex to complex FFT with sample data type of AVComplexFloat,
* AVComplexDouble or AVComplexInt32, for each respective variant.
*
* Output is not 1/len normalized. Scaling currently unsupported. * Output is not 1/len normalized. Scaling currently unsupported.
* The stride parameter is ignored. * The stride parameter must be set to the size of a single sample in bytes.
*/ */
AV_TX_FLOAT_FFT = 0, AV_TX_FLOAT_FFT = 0,
AV_TX_DOUBLE_FFT = 2,
AV_TX_INT32_FFT = 4,
/** /**
* Standard MDCT with sample data type of float and a scale type of * Standard MDCT with a sample data type of float, double or int32_t,
* float. Length is the frame size, not the window size (which is 2x frame) * respecively. For the float and int32 variants, the scale type is
* 'float', while for the double variant, it's 'double'.
* If scale is NULL, 1.0 will be used as a default.
*
* Length is the frame size, not the window size (which is 2x frame).
* For forward transforms, the stride specifies the spacing between each * For forward transforms, the stride specifies the spacing between each
* sample in the output array in bytes. The input must be a flat array. * sample in the output array in bytes. The input must be a flat array.
* *
* For inverse transforms, the stride specifies the spacing between each * For inverse transforms, the stride specifies the spacing between each
* sample in the input array in bytes. The output will be a flat array. * sample in the input array in bytes. The output must be a flat array.
* Stride must be a non-zero multiple of sizeof(float).
* *
* NOTE: the inverse transform is half-length, meaning the output will not * NOTE: the inverse transform is half-length, meaning the output will not
* contain redundant data. This is what most codecs work with. To do a full * contain redundant data. This is what most codecs work with. To do a full
* inverse transform, set the AV_TX_FULL_IMDCT flag on init. * inverse transform, set the AV_TX_FULL_IMDCT flag on init.
*/ */
AV_TX_FLOAT_MDCT = 1, AV_TX_FLOAT_MDCT = 1,
/**
* Same as AV_TX_FLOAT_FFT with a data type of AVComplexDouble.
*/
AV_TX_DOUBLE_FFT = 2,
/**
* Same as AV_TX_FLOAT_MDCT with data and scale type of double.
* Stride must be a non-zero multiple of sizeof(double).
*/
AV_TX_DOUBLE_MDCT = 3, AV_TX_DOUBLE_MDCT = 3,
AV_TX_INT32_MDCT = 5,
/** /**
* Same as AV_TX_FLOAT_FFT with a data type of AVComplexInt32. * Real to complex and complex to real DFTs.
* For the float and int32 variants, the scale type is 'float', while for
* the double variant, it's a 'double'. If scale is NULL, 1.0 will be used
* as a default.
*
* For forward transforms (R2C), stride must be the spacing between two
* samples in bytes. For inverse transforms, the stride must be set
* to the spacing between two complex values in bytes.
*
* The forward transform performs a real-to-complex DFT of N samples to
* N/2+1 complex values.
*
* The inverse transform performs a complex-to-real DFT of N/2+1 complex
* values to N real samples. The output is not normalized, but can be
* made so by setting the scale value to 1.0/len.
* NOTE: the inverse transform always overwrites the input.
*/ */
AV_TX_INT32_FFT = 4, AV_TX_FLOAT_RDFT = 6,
AV_TX_DOUBLE_RDFT = 7,
AV_TX_INT32_RDFT = 8,
/** /**
* Same as AV_TX_FLOAT_MDCT with data type of int32_t and scale type of float. * Real to real (DCT) transforms.
* Only scale values less than or equal to 1.0 are supported. *
* Stride must be a non-zero multiple of sizeof(int32_t). * The forward transform is a DCT-II.
* The inverse transform is a DCT-III.
*
* The input array is always overwritten. DCT-III requires that the
* input be padded with 2 extra samples. Stride must be set to the
* spacing between two samples in bytes.
*/ */
AV_TX_INT32_MDCT = 5, AV_TX_FLOAT_DCT = 9,
AV_TX_DOUBLE_DCT = 10,
AV_TX_INT32_DCT = 11,
/* Not part of the API, do not use */
AV_TX_NB,
}; };
/** /**
@ -106,9 +131,8 @@ typedef void (*av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride);
*/ */
enum AVTXFlags { enum AVTXFlags {
/** /**
* Performs an in-place transformation on the input. The output argument * Allows for in-place transformations, where input == output.
* of av_tn_fn() MUST match the input. May be unsupported or slower for some * May be unsupported or slower for some transform types.
* transform types.
*/ */
AV_TX_INPLACE = 1ULL << 0, AV_TX_INPLACE = 1ULL << 0,
@ -145,7 +169,7 @@ int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type,
int inv, int len, const void *scale, uint64_t flags); int inv, int len, const void *scale, uint64_t flags);
/** /**
* Frees a context and sets ctx to NULL, does nothing when ctx == NULL * Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
*/ */
void av_tx_uninit(AVTXContext **ctx); void av_tx_uninit(AVTXContext **ctx);

146
src/3rdparty/win32_include/libavutil/uuid.h vendored Normal file
View File

@ -0,0 +1,146 @@
/*
* Copyright (c) 2022 Pierre-Anthony Lemieux <pal@palemieux.com>
* Zane van Iperen <zane@zanevaniperen.com>
*
* 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
*/
/**
* @file
* UUID parsing and serialization utilities.
* The library treats the UUID as an opaque sequence of 16 unsigned bytes,
* i.e. ignoring the internal layout of the UUID, which depends on the type
* of the UUID.
*
* @author Pierre-Anthony Lemieux <pal@palemieux.com>
* @author Zane van Iperen <zane@zanevaniperen.com>
*/
#ifndef AVUTIL_UUID_H
#define AVUTIL_UUID_H
#include <stdint.h>
#include <string.h>
#define AV_PRI_UUID \
"%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-" \
"%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
#define AV_PRI_URN_UUID \
"urn:uuid:%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-" \
"%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
/* AV_UUID_ARG() is used together with AV_PRI_UUID() or AV_PRI_URN_UUID
* to print UUIDs, e.g.
* av_log(NULL, AV_LOG_DEBUG, "UUID: " AV_PRI_UUID, AV_UUID_ARG(uuid));
*/
#define AV_UUID_ARG(x) \
(x)[ 0], (x)[ 1], (x)[ 2], (x)[ 3], \
(x)[ 4], (x)[ 5], (x)[ 6], (x)[ 7], \
(x)[ 8], (x)[ 9], (x)[10], (x)[11], \
(x)[12], (x)[13], (x)[14], (x)[15]
#define AV_UUID_LEN 16
/* Binary representation of a UUID */
typedef uint8_t AVUUID[AV_UUID_LEN];
/**
* Parses a string representation of a UUID formatted according to IETF RFC 4122
* into an AVUUID. The parsing is case-insensitive. The string must be 37
* characters long, including the terminating NUL character.
*
* Example string representation: "2fceebd0-7017-433d-bafb-d073a7116696"
*
* @param[in] in String representation of a UUID,
* e.g. 2fceebd0-7017-433d-bafb-d073a7116696
* @param[out] uu AVUUID
* @return A non-zero value in case of an error.
*/
int av_uuid_parse(const char *in, AVUUID uu);
/**
* Parses a URN representation of a UUID, as specified at IETF RFC 4122,
* into an AVUUID. The parsing is case-insensitive. The string must be 46
* characters long, including the terminating NUL character.
*
* Example string representation: "urn:uuid:2fceebd0-7017-433d-bafb-d073a7116696"
*
* @param[in] in URN UUID
* @param[out] uu AVUUID
* @return A non-zero value in case of an error.
*/
int av_uuid_urn_parse(const char *in, AVUUID uu);
/**
* Parses a string representation of a UUID formatted according to IETF RFC 4122
* into an AVUUID. The parsing is case-insensitive.
*
* @param[in] in_start Pointer to the first character of the string representation
* @param[in] in_end Pointer to the character after the last character of the
* string representation. That memory location is never
* accessed. It is an error if `in_end - in_start != 36`.
* @param[out] uu AVUUID
* @return A non-zero value in case of an error.
*/
int av_uuid_parse_range(const char *in_start, const char *in_end, AVUUID uu);
/**
* Serializes a AVUUID into a string representation according to IETF RFC 4122.
* The string is lowercase and always 37 characters long, including the
* terminating NUL character.
*
* @param[in] uu AVUUID
* @param[out] out Pointer to an array of no less than 37 characters.
*/
void av_uuid_unparse(const AVUUID uu, char *out);
/**
* Compares two UUIDs for equality.
*
* @param[in] uu1 AVUUID
* @param[in] uu2 AVUUID
* @return Nonzero if uu1 and uu2 are identical, 0 otherwise
*/
static inline int av_uuid_equal(const AVUUID uu1, const AVUUID uu2)
{
return memcmp(uu1, uu2, AV_UUID_LEN) == 0;
}
/**
* Copies the bytes of src into dest.
*
* @param[out] dest AVUUID
* @param[in] src AVUUID
*/
static inline void av_uuid_copy(AVUUID dest, const AVUUID src)
{
memcpy(dest, src, AV_UUID_LEN);
}
/**
* Sets a UUID to the nil UUID, i.e. a UUID with have all
* its 128 bits set to zero.
*
* @param[in,out] uu UUID to be set to the nil UUID
*/
static inline void av_uuid_nil(AVUUID uu)
{
memset(uu, 0, AV_UUID_LEN);
}
#endif /* AVUTIL_UUID_H */

16
src/3rdparty/win32_include/libavutil/version.h vendored
View File

@ -78,8 +78,8 @@
* @{ * @{
*/ */
#define LIBAVUTIL_VERSION_MAJOR 57 #define LIBAVUTIL_VERSION_MAJOR 58
#define LIBAVUTIL_VERSION_MINOR 17 #define LIBAVUTIL_VERSION_MINOR 2
#define LIBAVUTIL_VERSION_MICRO 100 #define LIBAVUTIL_VERSION_MICRO 100
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
@ -105,10 +105,14 @@
* @{ * @{
*/ */
#define FF_API_D2STR (LIBAVUTIL_VERSION_MAJOR < 58) #define FF_API_FIFO_PEEK2 (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_DECLARE_ALIGNED (LIBAVUTIL_VERSION_MAJOR < 58) #define FF_API_FIFO_OLD_API (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_COLORSPACE_NAME (LIBAVUTIL_VERSION_MAJOR < 58) #define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_AV_MALLOCZ_ARRAY (LIBAVUTIL_VERSION_MAJOR < 58) #define FF_API_OLD_CHANNEL_LAYOUT (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_AV_FOPEN_UTF8 (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_PKT_DURATION (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_REORDERED_OPAQUE (LIBAVUTIL_VERSION_MAJOR < 59)
#define FF_API_FRAME_PICTURE_NUMBER (LIBAVUTIL_VERSION_MAJOR < 59)
/** /**
* @} * @}

111
src/3rdparty/win32_include/libswresample/swresample.h vendored
View File

@ -34,11 +34,11 @@
* Audio resampling, sample format conversion and mixing library. * Audio resampling, sample format conversion and mixing library.
* *
* Interaction with lswr is done through SwrContext, which is * Interaction with lswr is done through SwrContext, which is
* allocated with swr_alloc() or swr_alloc_set_opts(). It is opaque, so all parameters * allocated with swr_alloc() or swr_alloc_set_opts2(). It is opaque, so all parameters
* must be set with the @ref avoptions API. * must be set with the @ref avoptions API.
* *
* The first thing you will need to do in order to use lswr is to allocate * The first thing you will need to do in order to use lswr is to allocate
* SwrContext. This can be done with swr_alloc() or swr_alloc_set_opts(). If you * SwrContext. This can be done with swr_alloc() or swr_alloc_set_opts2(). If you
* are using the former, you must set options through the @ref avoptions API. * are using the former, you must set options through the @ref avoptions API.
* The latter function provides the same feature, but it allows you to set some * The latter function provides the same feature, but it allows you to set some
* common options in the same statement. * common options in the same statement.
@ -57,13 +57,14 @@
* av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0); * av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
* @endcode * @endcode
* *
* The same job can be done using swr_alloc_set_opts() as well: * The same job can be done using swr_alloc_set_opts2() as well:
* @code * @code
* SwrContext *swr = swr_alloc_set_opts(NULL, // we're allocating a new context * SwrContext *swr = NULL;
* AV_CH_LAYOUT_STEREO, // out_ch_layout * int ret = swr_alloc_set_opts2(&swr, // we're allocating a new context
* &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO, // out_ch_layout
* AV_SAMPLE_FMT_S16, // out_sample_fmt * AV_SAMPLE_FMT_S16, // out_sample_fmt
* 44100, // out_sample_rate * 44100, // out_sample_rate
* AV_CH_LAYOUT_5POINT1, // in_ch_layout * &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1, // in_ch_layout
* AV_SAMPLE_FMT_FLTP, // in_sample_fmt * AV_SAMPLE_FMT_FLTP, // in_sample_fmt
* 48000, // in_sample_rate * 48000, // in_sample_rate
* 0, // log_offset * 0, // log_offset
@ -72,8 +73,8 @@
* *
* Once all values have been set, it must be initialized with swr_init(). If * Once all values have been set, it must be initialized with swr_init(). If
* you need to change the conversion parameters, you can change the parameters * you need to change the conversion parameters, you can change the parameters
* using @ref AVOptions, as described above in the first example; or by using * using @ref avoptions, as described above in the first example; or by using
* swr_alloc_set_opts(), but with the first argument the allocated context. * swr_alloc_set_opts2(), but with the first argument the allocated context.
* You must then call swr_init() again. * You must then call swr_init() again.
* *
* The conversion itself is done by repeatedly calling swr_convert(). * The conversion itself is done by repeatedly calling swr_convert().
@ -124,7 +125,13 @@
#include "libavutil/frame.h" #include "libavutil/frame.h"
#include "libavutil/samplefmt.h" #include "libavutil/samplefmt.h"
#include "libswresample/version_major.h"
#ifndef HAVE_AV_CONFIG_H
/* When included as part of the ffmpeg build, only include the major version
* to avoid unnecessary rebuilds. When included externally, keep including
* the full version information. */
#include "libswresample/version.h" #include "libswresample/version.h"
#endif
/** /**
* @name Option constants * @name Option constants
@ -199,9 +206,9 @@ const AVClass *swr_get_class(void);
* Allocate SwrContext. * Allocate SwrContext.
* *
* If you use this function you will need to set the parameters (manually or * If you use this function you will need to set the parameters (manually or
* with swr_alloc_set_opts()) before calling swr_init(). * with swr_alloc_set_opts2()) before calling swr_init().
* *
* @see swr_alloc_set_opts(), swr_init(), swr_free() * @see swr_alloc_set_opts2(), swr_init(), swr_free()
* @return NULL on error, allocated context otherwise * @return NULL on error, allocated context otherwise
*/ */
struct SwrContext *swr_alloc(void); struct SwrContext *swr_alloc(void);
@ -227,6 +234,7 @@ int swr_init(struct SwrContext *s);
*/ */
int swr_is_initialized(struct SwrContext *s); int swr_is_initialized(struct SwrContext *s);
#if FF_API_OLD_CHANNEL_LAYOUT
/** /**
* Allocate SwrContext if needed and set/reset common parameters. * Allocate SwrContext if needed and set/reset common parameters.
* *
@ -246,12 +254,41 @@ int swr_is_initialized(struct SwrContext *s);
* *
* @see swr_init(), swr_free() * @see swr_init(), swr_free()
* @return NULL on error, allocated context otherwise * @return NULL on error, allocated context otherwise
* @deprecated use @ref swr_alloc_set_opts2()
*/ */
attribute_deprecated
struct SwrContext *swr_alloc_set_opts(struct SwrContext *s, struct SwrContext *swr_alloc_set_opts(struct SwrContext *s,
int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate,
int log_offset, void *log_ctx); int log_offset, void *log_ctx);
#endif
/**
* Allocate SwrContext if needed and set/reset common parameters.
*
* This function does not require *ps to be allocated with swr_alloc(). On the
* other hand, swr_alloc() can use swr_alloc_set_opts2() to set the parameters
* on the allocated context.
*
* @param ps Pointer to an existing Swr context if available, or to NULL if not.
* On success, *ps will be set to the allocated context.
* @param out_ch_layout output channel layout (e.g. AV_CHANNEL_LAYOUT_*)
* @param out_sample_fmt output sample format (AV_SAMPLE_FMT_*).
* @param out_sample_rate output sample rate (frequency in Hz)
* @param in_ch_layout input channel layout (e.g. AV_CHANNEL_LAYOUT_*)
* @param in_sample_fmt input sample format (AV_SAMPLE_FMT_*).
* @param in_sample_rate input sample rate (frequency in Hz)
* @param log_offset logging level offset
* @param log_ctx parent logging context, can be NULL
*
* @see swr_init(), swr_free()
* @return 0 on success, a negative AVERROR code on error.
* On error, the Swr context is freed and *ps set to NULL.
*/
int swr_alloc_set_opts2(struct SwrContext **ps,
const AVChannelLayout *out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
const AVChannelLayout *in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate,
int log_offset, void *log_ctx);
/** /**
* @} * @}
* *
@ -317,8 +354,8 @@ int swr_convert(struct SwrContext *s, uint8_t **out, int out_count,
* in this case the output timestamps will match output sample numbers. * in this case the output timestamps will match output sample numbers.
* See ffmpeg-resampler(1) for the two modes of compensation. * See ffmpeg-resampler(1) for the two modes of compensation.
* *
* @param s[in] initialized Swr context * @param[in] s initialized Swr context
* @param pts[in] timestamp for the next input sample, INT64_MIN if unknown * @param[in] pts timestamp for the next input sample, INT64_MIN if unknown
* @see swr_set_compensation(), swr_drop_output(), and swr_inject_silence() are * @see swr_set_compensation(), swr_drop_output(), and swr_inject_silence() are
* function used internally for timestamp compensation. * function used internally for timestamp compensation.
* @return the output timestamp for the next output sample * @return the output timestamp for the next output sample
@ -362,6 +399,40 @@ int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensatio
*/ */
int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map); int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map);
#if FF_API_OLD_CHANNEL_LAYOUT
/**
* Generate a channel mixing matrix.
*
* This function is the one used internally by libswresample for building the
* default mixing matrix. It is made public just as a utility function for
* building custom matrices.
*
* @param in_layout input channel layout
* @param out_layout output channel layout
* @param center_mix_level mix level for the center channel
* @param surround_mix_level mix level for the surround channel(s)
* @param lfe_mix_level mix level for the low-frequency effects channel
* @param rematrix_maxval if 1.0, coefficients will be normalized to prevent
* overflow. if INT_MAX, coefficients will not be
* normalized.
* @param[out] matrix mixing coefficients; matrix[i + stride * o] is
* the weight of input channel i in output channel o.
* @param stride distance between adjacent input channels in the
* matrix array
* @param matrix_encoding matrixed stereo downmix mode (e.g. dplii)
* @param log_ctx parent logging context, can be NULL
* @return 0 on success, negative AVERROR code on failure
* @deprecated use @ref swr_build_matrix2()
*/
attribute_deprecated
int swr_build_matrix(uint64_t in_layout, uint64_t out_layout,
double center_mix_level, double surround_mix_level,
double lfe_mix_level, double rematrix_maxval,
double rematrix_volume, double *matrix,
int stride, enum AVMatrixEncoding matrix_encoding,
void *log_ctx);
#endif
/** /**
* Generate a channel mixing matrix. * Generate a channel mixing matrix.
* *
@ -385,12 +456,12 @@ int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map);
* @param log_ctx parent logging context, can be NULL * @param log_ctx parent logging context, can be NULL
* @return 0 on success, negative AVERROR code on failure * @return 0 on success, negative AVERROR code on failure
*/ */
int swr_build_matrix(uint64_t in_layout, uint64_t out_layout, int swr_build_matrix2(const AVChannelLayout *in_layout, const AVChannelLayout *out_layout,
double center_mix_level, double surround_mix_level, double center_mix_level, double surround_mix_level,
double lfe_mix_level, double rematrix_maxval, double lfe_mix_level, double maxval,
double rematrix_volume, double *matrix, double rematrix_volume, double *matrix,
int stride, enum AVMatrixEncoding matrix_encoding, ptrdiff_t stride, enum AVMatrixEncoding matrix_encoding,
void *log_ctx); void *log_context);
/** /**
* Set a customized remix matrix. * Set a customized remix matrix.
@ -565,8 +636,8 @@ int swr_convert_frame(SwrContext *swr,
* @see swr_close(); * @see swr_close();
* *
* @param swr audio resample context * @param swr audio resample context
* @param output output AVFrame * @param out output AVFrame
* @param input input AVFrame * @param in input AVFrame
* @return 0 on success, AVERROR on failure. * @return 0 on success, AVERROR on failure.
*/ */
int swr_config_frame(SwrContext *swr, const AVFrame *out, const AVFrame *in); int swr_config_frame(SwrContext *swr, const AVFrame *out, const AVFrame *in);

5
src/3rdparty/win32_include/libswresample/version.h vendored
View File

@ -28,8 +28,9 @@
#include "libavutil/version.h" #include "libavutil/version.h"
#define LIBSWRESAMPLE_VERSION_MAJOR 4 #include "version_major.h"
#define LIBSWRESAMPLE_VERSION_MINOR 3
#define LIBSWRESAMPLE_VERSION_MINOR 10
#define LIBSWRESAMPLE_VERSION_MICRO 100 #define LIBSWRESAMPLE_VERSION_MICRO 100
#define LIBSWRESAMPLE_VERSION_INT AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \ #define LIBSWRESAMPLE_VERSION_INT AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \

31
src/3rdparty/win32_include/libswresample/version_major.h vendored Normal file
View File

@ -0,0 +1,31 @@
/*
* Version macros.
*
* This file is part of libswresample
*
* libswresample 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.
*
* libswresample 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 libswresample; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef SWRESAMPLE_VERSION_MAJOR_H
#define SWRESAMPLE_VERSION_MAJOR_H
/**
* @file
* Libswresample version macros
*/
#define LIBSWRESAMPLE_VERSION_MAJOR 4
#endif /* SWRESAMPLE_VERSION_MAJOR_H */