Cool_Tools/vgmstream
1
0
Fork 0
mirror of https://github.com/vgmstream/vgmstream.git synced 2024-11-30 17:24:31 +01:00
Code Issues Packages Projects Releases Wiki Activity

update ffmpeg

Browse Source 
- compiled with VS2019 (since old DLL used MSVC too)
- version n5.1.2
- removed unused config and included binka
- removed XP support
- comments in config txt
- has some crash bugs (to be improved in later commits)
This commit is contained in:
bnnm 2023-01-15 17:39:01 +01:00
parent 4429bb0fca
commit 86c4d81506
100 changed files with 7422 additions and 4896 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
cmake/dependencies/ffmpeg.cmake
View File

@ -68,67 +68,55 @@ if(USE_FFMPEG)
if(FFMPEG_PATH) if(FFMPEG_PATH)
set(FFMPEG_COMPILE YES) set(FFMPEG_COMPILE YES)
set(FFMPEG_CONF_DEMUXER
ac3 eac3 spdif asf xwma mov oma xmv ogg flac wav aac mp3 smacker bink binka caf mpc mpc8 tak ape
)
set(FFMPEG_CONF_PARSER set(FFMPEG_CONF_PARSER
ac3 mpegaudio xma vorbis opus ac3 mpegaudio xma vorbis opus
) )
set(FFMPEG_CONF_DEMUXER
ac3 asf xwma mov oma ogg tak dsf wav aac dts dtshd mp3 bink flac msf xmv caf ape smacker pcm_s8 spdif mpc mpc8
)
set(FFMPEG_CONF_DECODER set(FFMPEG_CONF_DECODER
ac3 wmapro wmav1 wmav2 wmavoice wmalossless xma1 xma2 dca tak dsd_lsbf dsd_lsbf_planar dsd_mbf dsd_msbf_planar aac atrac3 atrac3p mp1float mp2float mp3float binkaudio_dct binkaudio_rdft flac pcm_s16be pcm_s16be_planar pcm_s16le pcm_s16le_planar vorbis ape adpcm_ima_qt smackaud pcm_s8 pcm_s8_planar mpc7 mpc8 alac adpcm_ima_dk3 adpcm_ima_dk4 ac3 eac3 wmapro wmav1 wmav2 xma1 xma2 aac atrac3 atrac3p mp2float mp3float smackaud binkaudio_dct binkaudio_rdft pcm_s16be pcm_s16be_planar pcm_s16le pcm_s16le_planar pcm_s8 pcm_s8_planar flac vorbis mpc7 mpc8 alac adpcm_ima_qt adpcm_ima_dk3 adpcm_ima_dk4 tak ape
) )
if(USE_FFMPEG_LIBOPUS) if(USE_FFMPEG_LIBOPUS)
list(APPEND FFMPEG_CONF_DECODER libopus) list(APPEND FFMPEG_CONF_DECODER libopus)
else() else()
list(APPEND FFMPEG_CONF_DECODER opus) list(APPEND FFMPEG_CONF_DECODER opus)
endif() endif()
set(FFMPEG_CONF_DISABLE_PARSER
mpeg4video h263
)
set(FFMPEG_CONF_DISABLE_DECODER
mpeg2video h263 h264 mpeg1video mpeg2video mpeg4 hevc vp9
)
string(REPLACE ";" "," FFMPEG_CONF_PARSER "${FFMPEG_CONF_PARSER}") string(REPLACE ";" "," FFMPEG_CONF_PARSER "${FFMPEG_CONF_PARSER}")
string(REPLACE ";" "," FFMPEG_CONF_DEMUXER "${FFMPEG_CONF_DEMUXER}") string(REPLACE ";" "," FFMPEG_CONF_DEMUXER "${FFMPEG_CONF_DEMUXER}")
string(REPLACE ";" "," FFMPEG_CONF_DECODER "${FFMPEG_CONF_DECODER}") string(REPLACE ";" "," FFMPEG_CONF_DECODER "${FFMPEG_CONF_DECODER}")
string(REPLACE ";" "," FFMPEG_CONF_DISABLE_PARSER "${FFMPEG_CONF_DISABLE_PARSER}")
string(REPLACE ";" "," FFMPEG_CONF_DISABLE_DECODER "${FFMPEG_CONF_DISABLE_DECODER}")
set(FFMPEG_CONF_ARGS set(FFMPEG_CONF_ARGS
--enable-static --enable-static
--disable-shared --disable-shared
--enable-gpl --enable-gpl
--disable-version3
--disable-programs
--disable-doc --disable-doc
--disable-ffplay
--disable-ffprobe
--disable-avdevice --disable-avdevice
--disable-ffmpeg --disable-swscale
--disable-postproc --disable-postproc
--disable-avfilter --disable-avfilter
--disable-swscale
--disable-network --disable-network
--disable-everything
--disable-iconv
--disable-mediafoundation
--disable-schannel
--disable-sdl2
--disable-zlib
--disable-swscale-alpha --disable-swscale-alpha
--disable-vdpau
--disable-dxva2
--disable-amf --disable-amf
--disable-cuda --disable-cuda
--disable-cuvid
--disable-dxva2
--disable-d3d11va --disable-d3d11va
--disable-ffnvcodec --disable-ffnvcodec
--disable-nvenc --disable-nvenc
--disable-nvdec --disable-nvdec
--disable-hwaccels --disable-vdpau
--disable-sdl2
--disable-iconv
--disable-everything
--enable-hwaccels
--enable-swresample
--enable-parser=${FFMPEG_CONF_PARSER} --enable-parser=${FFMPEG_CONF_PARSER}
--enable-demuxer=${FFMPEG_CONF_DEMUXER} --enable-demuxer=${FFMPEG_CONF_DEMUXER}
--enable-decoder=${FFMPEG_CONF_DECODER} --enable-decoder=${FFMPEG_CONF_DECODER}
--disable-parser=${FFMPEG_CONF_DISABLE_PARSER} --enable-swresample
--disable-decoder=${FFMPEG_CONF_DISABLE_DECODER}
--disable-cuvid
--disable-version3
--disable-zlib
--extra-libs=-static --extra-libs=-static
--extra-cflags=--static --extra-cflags=--static
--pkg-config-flags=--static --pkg-config-flags=--static

8
cmake/vgmstream.cmake
View File

@ -151,10 +151,10 @@ macro(install_dlls INSTALL_PREFIX)
set(VORBIS_DLL ${VGM_SOURCE_DIR}/ext_libs/libvorbis.dll) set(VORBIS_DLL ${VGM_SOURCE_DIR}/ext_libs/libvorbis.dll)
set(G719_DLL ${VGM_SOURCE_DIR}/ext_libs/libg719_decode.dll) set(G719_DLL ${VGM_SOURCE_DIR}/ext_libs/libg719_decode.dll)
set(FFMPEG_DLL set(FFMPEG_DLL
${VGM_SOURCE_DIR}/ext_libs/avcodec-vgmstream-58.dll ${VGM_SOURCE_DIR}/ext_libs/avcodec-vgmstream-59.dll
${VGM_SOURCE_DIR}/ext_libs/avformat-vgmstream-58.dll ${VGM_SOURCE_DIR}/ext_libs/avformat-vgmstream-59.dll
${VGM_SOURCE_DIR}/ext_libs/avutil-vgmstream-56.dll ${VGM_SOURCE_DIR}/ext_libs/avutil-vgmstream-57.dll
${VGM_SOURCE_DIR}/ext_libs/swresample-vgmstream-3.dll) ${VGM_SOURCE_DIR}/ext_libs/swresample-vgmstream-4.dll)
set(ATRAC9_DLL ${VGM_SOURCE_DIR}/ext_libs/libatrac9.dll) set(ATRAC9_DLL ${VGM_SOURCE_DIR}/ext_libs/libatrac9.dll)
set(CELT_DLL set(CELT_DLL
${VGM_SOURCE_DIR}/ext_libs/libcelt-0061.dll ${VGM_SOURCE_DIR}/ext_libs/libcelt-0061.dll

3477
ext_includes/ffmpeg/libavcodec/avcodec.h
View File

File diff suppressed because it is too large Load Diff

4
ext_includes/ffmpeg/libavcodec/avdct.h
View File

@ -67,6 +67,10 @@ typedef struct AVDCT {
ptrdiff_t line_size); ptrdiff_t line_size);
int bits_per_sample; int bits_per_sample;
void (*get_pixels_unaligned)(int16_t *block /* align 16 */,
const uint8_t *pixels,
ptrdiff_t line_size);
} AVDCT; } AVDCT;
/** /**

328
ext_includes/ffmpeg/libavcodec/bsf.h Normal file
View File

@ -0,0 +1,328 @@
/*
* Bitstream filters public API
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_BSF_H
#define AVCODEC_BSF_H
#include "libavutil/dict.h"
#include "libavutil/log.h"
#include "libavutil/rational.h"
#include "codec_id.h"
#include "codec_par.h"
#include "packet.h"
/**
* @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().
* @{
*/
/**
* The bitstream filter state.
*
* This struct must be allocated with av_bsf_alloc() and freed with
* av_bsf_free().
*
* The fields in the struct will only be changed (by the caller or by the
* filter) as described in their documentation, and are to be considered
* immutable otherwise.
*/
typedef struct AVBSFContext {
/**
* A class for logging and AVOptions
*/
const AVClass *av_class;
/**
* The bitstream filter this context is an instance of.
*/
const struct AVBitStreamFilter *filter;
/**
* Opaque filter-specific private data. If filter->priv_class is non-NULL,
* this is an AVOptions-enabled struct.
*/
void *priv_data;
/**
* Parameters of the input stream. This field is allocated in
* av_bsf_alloc(), it needs to be filled by the caller before
* av_bsf_init().
*/
AVCodecParameters *par_in;
/**
* Parameters of the output stream. This field is allocated in
* av_bsf_alloc(), it is set by the filter in av_bsf_init().
*/
AVCodecParameters *par_out;
/**
* The timebase used for the timestamps of the input packets. Set by the
* caller before av_bsf_init().
*/
AVRational time_base_in;
/**
* The timebase used for the timestamps of the output packets. Set by the
* filter in av_bsf_init().
*/
AVRational time_base_out;
} AVBSFContext;
typedef struct AVBitStreamFilter {
const char *name;
/**
* A list of codec ids supported by the filter, terminated by
* AV_CODEC_ID_NONE.
* May be NULL, in that case the bitstream filter works with any codec id.
*/
const enum AVCodecID *codec_ids;
/**
* A class for the private data, used to declare bitstream filter private
* AVOptions. This field is NULL for bitstream filters that do not declare
* any options.
*
* If this field is non-NULL, the first member of the filter private data
* must be a pointer to AVClass, which will be set by libavcodec generic
* code to this class.
*/
const AVClass *priv_class;
} AVBitStreamFilter;
/**
* @return a bitstream filter with the specified name or NULL if no such
* bitstream filter exists.
*/
const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
/**
* Iterate over all registered bitstream filters.
*
* @param opaque a pointer where libavcodec will store the iteration state. Must
* point to NULL to start the iteration.
*
* @return the next registered bitstream filter or NULL when the iteration is
* finished
*/
const AVBitStreamFilter *av_bsf_iterate(void **opaque);
/**
* Allocate a context for a given bitstream filter. The caller must fill in the
* context parameters as described in the documentation and then call
* av_bsf_init() before sending any data to the filter.
*
* @param filter the filter for which to allocate an instance.
* @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
* filtering is done.
*
* @return 0 on success, a negative AVERROR code on failure
*/
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
/**
* Prepare the filter for use, after all the parameters and options have been
* set.
*/
int av_bsf_init(AVBSFContext *ctx);
/**
* Submit a packet for filtering.
*
* After sending each packet, the filter must be completely drained by calling
* av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
* AVERROR_EOF.
*
* @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.
* If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero),
* it signals the end of the stream (i.e. no more non-empty packets will be sent;
* sending more empty packets does nothing) and will cause the filter to output
* any packets it may have buffered internally.
*
* @return
* - 0 on success.
* - 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);
/**
* Retrieve a filtered packet.
*
* @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
* av_packet_unref() when it is no longer needed.
* This parameter should be "clean" (i.e. freshly allocated
* with av_packet_alloc() or unreffed with av_packet_unref())
* when this function is called. If this function returns
* successfully, the contents of pkt will be completely
* overwritten by the returned data. On failure, pkt is not
* touched.
*
* @return
* - 0 on success.
* - AVERROR(EAGAIN) if more packets need to be sent to the filter (using
* 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
* a packet with av_bsf_send_packet(), this function needs to be called
* repeatedly until it stops returning 0. It is also possible for a filter to
* output fewer packets than were sent to it, so this function may return
* AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
*/
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);
/**
* Reset the internal bitstream filter state. Should be called e.g. when seeking.
*/
void av_bsf_flush(AVBSFContext *ctx);
/**
* Free a bitstream filter context and everything associated with it; write NULL
* into the supplied pointer.
*/
void av_bsf_free(AVBSFContext **ctx);
/**
* Get the AVClass for AVBSFContext. It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options.
*
* @see av_opt_find().
*/
const AVClass *av_bsf_get_class(void);
/**
* Structure for chain/list of bitstream filters.
* Empty list can be allocated by av_bsf_list_alloc().
*/
typedef struct AVBSFList AVBSFList;
/**
* Allocate empty list of bitstream filters.
* The list must be later freed by av_bsf_list_free()
* or finalized by av_bsf_list_finalize().
*
* @return Pointer to @ref AVBSFList on success, NULL in case of failure
*/
AVBSFList *av_bsf_list_alloc(void);
/**
* Free list of bitstream filters.
*
* @param lst Pointer to pointer returned by av_bsf_list_alloc()
*/
void av_bsf_list_free(AVBSFList **lst);
/**
* Append bitstream filter to the list of bitstream filters.
*
* @param lst List to append to
* @param bsf Filter context to be appended
*
* @return >=0 on success, negative AVERROR in case of failure
*/
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
/**
* Construct new bitstream filter context given it's name and options
* and append it to the list of bitstream filters.
*
* @param lst List to append to
* @param bsf_name Name of the bitstream filter
* @param options Options for the bitstream filter, can be set to NULL
*
* @return >=0 on success, negative AVERROR in case of failure
*/
int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
/**
* Finalize list of bitstream filters.
*
* This function will transform @ref AVBSFList to single @ref AVBSFContext,
* so the whole chain of bitstream filters can be treated as single filter
* freshly allocated by av_bsf_alloc().
* If the call is successful, @ref AVBSFList structure is freed and lst
* will be set to NULL. In case of failure, caller is responsible for
* freeing the structure by av_bsf_list_free()
*
* @param lst Filter list structure to be transformed
* @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
* representing the chain of bitstream filters
*
* @return >=0 on success, negative AVERROR in case of failure
*/
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
/**
* Parse string describing list of bitstream filters and create single
* @ref AVBSFContext describing the whole chain of bitstream filters.
* Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
* allocated by av_bsf_alloc().
*
* @param str String describing chain of bitstream filters in format
* `bsf1[=opt1=val1:opt2=val2][,bsf2]`
* @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
* representing the chain of bitstream filters
*
* @return >=0 on success, negative AVERROR in case of failure
*/
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
/**
* Get null/pass-through bitstream filter.
*
* @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter
*
* @return
*/
int av_bsf_get_null_filter(AVBSFContext **bsf);
/**
* @}
*/
#endif // AVCODEC_BSF_H

387
ext_includes/ffmpeg/libavcodec/codec.h Normal file
View File

@ -0,0 +1,387 @@
/*
* AVCodec public API
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_CODEC_H
#define AVCODEC_CODEC_H
#include <stdint.h>
#include "libavutil/avutil.h"
#include "libavutil/hwcontext.h"
#include "libavutil/log.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"
#include "libavutil/samplefmt.h"
#include "libavcodec/codec_id.h"
#include "libavcodec/version_major.h"
/**
* @addtogroup lavc_core
* @{
*/
/**
* Decoder can use draw_horiz_band callback.
*/
#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
/**
* Codec uses get_buffer() or get_encode_buffer() for allocating buffers and
* supports custom allocators.
* If not set, it might not use get_buffer() or get_encode_buffer() at all, or
* use operations that assume the buffer was allocated by
* avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
*/
#define AV_CODEC_CAP_DR1 (1 << 1)
#if FF_API_FLAG_TRUNCATED
/**
* @deprecated Use parsers to always send proper frames.
*/
#define AV_CODEC_CAP_TRUNCATED (1 << 3)
#endif
/**
* Encoder or decoder requires flushing with NULL input at the end in order to
* give the complete and correct output.
*
* NOTE: If this flag is not set, the codec is guaranteed to never be fed with
* with NULL data. The user can still send NULL data to the public encode
* or decode function, but libavcodec will not pass it along to the codec
* unless this flag is set.
*
* Decoders:
* The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
* avpkt->size=0 at the end to get the delayed data until the decoder no longer
* returns frames.
*
* Encoders:
* The encoder needs to be fed with NULL data at the end of encoding until the
* encoder no longer returns data.
*
* NOTE: For encoders implementing the AVCodec.encode2() function, setting this
* flag also means that the encoder must set the pts and duration for
* each output packet. If this flag is not set, the pts and duration will
* be determined by libavcodec from the input frame.
*/
#define AV_CODEC_CAP_DELAY (1 << 5)
/**
* Codec can be fed a final frame with a smaller size.
* This can be used to prevent truncation of the last audio samples.
*/
#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
/**
* Codec can output multiple frames per AVPacket
* Normally demuxers return one frame at a time, demuxers which do not do
* are connected to a parser to split what they return into proper frames.
* This flag is reserved to the very rare category of codecs which have a
* bitstream that cannot be split into frames without timeconsuming
* operations like full decoding. Demuxers carrying such bitstreams thus
* may return multiple frames in a packet. This has many disadvantages like
* prohibiting stream copy in many cases thus it should only be considered
* as a last resort.
*/
#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
/**
* Codec is experimental and is thus avoided in favor of non experimental
* encoders
*/
#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
/**
* Codec should fill in channel configuration and samplerate instead of container
*/
#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
/**
* Codec supports frame-level multithreading.
*/
#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
/**
* Codec supports slice-based (or partition-based) multithreading.
*/
#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
/**
* Codec supports changed parameters at any point.
*/
#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
/**
* Codec supports multithreading through a method other than slice- or
* frame-level multithreading. Typically this marks wrappers around
* multithreading-capable external libraries.
*/
#define AV_CODEC_CAP_OTHER_THREADS (1 << 15)
#if FF_API_AUTO_THREADS
#define AV_CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_OTHER_THREADS
#endif
/**
* Audio encoder supports receiving a different number of samples in each call.
*/
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
/**
* Decoder is not a preferred choice for probing.
* This indicates that the decoder is not a good choice for probing.
* It could for example be an expensive to spin up hardware decoder,
* or it could simply not provide a lot of useful information about
* the stream.
* A decoder marked with this flag should only be used as last resort
* choice for probing.
*/
#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
#if FF_API_UNUSED_CODEC_CAPS
/**
* Deprecated and unused. Use AVCodecDescriptor.props instead
*/
#define AV_CODEC_CAP_INTRA_ONLY 0x40000000
/**
* Deprecated and unused. Use AVCodecDescriptor.props instead
*/
#define AV_CODEC_CAP_LOSSLESS 0x80000000
#endif
/**
* Codec is backed by a hardware implementation. Typically used to
* identify a non-hwaccel hardware decoder. For information about hwaccels, use
* avcodec_get_hw_config() instead.
*/
#define AV_CODEC_CAP_HARDWARE (1 << 18)
/**
* Codec is potentially backed by a hardware implementation, but not
* necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
* implementation provides some sort of internal fallback.
*/
#define AV_CODEC_CAP_HYBRID (1 << 19)
/**
* This codec takes the reordered_opaque field from input AVFrames
* and returns it in the corresponding field in AVCodecContext after
* encoding.
*/
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
/**
* This encoder can be flushed using avcodec_flush_buffers(). If this flag is
* not set, the encoder must be closed and reopened to ensure that no frames
* remain pending.
*/
#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
/**
* AVProfile.
*/
typedef struct AVProfile {
int profile;
const char *name; ///< short name for the profile
} AVProfile;
/**
* AVCodec.
*/
typedef struct AVCodec {
/**
* Name of the codec implementation.
* The name is globally unique among encoders and among decoders (but an
* encoder and a decoder can share the same name).
* This is the primary way to find a codec from the user perspective.
*/
const char *name;
/**
* Descriptive name for the codec, meant to be more human readable than name.
* You should use the NULL_IF_CONFIG_SMALL() macro to define it.
*/
const char *long_name;
enum AVMediaType type;
enum AVCodecID id;
/**
* Codec capabilities.
* see AV_CODEC_CAP_*
*/
int capabilities;
uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
#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
#endif
const AVClass *priv_class; ///< AVClass for the private context
const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
/**
* Group name of the codec implementation.
* This is a short symbolic name of the wrapper backing this codec. A
* wrapper uses some kind of external implementation for the codec, such
* as an external library, or a codec implementation provided by the OS or
* the hardware.
* If this field is NULL, this is a builtin, libavcodec native codec.
* If non-NULL, this will be the suffix in AVCodec.name in most cases
* (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
*/
const char *wrapper_name;
/**
* Array of supported channel layouts, terminated with a zeroed layout.
*/
const AVChannelLayout *ch_layouts;
} AVCodec;
/**
* Iterate over all registered codecs.
*
* @param opaque a pointer where libavcodec will store the iteration state. Must
* point to NULL to start the iteration.
*
* @return the next registered codec or NULL when the iteration is
* finished
*/
const AVCodec *av_codec_iterate(void **opaque);
/**
* Find a registered decoder with a matching codec ID.
*
* @param id AVCodecID of the requested decoder
* @return A decoder if one was found, NULL otherwise.
*/
const AVCodec *avcodec_find_decoder(enum AVCodecID id);
/**
* Find a registered decoder with the specified name.
*
* @param name name of the requested decoder
* @return A decoder if one was found, NULL otherwise.
*/
const AVCodec *avcodec_find_decoder_by_name(const char *name);
/**
* Find a registered encoder with a matching codec ID.
*
* @param id AVCodecID of the requested encoder
* @return An encoder if one was found, NULL otherwise.
*/
const AVCodec *avcodec_find_encoder(enum AVCodecID id);
/**
* Find a registered encoder with the specified name.
*
* @param name name of the requested encoder
* @return An encoder if one was found, NULL otherwise.
*/
const AVCodec *avcodec_find_encoder_by_name(const char *name);
/**
* @return a non-zero number if codec is an encoder, zero otherwise
*/
int av_codec_is_encoder(const AVCodec *codec);
/**
* @return a non-zero number if codec is a decoder, zero otherwise
*/
int av_codec_is_decoder(const AVCodec *codec);
/**
* Return a name for the specified profile, if available.
*
* @param codec the codec that is searched for the given profile
* @param profile the profile value for which a name is requested
* @return A name for the profile if found, NULL otherwise.
*/
const char *av_get_profile_name(const AVCodec *codec, int profile);
enum {
/**
* The codec supports this format via the hw_device_ctx interface.
*
* When selecting this format, AVCodecContext.hw_device_ctx should
* have been set to a device of the specified type before calling
* avcodec_open2().
*/
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
/**
* The codec supports this format via the hw_frames_ctx interface.
*
* When selecting this format for a decoder,
* AVCodecContext.hw_frames_ctx should be set to a suitable frames
* context inside the get_format() callback. The frames context
* must have been created on a device of the specified type.
*
* When selecting this format for an encoder,
* AVCodecContext.hw_frames_ctx should be set to the context which
* will be used for the input frames before calling avcodec_open2().
*/
AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
/**
* The codec supports this format by some internal method.
*
* This format can be selected without any additional configuration -
* no device or frames context is required.
*/
AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
/**
* The codec supports this format by some ad-hoc method.
*
* Additional settings and/or function calls are required. See the
* codec-specific documentation for details. (Methods requiring
* this sort of configuration are deprecated and others should be
* used in preference.)
*/
AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
};
typedef struct AVCodecHWConfig {
/**
* For decoders, a hardware pixel format which that decoder may be
* able to decode to if suitable hardware is available.
*
* For encoders, a pixel format which the encoder may be able to
* accept. If set to AV_PIX_FMT_NONE, this applies to all pixel
* formats supported by the codec.
*/
enum AVPixelFormat pix_fmt;
/**
* Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
* setup methods which can be used with this configuration.
*/
int methods;
/**
* The device type associated with the configuration.
*
* Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
* AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
*/
enum AVHWDeviceType device_type;
} AVCodecHWConfig;
/**
* Retrieve supported hardware configurations for a codec.
*
* Values of index from zero to some maximum return the indexed configuration
* descriptor; all other values return NULL. If the codec does not support
* any hardware configurations then it will always return NULL.
*/
const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
/**
* @}
*/
#endif /* AVCODEC_CODEC_H */

128
ext_includes/ffmpeg/libavcodec/codec_desc.h Normal file
View File

@ -0,0 +1,128 @@
/*
* Codec descriptors public API
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_CODEC_DESC_H
#define AVCODEC_CODEC_DESC_H
#include "libavutil/avutil.h"
#include "codec_id.h"
/**
* @addtogroup lavc_core
* @{
*/
/**
* This struct describes the properties of a single codec described by an
* AVCodecID.
* @see avcodec_descriptor_get()
*/
typedef struct AVCodecDescriptor {
enum AVCodecID id;
enum AVMediaType type;
/**
* Name of the codec described by this descriptor. It is non-empty and
* unique for each codec descriptor. It should contain alphanumeric
* characters and '_' only.
*/
const char *name;
/**
* A more descriptive name for this codec. May be NULL.
*/
const char *long_name;
/**
* Codec properties, a combination of AV_CODEC_PROP_* flags.
*/
int props;
/**
* MIME type(s) associated with the codec.
* May be NULL; if not, a NULL-terminated array of MIME types.
* The first item is always non-NULL and is the preferred MIME type.
*/
const char *const *mime_types;
/**
* If non-NULL, an array of profiles recognized for this codec.
* Terminated with FF_PROFILE_UNKNOWN.
*/
const struct AVProfile *profiles;
} AVCodecDescriptor;
/**
* Codec uses only intra compression.
* Video and audio codecs only.
*/
#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
/**
* Codec supports lossy compression. Audio and video codecs only.
* @note a codec may support both lossy and lossless
* compression modes
*/
#define AV_CODEC_PROP_LOSSY (1 << 1)
/**
* Codec supports lossless compression. Audio and video codecs only.
*/
#define AV_CODEC_PROP_LOSSLESS (1 << 2)
/**
* Codec supports frame reordering. That is, the coded order (the order in which
* the encoded packets are output by the encoders / stored / input to the
* decoders) may be different from the presentation order of the corresponding
* frames.
*
* For codecs that do not have this property set, PTS and DTS should always be
* equal.
*/
#define AV_CODEC_PROP_REORDER (1 << 3)
/**
* Subtitle codec is bitmap based
* Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
*/
#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
/**
* Subtitle codec is text based.
* Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
*/
#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
/**
* @return descriptor for given codec ID or NULL if no descriptor exists.
*/
const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
/**
* Iterate over all codec descriptors known to libavcodec.
*
* @param prev previous descriptor. NULL to get the first descriptor.
*
* @return next descriptor or NULL after the last descriptor
*/
const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
/**
* @return codec descriptor with the given name or NULL if no such descriptor
* exists.
*/
const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
/**
* @}
*/
#endif // AVCODEC_CODEC_DESC_H

634
ext_includes/ffmpeg/libavcodec/codec_id.h Normal file
View File

@ -0,0 +1,634 @@
/*
* Codec IDs
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_CODEC_ID_H
#define AVCODEC_CODEC_ID_H
#include "libavutil/avutil.h"
#include "libavutil/samplefmt.h"
/**
* @addtogroup lavc_core
* @{
*/
/**
* Identify the syntax and semantics of the bitstream.
* The principle is roughly:
* Two decoders with the same ID can decode the same streams.
* Two encoders with the same ID can encode compatible streams.
* There may be slight deviations from the principle due to implementation
* details.
*
* If you add a codec ID to this list, add it so that
* 1. no value of an existing codec ID changes (that would break ABI),
* 2. it is as close as possible to similar codecs
*
* After adding new codec IDs, do not forget to add an entry to the codec
* descriptor list and bump libavcodec minor version.
*/
enum AVCodecID {
AV_CODEC_ID_NONE,
/* video codecs */
AV_CODEC_ID_MPEG1VIDEO,
AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
AV_CODEC_ID_H261,
AV_CODEC_ID_H263,
AV_CODEC_ID_RV10,
AV_CODEC_ID_RV20,
AV_CODEC_ID_MJPEG,
AV_CODEC_ID_MJPEGB,
AV_CODEC_ID_LJPEG,
AV_CODEC_ID_SP5X,
AV_CODEC_ID_JPEGLS,
AV_CODEC_ID_MPEG4,
AV_CODEC_ID_RAWVIDEO,
AV_CODEC_ID_MSMPEG4V1,
AV_CODEC_ID_MSMPEG4V2,
AV_CODEC_ID_MSMPEG4V3,
AV_CODEC_ID_WMV1,
AV_CODEC_ID_WMV2,
AV_CODEC_ID_H263P,
AV_CODEC_ID_H263I,
AV_CODEC_ID_FLV1,
AV_CODEC_ID_SVQ1,
AV_CODEC_ID_SVQ3,
AV_CODEC_ID_DVVIDEO,
AV_CODEC_ID_HUFFYUV,
AV_CODEC_ID_CYUV,
AV_CODEC_ID_H264,
AV_CODEC_ID_INDEO3,
AV_CODEC_ID_VP3,
AV_CODEC_ID_THEORA,
AV_CODEC_ID_ASV1,
AV_CODEC_ID_ASV2,
AV_CODEC_ID_FFV1,
AV_CODEC_ID_4XM,
AV_CODEC_ID_VCR1,
AV_CODEC_ID_CLJR,
AV_CODEC_ID_MDEC,
AV_CODEC_ID_ROQ,
AV_CODEC_ID_INTERPLAY_VIDEO,
AV_CODEC_ID_XAN_WC3,
AV_CODEC_ID_XAN_WC4,
AV_CODEC_ID_RPZA,
AV_CODEC_ID_CINEPAK,
AV_CODEC_ID_WS_VQA,
AV_CODEC_ID_MSRLE,
AV_CODEC_ID_MSVIDEO1,
AV_CODEC_ID_IDCIN,
AV_CODEC_ID_8BPS,
AV_CODEC_ID_SMC,
AV_CODEC_ID_FLIC,
AV_CODEC_ID_TRUEMOTION1,
AV_CODEC_ID_VMDVIDEO,
AV_CODEC_ID_MSZH,
AV_CODEC_ID_ZLIB,
AV_CODEC_ID_QTRLE,
AV_CODEC_ID_TSCC,
AV_CODEC_ID_ULTI,
AV_CODEC_ID_QDRAW,
AV_CODEC_ID_VIXL,
AV_CODEC_ID_QPEG,
AV_CODEC_ID_PNG,
AV_CODEC_ID_PPM,
AV_CODEC_ID_PBM,
AV_CODEC_ID_PGM,
AV_CODEC_ID_PGMYUV,
AV_CODEC_ID_PAM,
AV_CODEC_ID_FFVHUFF,
AV_CODEC_ID_RV30,
AV_CODEC_ID_RV40,
AV_CODEC_ID_VC1,
AV_CODEC_ID_WMV3,
AV_CODEC_ID_LOCO,
AV_CODEC_ID_WNV1,
AV_CODEC_ID_AASC,
AV_CODEC_ID_INDEO2,
AV_CODEC_ID_FRAPS,
AV_CODEC_ID_TRUEMOTION2,
AV_CODEC_ID_BMP,
AV_CODEC_ID_CSCD,
AV_CODEC_ID_MMVIDEO,
AV_CODEC_ID_ZMBV,
AV_CODEC_ID_AVS,
AV_CODEC_ID_SMACKVIDEO,
AV_CODEC_ID_NUV,
AV_CODEC_ID_KMVC,
AV_CODEC_ID_FLASHSV,
AV_CODEC_ID_CAVS,
AV_CODEC_ID_JPEG2000,
AV_CODEC_ID_VMNC,
AV_CODEC_ID_VP5,
AV_CODEC_ID_VP6,
AV_CODEC_ID_VP6F,
AV_CODEC_ID_TARGA,
AV_CODEC_ID_DSICINVIDEO,
AV_CODEC_ID_TIERTEXSEQVIDEO,
AV_CODEC_ID_TIFF,
AV_CODEC_ID_GIF,
AV_CODEC_ID_DXA,
AV_CODEC_ID_DNXHD,
AV_CODEC_ID_THP,
AV_CODEC_ID_SGI,
AV_CODEC_ID_C93,
AV_CODEC_ID_BETHSOFTVID,
AV_CODEC_ID_PTX,
AV_CODEC_ID_TXD,
AV_CODEC_ID_VP6A,
AV_CODEC_ID_AMV,
AV_CODEC_ID_VB,
AV_CODEC_ID_PCX,
AV_CODEC_ID_SUNRAST,
AV_CODEC_ID_INDEO4,
AV_CODEC_ID_INDEO5,
AV_CODEC_ID_MIMIC,
AV_CODEC_ID_RL2,
AV_CODEC_ID_ESCAPE124,
AV_CODEC_ID_DIRAC,
AV_CODEC_ID_BFI,
AV_CODEC_ID_CMV,
AV_CODEC_ID_MOTIONPIXELS,
AV_CODEC_ID_TGV,
AV_CODEC_ID_TGQ,
AV_CODEC_ID_TQI,
AV_CODEC_ID_AURA,
AV_CODEC_ID_AURA2,
AV_CODEC_ID_V210X,
AV_CODEC_ID_TMV,
AV_CODEC_ID_V210,
AV_CODEC_ID_DPX,
AV_CODEC_ID_MAD,
AV_CODEC_ID_FRWU,
AV_CODEC_ID_FLASHSV2,
AV_CODEC_ID_CDGRAPHICS,
AV_CODEC_ID_R210,
AV_CODEC_ID_ANM,
AV_CODEC_ID_BINKVIDEO,
AV_CODEC_ID_IFF_ILBM,
#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
AV_CODEC_ID_KGV1,
AV_CODEC_ID_YOP,
AV_CODEC_ID_VP8,
AV_CODEC_ID_PICTOR,
AV_CODEC_ID_ANSI,
AV_CODEC_ID_A64_MULTI,
AV_CODEC_ID_A64_MULTI5,
AV_CODEC_ID_R10K,
AV_CODEC_ID_MXPEG,
AV_CODEC_ID_LAGARITH,
AV_CODEC_ID_PRORES,
AV_CODEC_ID_JV,
AV_CODEC_ID_DFA,
AV_CODEC_ID_WMV3IMAGE,
AV_CODEC_ID_VC1IMAGE,
AV_CODEC_ID_UTVIDEO,
AV_CODEC_ID_BMV_VIDEO,
AV_CODEC_ID_VBLE,
AV_CODEC_ID_DXTORY,
AV_CODEC_ID_V410,
AV_CODEC_ID_XWD,
AV_CODEC_ID_CDXL,
AV_CODEC_ID_XBM,
AV_CODEC_ID_ZEROCODEC,
AV_CODEC_ID_MSS1,
AV_CODEC_ID_MSA1,
AV_CODEC_ID_TSCC2,
AV_CODEC_ID_MTS2,
AV_CODEC_ID_CLLC,
AV_CODEC_ID_MSS2,
AV_CODEC_ID_VP9,
AV_CODEC_ID_AIC,
AV_CODEC_ID_ESCAPE130,
AV_CODEC_ID_G2M,
AV_CODEC_ID_WEBP,
AV_CODEC_ID_HNM4_VIDEO,
AV_CODEC_ID_HEVC,
#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
AV_CODEC_ID_FIC,
AV_CODEC_ID_ALIAS_PIX,
AV_CODEC_ID_BRENDER_PIX,
AV_CODEC_ID_PAF_VIDEO,
AV_CODEC_ID_EXR,
AV_CODEC_ID_VP7,
AV_CODEC_ID_SANM,
AV_CODEC_ID_SGIRLE,
AV_CODEC_ID_MVC1,
AV_CODEC_ID_MVC2,
AV_CODEC_ID_HQX,
AV_CODEC_ID_TDSC,
AV_CODEC_ID_HQ_HQA,
AV_CODEC_ID_HAP,
AV_CODEC_ID_DDS,
AV_CODEC_ID_DXV,
AV_CODEC_ID_SCREENPRESSO,
AV_CODEC_ID_RSCC,
AV_CODEC_ID_AVS2,
AV_CODEC_ID_PGX,
AV_CODEC_ID_AVS3,
AV_CODEC_ID_MSP2,
AV_CODEC_ID_VVC,
#define AV_CODEC_ID_H266 AV_CODEC_ID_VVC
AV_CODEC_ID_Y41P,
AV_CODEC_ID_AVRP,
AV_CODEC_ID_012V,
AV_CODEC_ID_AVUI,
AV_CODEC_ID_AYUV,
AV_CODEC_ID_TARGA_Y216,
AV_CODEC_ID_V308,
AV_CODEC_ID_V408,
AV_CODEC_ID_YUV4,
AV_CODEC_ID_AVRN,
AV_CODEC_ID_CPIA,
AV_CODEC_ID_XFACE,
AV_CODEC_ID_SNOW,
AV_CODEC_ID_SMVJPEG,
AV_CODEC_ID_APNG,
AV_CODEC_ID_DAALA,
AV_CODEC_ID_CFHD,
AV_CODEC_ID_TRUEMOTION2RT,
AV_CODEC_ID_M101,
AV_CODEC_ID_MAGICYUV,
AV_CODEC_ID_SHEERVIDEO,
AV_CODEC_ID_YLC,
AV_CODEC_ID_PSD,
AV_CODEC_ID_PIXLET,
AV_CODEC_ID_SPEEDHQ,
AV_CODEC_ID_FMVC,
AV_CODEC_ID_SCPR,
AV_CODEC_ID_CLEARVIDEO,
AV_CODEC_ID_XPM,
AV_CODEC_ID_AV1,
AV_CODEC_ID_BITPACKED,
AV_CODEC_ID_MSCC,
AV_CODEC_ID_SRGC,
AV_CODEC_ID_SVG,
AV_CODEC_ID_GDV,
AV_CODEC_ID_FITS,
AV_CODEC_ID_IMM4,
AV_CODEC_ID_PROSUMER,
AV_CODEC_ID_MWSC,
AV_CODEC_ID_WCMV,
AV_CODEC_ID_RASC,
AV_CODEC_ID_HYMT,
AV_CODEC_ID_ARBC,
AV_CODEC_ID_AGM,
AV_CODEC_ID_LSCR,
AV_CODEC_ID_VP4,
AV_CODEC_ID_IMM5,
AV_CODEC_ID_MVDV,
AV_CODEC_ID_MVHA,
AV_CODEC_ID_CDTOONS,
AV_CODEC_ID_MV30,
AV_CODEC_ID_NOTCHLC,
AV_CODEC_ID_PFM,
AV_CODEC_ID_MOBICLIP,
AV_CODEC_ID_PHOTOCD,
AV_CODEC_ID_IPU,
AV_CODEC_ID_ARGO,
AV_CODEC_ID_CRI,
AV_CODEC_ID_SIMBIOSIS_IMX,
AV_CODEC_ID_SGA_VIDEO,
AV_CODEC_ID_GEM,
AV_CODEC_ID_VBN,
AV_CODEC_ID_JPEGXL,
AV_CODEC_ID_QOI,
AV_CODEC_ID_PHM,
/* various PCM "codecs" */
AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
AV_CODEC_ID_PCM_S16LE = 0x10000,
AV_CODEC_ID_PCM_S16BE,
AV_CODEC_ID_PCM_U16LE,
AV_CODEC_ID_PCM_U16BE,
AV_CODEC_ID_PCM_S8,
AV_CODEC_ID_PCM_U8,
AV_CODEC_ID_PCM_MULAW,
AV_CODEC_ID_PCM_ALAW,
AV_CODEC_ID_PCM_S32LE,
AV_CODEC_ID_PCM_S32BE,
AV_CODEC_ID_PCM_U32LE,
AV_CODEC_ID_PCM_U32BE,
AV_CODEC_ID_PCM_S24LE,
AV_CODEC_ID_PCM_S24BE,
AV_CODEC_ID_PCM_U24LE,
AV_CODEC_ID_PCM_U24BE,
AV_CODEC_ID_PCM_S24DAUD,
AV_CODEC_ID_PCM_ZORK,
AV_CODEC_ID_PCM_S16LE_PLANAR,
AV_CODEC_ID_PCM_DVD,
AV_CODEC_ID_PCM_F32BE,
AV_CODEC_ID_PCM_F32LE,
AV_CODEC_ID_PCM_F64BE,
AV_CODEC_ID_PCM_F64LE,
AV_CODEC_ID_PCM_BLURAY,
AV_CODEC_ID_PCM_LXF,
AV_CODEC_ID_S302M,
AV_CODEC_ID_PCM_S8_PLANAR,
AV_CODEC_ID_PCM_S24LE_PLANAR,
AV_CODEC_ID_PCM_S32LE_PLANAR,
AV_CODEC_ID_PCM_S16BE_PLANAR,
AV_CODEC_ID_PCM_S64LE,
AV_CODEC_ID_PCM_S64BE,
AV_CODEC_ID_PCM_F16LE,
AV_CODEC_ID_PCM_F24LE,
AV_CODEC_ID_PCM_VIDC,
AV_CODEC_ID_PCM_SGA,
/* various ADPCM codecs */
AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
AV_CODEC_ID_ADPCM_IMA_WAV,
AV_CODEC_ID_ADPCM_IMA_DK3,
AV_CODEC_ID_ADPCM_IMA_DK4,
AV_CODEC_ID_ADPCM_IMA_WS,
AV_CODEC_ID_ADPCM_IMA_SMJPEG,
AV_CODEC_ID_ADPCM_MS,
AV_CODEC_ID_ADPCM_4XM,
AV_CODEC_ID_ADPCM_XA,
AV_CODEC_ID_ADPCM_ADX,
AV_CODEC_ID_ADPCM_EA,
AV_CODEC_ID_ADPCM_G726,
AV_CODEC_ID_ADPCM_CT,
AV_CODEC_ID_ADPCM_SWF,
AV_CODEC_ID_ADPCM_YAMAHA,
AV_CODEC_ID_ADPCM_SBPRO_4,
AV_CODEC_ID_ADPCM_SBPRO_3,
AV_CODEC_ID_ADPCM_SBPRO_2,
AV_CODEC_ID_ADPCM_THP,
AV_CODEC_ID_ADPCM_IMA_AMV,
AV_CODEC_ID_ADPCM_EA_R1,
AV_CODEC_ID_ADPCM_EA_R3,
AV_CODEC_ID_ADPCM_EA_R2,
AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
AV_CODEC_ID_ADPCM_IMA_EA_EACS,
AV_CODEC_ID_ADPCM_EA_XAS,
AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
AV_CODEC_ID_ADPCM_IMA_ISS,
AV_CODEC_ID_ADPCM_G722,
AV_CODEC_ID_ADPCM_IMA_APC,
AV_CODEC_ID_ADPCM_VIMA,
AV_CODEC_ID_ADPCM_AFC,
AV_CODEC_ID_ADPCM_IMA_OKI,
AV_CODEC_ID_ADPCM_DTK,
AV_CODEC_ID_ADPCM_IMA_RAD,
AV_CODEC_ID_ADPCM_G726LE,
AV_CODEC_ID_ADPCM_THP_LE,
AV_CODEC_ID_ADPCM_PSX,
AV_CODEC_ID_ADPCM_AICA,
AV_CODEC_ID_ADPCM_IMA_DAT4,
AV_CODEC_ID_ADPCM_MTAF,
AV_CODEC_ID_ADPCM_AGM,
AV_CODEC_ID_ADPCM_ARGO,
AV_CODEC_ID_ADPCM_IMA_SSI,
AV_CODEC_ID_ADPCM_ZORK,
AV_CODEC_ID_ADPCM_IMA_APM,
AV_CODEC_ID_ADPCM_IMA_ALP,
AV_CODEC_ID_ADPCM_IMA_MTF,
AV_CODEC_ID_ADPCM_IMA_CUNNING,
AV_CODEC_ID_ADPCM_IMA_MOFLEX,
AV_CODEC_ID_ADPCM_IMA_ACORN,
/* AMR */
AV_CODEC_ID_AMR_NB = 0x12000,
AV_CODEC_ID_AMR_WB,
/* RealAudio codecs*/
AV_CODEC_ID_RA_144 = 0x13000,
AV_CODEC_ID_RA_288,
/* various DPCM codecs */
AV_CODEC_ID_ROQ_DPCM = 0x14000,
AV_CODEC_ID_INTERPLAY_DPCM,
AV_CODEC_ID_XAN_DPCM,
AV_CODEC_ID_SOL_DPCM,
AV_CODEC_ID_SDX2_DPCM,
AV_CODEC_ID_GREMLIN_DPCM,
AV_CODEC_ID_DERF_DPCM,
/* audio codecs */
AV_CODEC_ID_MP2 = 0x15000,
AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
AV_CODEC_ID_AAC,
AV_CODEC_ID_AC3,
AV_CODEC_ID_DTS,
AV_CODEC_ID_VORBIS,
AV_CODEC_ID_DVAUDIO,
AV_CODEC_ID_WMAV1,
AV_CODEC_ID_WMAV2,
AV_CODEC_ID_MACE3,
AV_CODEC_ID_MACE6,
AV_CODEC_ID_VMDAUDIO,
AV_CODEC_ID_FLAC,
AV_CODEC_ID_MP3ADU,
AV_CODEC_ID_MP3ON4,
AV_CODEC_ID_SHORTEN,
AV_CODEC_ID_ALAC,
AV_CODEC_ID_WESTWOOD_SND1,
AV_CODEC_ID_GSM, ///< as in Berlin toast format
AV_CODEC_ID_QDM2,
AV_CODEC_ID_COOK,
AV_CODEC_ID_TRUESPEECH,
AV_CODEC_ID_TTA,
AV_CODEC_ID_SMACKAUDIO,
AV_CODEC_ID_QCELP,
AV_CODEC_ID_WAVPACK,
AV_CODEC_ID_DSICINAUDIO,
AV_CODEC_ID_IMC,
AV_CODEC_ID_MUSEPACK7,
AV_CODEC_ID_MLP,
AV_CODEC_ID_GSM_MS, /* as found in WAV */
AV_CODEC_ID_ATRAC3,
AV_CODEC_ID_APE,
AV_CODEC_ID_NELLYMOSER,
AV_CODEC_ID_MUSEPACK8,
AV_CODEC_ID_SPEEX,
AV_CODEC_ID_WMAVOICE,
AV_CODEC_ID_WMAPRO,
AV_CODEC_ID_WMALOSSLESS,
AV_CODEC_ID_ATRAC3P,
AV_CODEC_ID_EAC3,
AV_CODEC_ID_SIPR,
AV_CODEC_ID_MP1,
AV_CODEC_ID_TWINVQ,
AV_CODEC_ID_TRUEHD,
AV_CODEC_ID_MP4ALS,
AV_CODEC_ID_ATRAC1,
AV_CODEC_ID_BINKAUDIO_RDFT,
AV_CODEC_ID_BINKAUDIO_DCT,
AV_CODEC_ID_AAC_LATM,
AV_CODEC_ID_QDMC,
AV_CODEC_ID_CELT,
AV_CODEC_ID_G723_1,
AV_CODEC_ID_G729,
AV_CODEC_ID_8SVX_EXP,
AV_CODEC_ID_8SVX_FIB,
AV_CODEC_ID_BMV_AUDIO,
AV_CODEC_ID_RALF,
AV_CODEC_ID_IAC,
AV_CODEC_ID_ILBC,
AV_CODEC_ID_OPUS,
AV_CODEC_ID_COMFORT_NOISE,
AV_CODEC_ID_TAK,
AV_CODEC_ID_METASOUND,
AV_CODEC_ID_PAF_AUDIO,
AV_CODEC_ID_ON2AVC,
AV_CODEC_ID_DSS_SP,
AV_CODEC_ID_CODEC2,
AV_CODEC_ID_FFWAVESYNTH,
AV_CODEC_ID_SONIC,
AV_CODEC_ID_SONIC_LS,
AV_CODEC_ID_EVRC,
AV_CODEC_ID_SMV,
AV_CODEC_ID_DSD_LSBF,
AV_CODEC_ID_DSD_MSBF,
AV_CODEC_ID_DSD_LSBF_PLANAR,
AV_CODEC_ID_DSD_MSBF_PLANAR,
AV_CODEC_ID_4GV,
AV_CODEC_ID_INTERPLAY_ACM,
AV_CODEC_ID_XMA1,
AV_CODEC_ID_XMA2,
AV_CODEC_ID_DST,
AV_CODEC_ID_ATRAC3AL,
AV_CODEC_ID_ATRAC3PAL,
AV_CODEC_ID_DOLBY_E,
AV_CODEC_ID_APTX,
AV_CODEC_ID_APTX_HD,
AV_CODEC_ID_SBC,
AV_CODEC_ID_ATRAC9,
AV_CODEC_ID_HCOM,
AV_CODEC_ID_ACELP_KELVIN,
AV_CODEC_ID_MPEGH_3D_AUDIO,
AV_CODEC_ID_SIREN,
AV_CODEC_ID_HCA,
AV_CODEC_ID_FASTAUDIO,
AV_CODEC_ID_MSNSIREN,
AV_CODEC_ID_DFPWM,
/* subtitle codecs */
AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
AV_CODEC_ID_DVB_SUBTITLE,
AV_CODEC_ID_TEXT, ///< raw UTF-8 text
AV_CODEC_ID_XSUB,
AV_CODEC_ID_SSA,
AV_CODEC_ID_MOV_TEXT,
AV_CODEC_ID_HDMV_PGS_SUBTITLE,
AV_CODEC_ID_DVB_TELETEXT,
AV_CODEC_ID_SRT,
AV_CODEC_ID_MICRODVD,
AV_CODEC_ID_EIA_608,
AV_CODEC_ID_JACOSUB,
AV_CODEC_ID_SAMI,
AV_CODEC_ID_REALTEXT,
AV_CODEC_ID_STL,
AV_CODEC_ID_SUBVIEWER1,
AV_CODEC_ID_SUBVIEWER,
AV_CODEC_ID_SUBRIP,
AV_CODEC_ID_WEBVTT,
AV_CODEC_ID_MPL2,
AV_CODEC_ID_VPLAYER,
AV_CODEC_ID_PJS,
AV_CODEC_ID_ASS,
AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
AV_CODEC_ID_TTML,
AV_CODEC_ID_ARIB_CAPTION,
/* other specific kind of codecs (generally used for attachments) */
AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
AV_CODEC_ID_TTF = 0x18000,
AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
AV_CODEC_ID_EPG,
AV_CODEC_ID_BINTEXT,
AV_CODEC_ID_XBIN,
AV_CODEC_ID_IDF,
AV_CODEC_ID_OTF,
AV_CODEC_ID_SMPTE_KLV,
AV_CODEC_ID_DVD_NAV,
AV_CODEC_ID_TIMED_ID3,
AV_CODEC_ID_BIN_DATA,
AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
* stream (only used by libavformat) */
AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
* stream (only used by libavformat) */
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
};
/**
* Get the type of the given codec.
*/
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
/**
* Get the name of a codec.
* @return a static string identifying the codec; never NULL
*/
const char *avcodec_get_name(enum AVCodecID id);
/**
* Return codec bits per sample.
*
* @param[in] codec_id the codec
* @return Number of bits per sample or zero if unknown for the given codec.
*/
int av_get_bits_per_sample(enum AVCodecID codec_id);
/**
* Return codec bits per sample.
* Only return non-zero if the bits per sample is exactly correct, not an
* approximation.
*
* @param[in] codec_id the codec
* @return Number of bits per sample or zero if unknown for the given codec.
*/
int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
/**
* Return a name for the specified profile, if available.
*
* @param codec_id the ID of the codec to which the requested profile belongs
* @param profile the profile value for which a name is requested
* @return A name for the profile if found, NULL otherwise.
*
* @note unlike av_get_profile_name(), which searches a list of profiles
* supported by a specific decoder or encoder implementation, this
* function searches the list of profiles from the AVCodecDescriptor
*/
const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);
/**
* Return the PCM codec associated with a sample format.
* @param be endianness, 0 for little, 1 for big,
* -1 (or anything else) for native
* @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
*/
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
/**
* @}
*/
#endif // AVCODEC_CODEC_ID_H

246
ext_includes/ffmpeg/libavcodec/codec_par.h Normal file
View File

@ -0,0 +1,246 @@
/*
* Codec parameters public API
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_CODEC_PAR_H
#define AVCODEC_CODEC_PAR_H
#include <stdint.h>
#include "libavutil/avutil.h"
#include "libavutil/channel_layout.h"
#include "libavutil/rational.h"
#include "libavutil/pixfmt.h"
#include "codec_id.h"
/**
* @addtogroup lavc_core
*/
enum AVFieldOrder {
AV_FIELD_UNKNOWN,
AV_FIELD_PROGRESSIVE,
AV_FIELD_TT, //< Top coded_first, top displayed first
AV_FIELD_BB, //< Bottom coded first, bottom displayed first
AV_FIELD_TB, //< Top coded first, bottom displayed first
AV_FIELD_BT, //< Bottom coded first, top displayed first
};
/**
* This struct describes the properties of an encoded stream.
*
* sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
* be allocated with avcodec_parameters_alloc() and freed with
* avcodec_parameters_free().
*/
typedef struct AVCodecParameters {
/**
* General type of the encoded data.
*/
enum AVMediaType codec_type;
/**
* Specific type of the encoded data (the codec used).
*/
enum AVCodecID codec_id;
/**
* Additional information about the codec (corresponds to the AVI FOURCC).
*/
uint32_t codec_tag;
/**
* Extra binary data needed for initializing the decoder, codec-dependent.
*
* Must be allocated with av_malloc() and will be freed by
* avcodec_parameters_free(). The allocated size of extradata must be at
* least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
* bytes zeroed.
*/
uint8_t *extradata;
/**
* Size of the extradata content in bytes.
*/
int extradata_size;
/**
* - video: the pixel format, the value corresponds to enum AVPixelFormat.
* - audio: the sample format, the value corresponds to enum AVSampleFormat.
*/
int format;
/**
* The average bitrate of the encoded data (in bits per second).
*/
int64_t bit_rate;
/**
* The number of bits per sample in the codedwords.
*
* This is basically the bitrate per sample. It is mandatory for a bunch of
* formats to actually decode them. It's the number of bits for one sample in
* the actual coded bitstream.
*
* This could be for example 4 for ADPCM
* For PCM formats this matches bits_per_raw_sample
* Can be 0
*/
int bits_per_coded_sample;
/**
* This is the number of valid bits in each output sample. If the
* sample format has more bits, the least significant bits are additional
* padding bits, which are always 0. Use right shifts to reduce the sample
* to its actual size. For example, audio formats with 24 bit samples will
* have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
* To get the original sample use "(int32_t)sample >> 8"."
*
* For ADPCM this might be 12 or 16 or similar
* Can be 0
*/
int bits_per_raw_sample;
/**
* Codec-specific bitstream restrictions that the stream conforms to.
*/
int profile;
int level;
/**
* Video only. The dimensions of the video frame in pixels.
*/
int width;
int height;
/**
* Video only. The aspect ratio (width / height) which a single pixel
* should have when displayed.
*
* When the aspect ratio is unknown / undefined, the numerator should be
* set to 0 (the denominator may have any value).
*/
AVRational sample_aspect_ratio;
/**
* Video only. The order of the fields in interlaced video.
*/
enum AVFieldOrder field_order;
/**
* Video only. Additional colorspace characteristics.
*/
enum AVColorRange color_range;
enum AVColorPrimaries color_primaries;
enum AVColorTransferCharacteristic color_trc;
enum AVColorSpace color_space;
enum AVChromaLocation chroma_location;
/**
* Video only. Number of delayed frames.
*/
int video_delay;
#if FF_API_OLD_CHANNEL_LAYOUT
/**
* 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
* the channels field.
* @deprecated use ch_layout
*/
attribute_deprecated
uint64_t channel_layout;
/**
* Audio only. The number of audio channels.
* @deprecated use ch_layout.nb_channels
*/
attribute_deprecated
int channels;
#endif
/**
* Audio only. The number of audio samples per second.
*/
int sample_rate;
/**
* Audio only. The number of bytes per coded audio frame, required by some
* formats.
*
* Corresponds to nBlockAlign in WAVEFORMATEX.
*/
int block_align;
/**
* Audio only. Audio frame size, if known. Required by some formats to be static.
*/
int frame_size;
/**
* Audio only. The amount of padding (in samples) inserted by the encoder at
* the beginning of the audio. I.e. this number of leading decoded samples
* must be discarded by the caller to get the original audio without leading
* padding.
*/
int initial_padding;
/**
* 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
* discarded by the caller from the end of the stream to get the original
* audio without any trailing padding.
*/
int trailing_padding;
/**
* Audio only. Number of samples to skip after a discontinuity.
*/
int seek_preroll;
/**
* Audio only. The channel layout and number of channels.
*/
AVChannelLayout ch_layout;
} AVCodecParameters;
/**
* Allocate a new AVCodecParameters and set its fields to default values
* (unknown/invalid/0). The returned struct must be freed with
* avcodec_parameters_free().
*/
AVCodecParameters *avcodec_parameters_alloc(void);
/**
* Free an AVCodecParameters instance and everything associated with it and
* write NULL to the supplied pointer.
*/
void avcodec_parameters_free(AVCodecParameters **par);
/**
* Copy the contents of src to dst. Any allocated fields in dst are freed and
* replaced with newly allocated duplicates of the corresponding fields in src.
*
* @return >= 0 on success, a negative AVERROR code on failure.
*/
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
/**
* This function is the same as av_get_audio_frame_duration(), except it works
* with AVCodecParameters instead of an AVCodecContext.
*/
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
/**
* @}
*/
#endif // AVCODEC_CODEC_PAR_H

170
ext_includes/ffmpeg/libavcodec/defs.h Normal file
View File

@ -0,0 +1,170 @@
/*
*
* 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_DEFS_H
#define AVCODEC_DEFS_H
/**
* @file
* @ingroup libavc
* Misc types and constants that do not belong anywhere else.
*/
#include <stdint.h>
#include <stdlib.h>
/**
* @ingroup lavc_decoding
* Required number of additionally allocated bytes at the end of the input bitstream for decoding.
* This is mainly needed because some optimized bitstream readers read
* 32 or 64 bit at once and could read over the end.<br>
* Note: If the first 23 bits of the additional bytes are not 0, then damaged
* MPEG bitstreams could cause overread and segfault.
*/
#define AV_INPUT_BUFFER_PADDING_SIZE 64
/**
* @ingroup lavc_decoding
*/
enum AVDiscard{
/* We leave some space between them for extensions (drop some
* keyframes for intra-only or drop just some bidir frames). */
AVDISCARD_NONE =-16, ///< discard nothing
AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi
AVDISCARD_NONREF = 8, ///< discard all non reference
AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames
AVDISCARD_NONINTRA= 24, ///< discard all non intra frames
AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
AVDISCARD_ALL = 48, ///< discard all
};
enum AVAudioServiceType {
AV_AUDIO_SERVICE_TYPE_MAIN = 0,
AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
};
/**
* Pan Scan area.
* This specifies the area which should be displayed.
* Note there may be multiple such areas for one frame.
*/
typedef struct AVPanScan {
/**
* id
* - encoding: Set by user.
* - decoding: Set by libavcodec.
*/
int id;
/**
* width and height in 1/16 pel
* - encoding: Set by user.
* - decoding: Set by libavcodec.
*/
int width;
int height;
/**
* position of the top left corner in 1/16 pel for up to 3 fields/frames
* - encoding: Set by user.
* - decoding: Set by libavcodec.
*/
int16_t position[3][2];
} AVPanScan;
/**
* This structure describes the bitrate properties of an encoded bitstream. It
* roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD
* parameters for H.264/HEVC.
*/
typedef struct AVCPBProperties {
/**
* Maximum bitrate of the stream, in bits per second.
* Zero if unknown or unspecified.
*/
int64_t max_bitrate;
/**
* Minimum bitrate of the stream, in bits per second.
* Zero if unknown or unspecified.
*/
int64_t min_bitrate;
/**
* Average bitrate of the stream, in bits per second.
* Zero if unknown or unspecified.
*/
int64_t avg_bitrate;
/**
* The size of the buffer to which the ratecontrol is applied, in bits.
* Zero if unknown or unspecified.
*/
int64_t buffer_size;
/**
* The delay between the time the packet this structure is associated with
* is received and the time when it should be decoded, in periods of a 27MHz
* clock.
*
* UINT64_MAX when unknown or unspecified.
*/
uint64_t vbv_delay;
} AVCPBProperties;
/**
* Allocate a CPB properties structure and initialize its fields to default
* values.
*
* @param size if non-NULL, the size of the allocated struct will be written
* here. This is useful for embedding it in side data.
*
* @return the newly allocated struct or NULL on failure
*/
AVCPBProperties *av_cpb_properties_alloc(size_t *size);
/**
* This structure supplies correlation between a packet timestamp and a wall clock
* production time. The definition follows the Producer Reference Time ('prft')
* as defined in ISO/IEC 14496-12
*/
typedef struct AVProducerReferenceTime {
/**
* A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
*/
int64_t wallclock;
int flags;
} AVProducerReferenceTime;
/**
* Encode extradata length to a buffer. Used by xiph codecs.
*
* @param s buffer to write to; must be at least (v/255+1) bytes long
* @param v size of extradata in bytes
* @return number of bytes written to the buffer.
*/
unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
#endif // AVCODEC_DEFS_H

1
ext_includes/ffmpeg/libavcodec/dv_profile.h
View File

@ -23,7 +23,6 @@
#include "libavutil/pixfmt.h" #include "libavutil/pixfmt.h"
#include "libavutil/rational.h" #include "libavutil/rational.h"
#include "avcodec.h"
/* minimum number of bytes to read from a DV stream in order to /* minimum number of bytes to read from a DV stream in order to
* determine the profile */ * determine the profile */

731
ext_includes/ffmpeg/libavcodec/packet.h Normal file
View File

@ -0,0 +1,731 @@
/*
* AVPacket public API
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_PACKET_H
#define AVCODEC_PACKET_H
#include <stddef.h>
#include <stdint.h>
#include "libavutil/attributes.h"
#include "libavutil/buffer.h"
#include "libavutil/dict.h"
#include "libavutil/rational.h"
#include "libavutil/version.h"
#include "libavcodec/version_major.h"
/**
* @defgroup lavc_packet AVPacket
*
* Types and functions for working with AVPacket.
* @{
*/
enum AVPacketSideDataType {
/**
* An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
* bytes worth of palette. This side data signals that a new palette is
* present.
*/
AV_PKT_DATA_PALETTE,
/**
* The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
* that the extradata buffer was changed and the receiving side should
* act upon it appropriately. The new extradata is embedded in the side
* data buffer and should be immediately used for processing the current
* frame or packet.
*/
AV_PKT_DATA_NEW_EXTRADATA,
/**
* An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
* @code
* u32le param_flags
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
* s32le channel_count
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
* u64le channel_layout
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
* s32le sample_rate
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
* s32le width
* s32le height
* @endcode
*/
AV_PKT_DATA_PARAM_CHANGE,
/**
* An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
* structures with info about macroblocks relevant to splitting the
* packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
* That is, it does not necessarily contain info about all macroblocks,
* as long as the distance between macroblocks in the info is smaller
* than the target payload size.
* Each MB info structure is 12 bytes, and is laid out as follows:
* @code
* u32le bit offset from the start of the packet
* u8 current quantizer at the start of the macroblock
* u8 GOB number
* u16le macroblock address within the GOB
* u8 horizontal MV predictor
* u8 vertical MV predictor
* u8 horizontal MV predictor for block number 3
* u8 vertical MV predictor for block number 3
* @endcode
*/
AV_PKT_DATA_H263_MB_INFO,
/**
* This side data should be associated with an audio stream and contains
* ReplayGain information in form of the AVReplayGain struct.
*/
AV_PKT_DATA_REPLAYGAIN,
/**
* This side data contains a 3x3 transformation matrix describing an affine
* transformation that needs to be applied to the decoded video frames for
* correct presentation.
*
* See libavutil/display.h for a detailed description of the data.
*/
AV_PKT_DATA_DISPLAYMATRIX,
/**
* This side data should be associated with a video stream and contains
* Stereoscopic 3D information in form of the AVStereo3D struct.
*/
AV_PKT_DATA_STEREO3D,
/**
* This side data should be associated with an audio stream and corresponds
* to enum AVAudioServiceType.
*/
AV_PKT_DATA_AUDIO_SERVICE_TYPE,
/**
* This side data contains quality related information from the encoder.
* @code
* u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
* u8 picture type
* u8 error count
* u16 reserved
* u64le[error count] sum of squared differences between encoder in and output
* @endcode
*/
AV_PKT_DATA_QUALITY_STATS,
/**
* This side data contains an integer value representing the stream index
* of a "fallback" track. A fallback track indicates an alternate
* track to use when the current track can not be decoded for some reason.
* e.g. no decoder available for codec.
*/
AV_PKT_DATA_FALLBACK_TRACK,
/**
* This side data corresponds to the AVCPBProperties struct.
*/
AV_PKT_DATA_CPB_PROPERTIES,
/**
* Recommmends skipping the specified number of samples
* @code
* u32le number of samples to skip from start of this packet
* u32le number of samples to skip from end of this packet
* u8 reason for start skip
* u8 reason for end skip (0=padding silence, 1=convergence)
* @endcode
*/
AV_PKT_DATA_SKIP_SAMPLES,
/**
* An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
* the packet may contain "dual mono" audio specific to Japanese DTV
* and if it is true, recommends only the selected channel to be used.
* @code
* u8 selected channels (0=mail/left, 1=sub/right, 2=both)
* @endcode
*/
AV_PKT_DATA_JP_DUALMONO,
/**
* A list of zero terminated key/value strings. There is no end marker for
* the list, so it is required to rely on the side data size to stop.
*/
AV_PKT_DATA_STRINGS_METADATA,
/**
* Subtitle event position
* @code
* u32le x1
* u32le y1
* u32le x2
* u32le y2
* @endcode
*/
AV_PKT_DATA_SUBTITLE_POSITION,
/**
* Data found in BlockAdditional element of matroska container. There is
* no end marker for the data, so it is required to rely on the side data
* size to recognize the end. 8 byte id (as found in BlockAddId) followed
* by data.
*/
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
/**
* The optional first identifier line of a WebVTT cue.
*/
AV_PKT_DATA_WEBVTT_IDENTIFIER,
/**
* The optional settings (rendering instructions) that immediately
* follow the timestamp specifier of a WebVTT cue.
*/
AV_PKT_DATA_WEBVTT_SETTINGS,
/**
* A list of zero terminated key/value strings. There is no end marker for
* the list, so it is required to rely on the side data size to stop. This
* side data includes updated metadata which appeared in the stream.
*/
AV_PKT_DATA_METADATA_UPDATE,
/**
* MPEGTS stream ID as uint8_t, this is required to pass the stream ID
* information from the demuxer to the corresponding muxer.
*/
AV_PKT_DATA_MPEGTS_STREAM_ID,
/**
* Mastering display metadata (based on SMPTE-2086:2014). This metadata
* should be associated with a video stream and contains data in the form
* of the AVMasteringDisplayMetadata struct.
*/
AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
/**
* This side data should be associated with a video stream and corresponds
* to the AVSphericalMapping structure.
*/
AV_PKT_DATA_SPHERICAL,
/**
* Content light level (based on CTA-861.3). This metadata should be
* associated with a video stream and contains data in the form of the
* AVContentLightMetadata struct.
*/
AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
/**
* ATSC A53 Part 4 Closed Captions. This metadata should be associated with
* a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
* The number of bytes of CC data is AVPacketSideData.size.
*/
AV_PKT_DATA_A53_CC,
/**
* This side data is encryption initialization data.
* The format is not part of ABI, use av_encryption_init_info_* methods to
* access.
*/
AV_PKT_DATA_ENCRYPTION_INIT_INFO,
/**
* This side data contains encryption info for how to decrypt the packet.
* The format is not part of ABI, use av_encryption_info_* methods to access.
*/
AV_PKT_DATA_ENCRYPTION_INFO,
/**
* Active Format Description data consisting of a single byte as specified
* in ETSI TS 101 154 using AVActiveFormatDescription enum.
*/
AV_PKT_DATA_AFD,
/**
* Producer Reference Time data corresponding to the AVProducerReferenceTime struct,
* usually exported by some encoders (on demand through the prft flag set in the
* AVCodecContext export_side_data field).
*/
AV_PKT_DATA_PRFT,
/**
* ICC profile data consisting of an opaque octet buffer following the
* format described by ISO 15076-1.
*/
AV_PKT_DATA_ICC_PROFILE,
/**
* DOVI configuration
* ref:
* dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2
* dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3
* Tags are stored in struct AVDOVIDecoderConfigurationRecord.
*/
AV_PKT_DATA_DOVI_CONF,
/**
* Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t
* where the first uint32_t describes how many (1-3) of the other timecodes are used.
* The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
* function in libavutil/timecode.h.
*/
AV_PKT_DATA_S12M_TIMECODE,
/**
* HDR10+ dynamic metadata associated with a video frame. The metadata is in
* the form of the AVDynamicHDRPlus struct and contains
* information for color volume transform - application 4 of
* SMPTE 2094-40:2016 standard.
*/
AV_PKT_DATA_DYNAMIC_HDR10_PLUS,
/**
* The number of side data types.
* This is not part of the public API/ABI in the sense that it may
* change when new side data types are added.
* This must stay the last enum value.
* If its value becomes huge, some code using it
* needs to be updated as it assumes it to be smaller than other limits.
*/
AV_PKT_DATA_NB
};
#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
typedef struct AVPacketSideData {
uint8_t *data;
size_t size;
enum AVPacketSideDataType type;
} AVPacketSideData;
/**
* This structure stores compressed data. It is typically exported by demuxers
* and then passed as input to decoders, or received as output from encoders and
* then passed to muxers.
*
* For video, it should typically contain one compressed frame. For audio it may
* contain several compressed frames. Encoders are allowed to output empty
* packets, with no compressed data, containing only side data
* (e.g. to update some stream parameters at the end of encoding).
*
* The semantics of data ownership depends on the buf field.
* If it is set, the packet data is dynamically allocated and is
* valid indefinitely until a call to av_packet_unref() reduces the
* reference count to 0.
*
* If the buf field is not set av_packet_ref() would make a copy instead
* of increasing the reference count.
*
* The side data is always allocated with av_malloc(), copied by
* av_packet_ref() and freed by av_packet_unref().
*
* sizeof(AVPacket) being a part of the public ABI is deprecated. once
* av_init_packet() is removed, new packets will only be able to be allocated
* with av_packet_alloc(), and new fields may be added to the end of the struct
* with a minor bump.
*
* @see av_packet_alloc
* @see av_packet_ref
* @see av_packet_unref
*/
typedef struct AVPacket {
/**
* A reference to the reference-counted buffer where the packet data is
* stored.
* May be NULL, then the packet data is not reference-counted.
*/
AVBufferRef *buf;
/**
* Presentation timestamp in AVStream->time_base units; the time at which
* the decompressed packet will be presented to the user.
* Can be AV_NOPTS_VALUE if it is not stored in the file.
* pts MUST be larger or equal to dts as presentation cannot happen before
* decompression, unless one wants to view hex dumps. Some formats misuse
* the terms dts and pts/cts to mean something different. Such timestamps
* must be converted to true pts/dts before they are stored in AVPacket.
*/
int64_t pts;
/**
* Decompression timestamp in AVStream->time_base units; the time at which
* the packet is decompressed.
* Can be AV_NOPTS_VALUE if it is not stored in the file.
*/
int64_t dts;
uint8_t *data;
int size;
int stream_index;
/**
* A combination of AV_PKT_FLAG values
*/
int flags;
/**
* Additional packet data that can be provided by the container.
* Packet can contain several types of side information.
*/
AVPacketSideData *side_data;
int side_data_elems;
/**
* Duration of this packet in AVStream->time_base units, 0 if unknown.
* Equals next_pts - this_pts in presentation order.
*/
int64_t duration;
int64_t pos; ///< byte position in stream, -1 if unknown
/**
* for some private data of the user
*/
void *opaque;
/**
* AVBufferRef for free use by the API user. FFmpeg will never check the
* contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when
* the packet is unreferenced. av_packet_copy_props() calls create a new
* reference with av_buffer_ref() for the target packet's opaque_ref field.
*
* This is unrelated to the opaque field, although it serves a similar
* purpose.
*/
AVBufferRef *opaque_ref;
/**
* Time base of the packet's timestamps.
* In the future, this field may be set on packets output by encoders or
* demuxers, but its value will be by default ignored on input to decoders
* or muxers.
*/
AVRational time_base;
} AVPacket;
#if FF_API_INIT_PACKET
attribute_deprecated
typedef struct AVPacketList {
AVPacket pkt;
struct AVPacketList *next;
} AVPacketList;
#endif
#define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
/**
* Flag is used to discard packets which are required to maintain valid
* decoder state but are not required for output and should be dropped
* after decoding.
**/
#define AV_PKT_FLAG_DISCARD 0x0004
/**
* The packet comes from a trusted source.
*
* Otherwise-unsafe constructs such as arbitrary pointers to data
* outside the packet may be followed.
*/
#define AV_PKT_FLAG_TRUSTED 0x0008
/**
* Flag is used to indicate packets that contain frames that can
* be discarded by the decoder. I.e. Non-reference frames.
*/
#define AV_PKT_FLAG_DISPOSABLE 0x0010
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_LAYOUT = 0x0002,
#endif
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
};
/**
* Allocate an AVPacket and set its fields to default values. The resulting
* struct must be freed using av_packet_free().
*
* @return An AVPacket filled with default values or NULL on failure.
*
* @note this only allocates the AVPacket itself, not the data buffers. Those
* must be allocated through other means such as av_new_packet.
*
* @see av_new_packet
*/
AVPacket *av_packet_alloc(void);
/**
* Create a new packet that references the same data as src.
*
* This is a shortcut for av_packet_alloc()+av_packet_ref().
*
* @return newly created AVPacket on success, NULL on error.
*
* @see av_packet_alloc
* @see av_packet_ref
*/
AVPacket *av_packet_clone(const AVPacket *src);
/**
* Free the packet, if the packet is reference counted, it will be
* unreferenced first.
*
* @param pkt packet to be freed. The pointer will be set to NULL.
* @note passing NULL is a no-op.
*/
void av_packet_free(AVPacket **pkt);
#if FF_API_INIT_PACKET
/**
* Initialize optional fields of a packet with default values.
*
* Note, this does not touch the data and size members, which have to be
* initialized separately.
*
* @param pkt packet
*
* @see av_packet_alloc
* @see av_packet_unref
*
* @deprecated This function is deprecated. Once it's removed,
sizeof(AVPacket) will not be a part of the ABI anymore.
*/
attribute_deprecated
void av_init_packet(AVPacket *pkt);
#endif
/**
* Allocate the payload of a packet and initialize its fields with
* default values.
*
* @param pkt packet
* @param size wanted payload size
* @return 0 if OK, AVERROR_xxx otherwise
*/
int av_new_packet(AVPacket *pkt, int size);
/**
* Reduce packet size, correctly zeroing padding
*
* @param pkt packet
* @param size new size
*/
void av_shrink_packet(AVPacket *pkt, int size);
/**
* Increase packet size, correctly zeroing padding
*
* @param pkt packet
* @param grow_by number of bytes by which to increase the size of the packet
*/
int av_grow_packet(AVPacket *pkt, int grow_by);
/**
* Initialize a reference-counted packet from av_malloc()ed data.
*
* @param pkt packet to be initialized. This function will set the data, size,
* and buf fields, all others are left untouched.
* @param data Data allocated by av_malloc() to be used as packet data. If this
* function returns successfully, the data is owned by the underlying AVBuffer.
* The caller may not access the data through other means.
* @param size size of data in bytes, without the padding. I.e. the full buffer
* size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
*
* @return 0 on success, a negative AVERROR on error
*/
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
/**
* Allocate new information of a packet.
*
* @param pkt packet
* @param type side information type
* @param size side information size
* @return pointer to fresh allocated data or NULL otherwise
*/
uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
size_t size);
/**
* Wrap an existing array as a packet side data.
*
* @param pkt packet
* @param type side information type
* @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
* pkt.
* @param size side information size
* @return a non-negative number on success, a negative AVERROR code on
* failure. On failure, the packet is unchanged and the data remains
* owned by the caller.
*/
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
uint8_t *data, size_t size);
/**
* Shrink the already allocated side data buffer
*
* @param pkt packet
* @param type side information type
* @param size new side information size
* @return 0 on success, < 0 on failure
*/
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
size_t size);
/**
* Get side information from packet.
*
* @param pkt packet
* @param type desired side information type
* @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.
* @return pointer to data if present or NULL otherwise
*/
uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
size_t *size);
const char *av_packet_side_data_name(enum AVPacketSideDataType type);
/**
* Pack a dictionary for use in side_data.
*
* @param dict The dictionary to pack.
* @param size pointer to store the size of the returned data
* @return pointer to data if successful, NULL otherwise
*/
uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
/**
* Unpack a dictionary from side_data.
*
* @param data data from side_data
* @param size size of the data
* @param dict the metadata storage dictionary
* @return 0 on success, < 0 on failure
*/
int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
AVDictionary **dict);
/**
* Convenience function to free all the side data stored.
* All the other fields stay untouched.
*
* @param pkt packet
*/
void av_packet_free_side_data(AVPacket *pkt);
/**
* Setup a new reference to the data described by a given packet
*
* If src is reference-counted, setup dst as a new reference to the
* buffer in src. Otherwise allocate a new buffer in dst and copy the
* data from src into it.
*
* All the other fields are copied from src.
*
* @see av_packet_unref
*
* @param dst Destination packet. Will be completely overwritten.
* @param src Source packet
*
* @return 0 on success, a negative AVERROR on error. On error, dst
* will be blank (as if returned by av_packet_alloc()).
*/
int av_packet_ref(AVPacket *dst, const AVPacket *src);
/**
* Wipe the packet.
*
* Unreference the buffer referenced by the packet and reset the
* remaining packet fields to their default values.
*
* @param pkt The packet to be unreferenced.
*/
void av_packet_unref(AVPacket *pkt);
/**
* Move every field in src to dst and reset src.
*
* @see av_packet_unref
*
* @param src Source packet, will be reset
* @param dst Destination packet
*/
void av_packet_move_ref(AVPacket *dst, AVPacket *src);
/**
* Copy only "properties" fields from src to dst.
*
* Properties for the purpose of this function are all the fields
* beside those related to the packet data (buf, data, size)
*
* @param dst Destination packet
* @param src Source packet
*
* @return 0 on success AVERROR on failure.
*/
int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
/**
* Ensure the data described by a given packet is reference counted.
*
* @note This function does not ensure that the reference will be writable.
* Use av_packet_make_writable instead for that purpose.
*
* @see av_packet_ref
* @see av_packet_make_writable
*
* @param pkt packet whose data should be made reference counted.
*
* @return 0 on success, a negative AVERROR on error. On failure, the
* packet is unchanged.
*/
int av_packet_make_refcounted(AVPacket *pkt);
/**
* Create a writable reference for the data described by a given packet,
* avoiding data copy if possible.
*
* @param pkt Packet whose data should be made writable.
*
* @return 0 on success, a negative AVERROR on failure. On failure, the
* packet is unchanged.
*/
int av_packet_make_writable(AVPacket *pkt);
/**
* Convert valid timing fields (timestamps / durations) in a packet from one
* timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
* ignored.
*
* @param pkt packet on which the conversion will be performed
* @param tb_src source timebase, in which the timing fields in pkt are
* expressed
* @param tb_dst destination timebase, to which the timing fields will be
* converted
*/
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
/**
* @}
*/
#endif // AVCODEC_PACKET_H

86
ext_includes/ffmpeg/libavcodec/vaapi.h
View File

@ -1,86 +0,0 @@
/*
* Video Acceleration API (shared data between FFmpeg and the video player)
* HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
*
* Copyright (C) 2008-2009 Splitted-Desktop Systems
*
* 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_VAAPI_H
#define AVCODEC_VAAPI_H
/**
* @file
* @ingroup lavc_codec_hwaccel_vaapi
* Public libavcodec VA API header.
*/
#include <stdint.h>
#include "libavutil/attributes.h"
#include "version.h"
#if FF_API_STRUCT_VAAPI_CONTEXT
/**
* @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
* @ingroup lavc_codec_hwaccel
* @{
*/
/**
* This structure is used to share data between the FFmpeg library and
* the client video application.
* This shall be zero-allocated and available as
* AVCodecContext.hwaccel_context. All user members can be set once
* during initialization or through each AVCodecContext.get_buffer()
* function call. In any case, they must be valid prior to calling
* decoding functions.
*
* Deprecated: use AVCodecContext.hw_frames_ctx instead.
*/
struct attribute_deprecated vaapi_context {
/**
* Window system dependent data
*
* - encoding: unused
* - decoding: Set by user
*/
void *display;
/**
* Configuration ID
*
* - encoding: unused
* - decoding: Set by user
*/
uint32_t config_id;
/**
* Context ID (video decode pipeline)
*
* - encoding: unused
* - decoding: Set by user
*/
uint32_t context_id;
};
/* @} */
#endif /* FF_API_STRUCT_VAAPI_CONTEXT */
#endif /* AVCODEC_VAAPI_H */

19
ext_includes/ffmpeg/libavcodec/vdpau.h
View File

@ -55,7 +55,6 @@
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "avcodec.h" #include "avcodec.h"
#include "version.h"
struct AVCodecContext; struct AVCodecContext;
struct AVFrame; struct AVFrame;
@ -153,24 +152,6 @@ int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
*/ */
AVVDPAUContext *av_vdpau_alloc_context(void); AVVDPAUContext *av_vdpau_alloc_context(void);
#if FF_API_VDPAU_PROFILE
/**
* Get a decoder profile that should be used for initializing a VDPAU decoder.
* Should be called from the AVCodecContext.get_format() callback.
*
* @deprecated Use av_vdpau_bind_context() instead.
*
* @param avctx the codec context being used for decoding the stream
* @param profile a pointer into which the result will be written on success.
* The contents of profile are undefined if this function returns
* an error.
*
* @return 0 on success (non-negative), a negative AVERROR on failure.
*/
attribute_deprecated
int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile);
#endif
/* @}*/ /* @}*/
#endif /* AVCODEC_VDPAU_H */ #endif /* AVCODEC_VDPAU_H */

98
ext_includes/ffmpeg/libavcodec/version.h
View File

@ -27,8 +27,9 @@
#include "libavutil/version.h" #include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 58 #include "version_major.h"
#define LIBAVCODEC_VERSION_MINOR 43
#define LIBAVCODEC_VERSION_MINOR 37
#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,97 +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.
*/
#ifndef FF_API_LOWRES
#define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_DEBUG_MV
#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 58)
#endif
#ifndef FF_API_AVCTX_TIMEBASE
#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_CODED_FRAME
#define FF_API_CODED_FRAME (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_SIDEDATA_ONLY_PKT
#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_VDPAU_PROFILE
#define FF_API_VDPAU_PROFILE (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_CONVERGENCE_DURATION
#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_AVPICTURE
#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_AVPACKET_OLD_API
#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_RTP_CALLBACK
#define FF_API_RTP_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_VBV_DELAY
#define FF_API_VBV_DELAY (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_CODER_TYPE
#define FF_API_CODER_TYPE (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_STAT_BITS
#define FF_API_STAT_BITS (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_PRIVATE_OPT
#define FF_API_PRIVATE_OPT (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_ASS_TIMING
#define FF_API_ASS_TIMING (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_OLD_BSF
#define FF_API_OLD_BSF (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_COPY_CONTEXT
#define FF_API_COPY_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_GET_CONTEXT_DEFAULTS
#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_NVENC_OLD_NAME
#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_STRUCT_VAAPI_CONTEXT
#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_MERGE_SD_API
#define FF_API_MERGE_SD_API (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_TAG_STRING
#define FF_API_TAG_STRING (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_GETCHROMA
#define FF_API_GETCHROMA (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_CODEC_GET_SET
#define FF_API_CODEC_GET_SET (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_USER_VISIBLE_AVHWACCEL
#define FF_API_USER_VISIBLE_AVHWACCEL (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_LOCKMGR
#define FF_API_LOCKMGR (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_NEXT
#define FF_API_NEXT (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#endif /* AVCODEC_VERSION_H */ #endif /* AVCODEC_VERSION_H */

54
ext_includes/ffmpeg/libavcodec/version_major.h Normal file
View File

@ -0,0 +1,54 @@
/*
* 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 59
/**
* 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_FLAG_TRUNCATED (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_SUB_TEXT_FORMAT (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_IDCT_NONE (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_SVTAV1_OPTS (LIBAVCODEC_VERSION_MAJOR < 60)
#endif /* AVCODEC_VERSION_MAJOR_H */

3
ext_includes/ffmpeg/libavcodec/xvmc.h
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"
/** /**

874
ext_includes/ffmpeg/libavformat/avformat.h
View File

File diff suppressed because it is too large Load Diff

131
ext_includes/ffmpeg/libavformat/avio.h
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.
@ -148,9 +149,9 @@ enum AVIODataMarkerType {
/** /**
* Bytestream IO Context. * Bytestream IO Context.
* New fields can be added to the end with minor version bumps. * New public fields can be added with minor version bumps.
* Removal, reordering and changes to existing fields require a major * Removal, reordering and changes to existing public fields require
* version bump. * a major version bump.
* sizeof(AVIOContext) must not be used outside libav*. * sizeof(AVIOContext) must not be used outside libav*.
* *
* @note None of the function pointers in AVIOContext should be called * @note None of the function pointers in AVIOContext should be called
@ -237,12 +238,14 @@ typedef struct AVIOContext {
int64_t (*seek)(void *opaque, int64_t offset, int whence); int64_t (*seek)(void *opaque, int64_t offset, int whence);
int64_t pos; /**< position in the file of the current buffer */ int64_t pos; /**< position in the file of the current buffer */
int eof_reached; /**< true if was unable to read due to error or eof */ int eof_reached; /**< true if was unable to read due to error or eof */
int error; /**< contains the error code or 0 if no error happened */
int write_flag; /**< true if open for writing */ int write_flag; /**< true if open for writing */
int max_packet_size; int max_packet_size;
int min_packet_size; /**< Try to buffer at least this amount of data
before flushing it. */
unsigned long checksum; unsigned long checksum;
unsigned char *checksum_ptr; unsigned char *checksum_ptr;
unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size); unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
int error; /**< contains the error code or 0 if no error happened */
/** /**
* Pause or resume playback for network streaming protocols - e.g. MMS. * Pause or resume playback for network streaming protocols - e.g. MMS.
*/ */
@ -259,12 +262,6 @@ typedef struct AVIOContext {
*/ */
int seekable; int seekable;
/**
* max filesize, used to limit allocations
* This field is internal to libavformat and access from outside is not allowed.
*/
int64_t maxsize;
/** /**
* avio_read and avio_write should if possible be satisfied directly * avio_read and avio_write should if possible be satisfied directly
* instead of going through a buffer, and avio_seek will always * instead of going through a buffer, and avio_seek will always
@ -272,37 +269,6 @@ typedef struct AVIOContext {
*/ */
int direct; int direct;
/**
* Bytes read statistic
* This field is internal to libavformat and access from outside is not allowed.
*/
int64_t bytes_read;
/**
* seek statistic
* This field is internal to libavformat and access from outside is not allowed.
*/
int seek_count;
/**
* writeout statistic
* This field is internal to libavformat and access from outside is not allowed.
*/
int writeout_count;
/**
* Original buffer size
* used internally after probing and ensure seekback to reset the buffer size
* This field is internal to libavformat and access from outside is not allowed.
*/
int orig_buffer_size;
/**
* Threshold to favor readahead over seek.
* This is current internal only, do not use from outside.
*/
int short_seek_threshold;
/** /**
* ',' separated list of allowed protocols. * ',' separated list of allowed protocols.
*/ */
@ -325,19 +291,15 @@ typedef struct AVIOContext {
*/ */
int ignore_boundary_point; int ignore_boundary_point;
#if FF_API_AVIOCONTEXT_WRITTEN
/** /**
* Internal, not meant to be used from outside of AVIOContext. * @deprecated field utilized privately by libavformat. For a public
* statistic of how many bytes were written out, see
* AVIOContext::bytes_written.
*/ */
enum AVIODataMarkerType current_type; attribute_deprecated
int64_t last_time;
/**
* A callback that is used instead of short_seek_threshold.
* This is current internal only, do not use from outside.
*/
int (*short_seek_get)(void *opaque);
int64_t written; 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,
@ -346,9 +308,14 @@ typedef struct AVIOContext {
unsigned char *buf_ptr_max; unsigned char *buf_ptr_max;
/** /**
* Try to buffer at least this amount of data before flushing it * Read-only statistic of bytes read for this AVIOContext.
*/ */
int min_packet_size; int64_t bytes_read;
/**
* Read-only statistic of bytes written for this AVIOContext.
*/
int64_t bytes_written;
} AVIOContext; } AVIOContext;
/** /**
@ -374,25 +341,6 @@ const char *avio_find_protocol_name(const char *url);
*/ */
int avio_check(const char *url, int flags); int avio_check(const char *url, int flags);
/**
* Move or rename a resource.
*
* @note url_src and url_dst should share the same protocol and authority.
*
* @param url_src url to resource to be moved
* @param url_dst new url to resource if the operation succeeded
* @return >=0 on success or negative on error.
*/
int avpriv_io_move(const char *url_src, const char *url_dst);
/**
* Delete a resource.
*
* @param url resource to be deleted.
* @return >=0 on success or negative on error.
*/
int avpriv_io_delete(const char *url);
/** /**
* Open directory for reading. * Open directory for reading.
* *
@ -571,9 +519,35 @@ int64_t avio_size(AVIOContext *s);
*/ */
int avio_feof(AVIOContext *s); int avio_feof(AVIOContext *s);
/** @warning Writes up to 4 KiB per call */ /**
* 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.
* @return number of bytes written, < 0 on error.
*/
int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3); int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
/**
* Write a NULL terminated array of strings to the context.
* Usually you don't need to use this function directly but its macro wrapper,
* avio_print.
*/
void avio_print_string_array(AVIOContext *s, const char *strings[]);
/**
* Write strings (const char *) to the context.
* This is a convenience macro around avio_print_string_array and it
* automatically creates the string array from the variable argument list.
* For simple string concatenations this function is more performant than using
* avio_printf since it does not need a temporary buffer.
*/
#define avio_print(s, ...) \
avio_print_string_array(s, (const char*[]){__VA_ARGS__, NULL})
/** /**
* Force flushing of buffered data. * Force flushing of buffered data.
* *
@ -787,6 +761,13 @@ int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
*/ */
const char *avio_enum_protocols(void **opaque, int output); const char *avio_enum_protocols(void **opaque, int output);
/**
* Get AVClass by names of available protocols.
*
* @return A AVClass of input protocol name or NULL
*/
const AVClass *avio_protocol_get_class(const char *name);
/** /**
* Pause and resume playing - only meaningful if using a network streaming * Pause and resume playing - only meaningful if using a network streaming
* protocol (e.g. MMS). * protocol (e.g. MMS).

70
ext_includes/ffmpeg/libavformat/version.h
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 58 #define LIBAVFORMAT_VERSION_MINOR 27
#define LIBAVFORMAT_VERSION_MINOR 25
#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,67 +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.
*
*/
#ifndef FF_API_COMPUTE_PKT_FIELDS2
#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_OLD_OPEN_CALLBACKS
#define FF_API_OLD_OPEN_CALLBACKS (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_LAVF_AVCTX
#define FF_API_LAVF_AVCTX (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_HTTP_USER_AGENT
#define FF_API_HTTP_USER_AGENT (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_HLS_WRAP
#define FF_API_HLS_WRAP (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_HLS_USE_LOCALTIME
#define FF_API_HLS_USE_LOCALTIME (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_LAVF_KEEPSIDE_FLAG
#define FF_API_LAVF_KEEPSIDE_FLAG (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_OLD_ROTATE_API
#define FF_API_OLD_ROTATE_API (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_FORMAT_GET_SET
#define FF_API_FORMAT_GET_SET (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_OLD_AVIO_EOF_0
#define FF_API_OLD_AVIO_EOF_0 (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_LAVF_FFSERVER
#define FF_API_LAVF_FFSERVER (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_FORMAT_FILENAME
#define FF_API_FORMAT_FILENAME (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_OLD_RTSP_OPTIONS
#define FF_API_OLD_RTSP_OPTIONS (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_NEXT
#define FF_API_NEXT (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_DASH_MIN_SEG_DURATION
#define FF_API_DASH_MIN_SEG_DURATION (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_LAVF_MP4A_LATM
#define FF_API_LAVF_MP4A_LATM (LIBAVFORMAT_VERSION_MAJOR < 59)
#endif
#ifndef FF_API_R_FRAME_RATE
#define FF_API_R_FRAME_RATE 1
#endif
#endif /* AVFORMAT_VERSION_H */ #endif /* AVFORMAT_VERSION_H */

53
ext_includes/ffmpeg/libavformat/version_major.h Normal file
View File

@ -0,0 +1,53 @@
/*
* 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 59
/**
* 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_API_R_FRAME_RATE 1
#endif /* AVFORMAT_VERSION_MAJOR_H */

7
ext_includes/ffmpeg/libavutil/adler32.h
View File

@ -27,6 +27,7 @@
#ifndef AVUTIL_ADLER32_H #ifndef AVUTIL_ADLER32_H
#define AVUTIL_ADLER32_H #define AVUTIL_ADLER32_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
@ -38,6 +39,8 @@
* @{ * @{
*/ */
typedef uint32_t AVAdler;
/** /**
* Calculate the Adler32 checksum of a buffer. * Calculate the Adler32 checksum of a buffer.
* *
@ -50,8 +53,8 @@
* @param len size of input buffer * @param len size of input buffer
* @return updated checksum * @return updated checksum
*/ */
unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, AVAdler av_adler32_update(AVAdler adler, const uint8_t *buf,
unsigned int len) av_pure; size_t len) av_pure;
/** /**
* @} * @}

1
ext_includes/ffmpeg/libavutil/aes.h
View File

@ -24,7 +24,6 @@
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @defgroup lavu_aes AES * @defgroup lavu_aes AES

1
ext_includes/ffmpeg/libavutil/aes_ctr.h
View File

@ -25,7 +25,6 @@
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
#define AES_CTR_KEY_SIZE (16) #define AES_CTR_KEY_SIZE (16)
#define AES_CTR_IV_SIZE (8) #define AES_CTR_IV_SIZE (8)

8
ext_includes/ffmpeg/libavutil/attributes.h
View File

@ -34,6 +34,12 @@
# define AV_GCC_VERSION_AT_MOST(x,y) 0 # define AV_GCC_VERSION_AT_MOST(x,y) 0
#endif #endif
#ifdef __has_builtin
# define AV_HAS_BUILTIN(x) __has_builtin(x)
#else
# define AV_HAS_BUILTIN(x) 0
#endif
#ifndef av_always_inline #ifndef av_always_inline
#if AV_GCC_VERSION_AT_LEAST(3,1) #if AV_GCC_VERSION_AT_LEAST(3,1)
# define av_always_inline __attribute__((always_inline)) inline # define av_always_inline __attribute__((always_inline)) inline
@ -104,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
ext_includes/ffmpeg/libavutil/audio_fifo.h
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
ext_includes/ffmpeg/libavutil/avassert.h
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.

32
ext_includes/ffmpeg/libavutil/avstring.h
View File

@ -24,6 +24,7 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @addtogroup lavu_string * @addtogroup lavu_string
@ -155,10 +156,14 @@ 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. * 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); 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,
@ -274,16 +279,21 @@ char *av_strireplace(const char *str, const char *from, const char *to);
/** /**
* Thread safe basename. * Thread safe basename.
* @param path the path, on DOS both \ and / are considered separators. * @param path the string to parse, on DOS both \ and / are considered separators.
* @return pointer to the basename substring. * @return pointer to the basename substring.
* If path does not contain a slash, the function returns a copy of path.
* If path is a NULL pointer or points to an empty string, a pointer
* to a string "." is returned.
*/ */
const char *av_basename(const char *path); const char *av_basename(const char *path);
/** /**
* Thread safe dirname. * Thread safe dirname.
* @param path the path, on DOS both \ and / are considered separators. * @param path the string to parse, on DOS both \ and / are considered separators.
* @return the path with the separator replaced by the string terminator or ".". * @return A pointer to a string that's the parent directory of path.
* @note the function may change the input string. * If path is a NULL pointer or points to an empty string, a pointer
* to a string "." is returned.
* @note the function may modify the contents of the path, so copies should be passed.
*/ */
const char *av_dirname(char *path); const char *av_dirname(char *path);
@ -314,6 +324,7 @@ enum AVEscapeMode {
AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode. AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode.
AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping. AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.
AV_ESCAPE_MODE_QUOTE, ///< Use single-quote escaping. AV_ESCAPE_MODE_QUOTE, ///< Use single-quote escaping.
AV_ESCAPE_MODE_XML, ///< Use XML non-markup character data escaping.
}; };
/** /**
@ -333,6 +344,19 @@ enum AVEscapeMode {
*/ */
#define AV_ESCAPE_FLAG_STRICT (1 << 1) #define AV_ESCAPE_FLAG_STRICT (1 << 1)
/**
* Within AV_ESCAPE_MODE_XML, additionally escape single quotes for single
* quoted attributes.
*/
#define AV_ESCAPE_FLAG_XML_SINGLE_QUOTES (1 << 2)
/**
* Within AV_ESCAPE_MODE_XML, additionally escape double quotes for double
* quoted attributes.
*/
#define AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES (1 << 3)
/** /**
* Escape string in src, and put the escaped string in an allocated * Escape string in src, and put the escaped string in an allocated
* string in *dst, which must be freed with av_free(). * string in *dst, which must be freed with av_free().

6
ext_includes/ffmpeg/libavutil/avutil.h
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.

53
ext_includes/ffmpeg/libavutil/buffer.h
View File

@ -25,6 +25,7 @@
#ifndef AVUTIL_BUFFER_H #ifndef AVUTIL_BUFFER_H
#define AVUTIL_BUFFER_H #define AVUTIL_BUFFER_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
/** /**
@ -90,7 +91,7 @@ typedef struct AVBufferRef {
/** /**
* Size of data in bytes. * Size of data in bytes.
*/ */
int size; size_t size;
} AVBufferRef; } AVBufferRef;
/** /**
@ -98,13 +99,13 @@ typedef struct AVBufferRef {
* *
* @return an AVBufferRef of given size or NULL when out of memory * @return an AVBufferRef of given size or NULL when out of memory
*/ */
AVBufferRef *av_buffer_alloc(int size); AVBufferRef *av_buffer_alloc(size_t size);
/** /**
* Same as av_buffer_alloc(), except the returned buffer will be initialized * Same as av_buffer_alloc(), except the returned buffer will be initialized
* to zero. * to zero.
*/ */
AVBufferRef *av_buffer_allocz(int size); AVBufferRef *av_buffer_allocz(size_t size);
/** /**
* Always treat the buffer as read-only, even when it has only one * Always treat the buffer as read-only, even when it has only one
@ -127,7 +128,7 @@ AVBufferRef *av_buffer_allocz(int size);
* *
* @return an AVBufferRef referring to data on success, NULL on failure. * @return an AVBufferRef referring to data on success, NULL on failure.
*/ */
AVBufferRef *av_buffer_create(uint8_t *data, int size, AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
void (*free)(void *opaque, uint8_t *data), void (*free)(void *opaque, uint8_t *data),
void *opaque, int flags); void *opaque, int flags);
@ -144,7 +145,7 @@ void av_buffer_default_free(void *opaque, uint8_t *data);
* @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on
* failure. * failure.
*/ */
AVBufferRef *av_buffer_ref(AVBufferRef *buf); AVBufferRef *av_buffer_ref(const AVBufferRef *buf);
/** /**
* Free a given reference and automatically free the buffer if there are no more * Free a given reference and automatically free the buffer if there are no more
@ -195,7 +196,23 @@ int av_buffer_make_writable(AVBufferRef **buf);
* reference to it (i.e. the one passed to this function). In all other cases * reference to it (i.e. the one passed to this function). In all other cases
* a new buffer is allocated and the data is copied. * a new buffer is allocated and the data is copied.
*/ */
int av_buffer_realloc(AVBufferRef **buf, int size); int av_buffer_realloc(AVBufferRef **buf, size_t size);
/**
* Ensure dst refers to the same data as src.
*
* When *dst is already equivalent to src, do nothing. Otherwise unreference dst
* and replace it with a new reference to src.
*
* @param dst Pointer to either a valid buffer reference or NULL. On success,
* this will point to a buffer reference equivalent to src. On
* failure, dst will be left untouched.
* @param src A buffer reference to replace dst with. May be NULL, then this
* function is equivalent to av_buffer_unref(dst).
* @return 0 on success
* AVERROR(ENOMEM) on memory allocation failure.
*/
int av_buffer_replace(AVBufferRef **dst, const AVBufferRef *src);
/** /**
* @} * @}
@ -246,7 +263,7 @@ typedef struct AVBufferPool AVBufferPool;
* (av_buffer_alloc()). * (av_buffer_alloc()).
* @return newly created buffer pool on success, NULL on error. * @return newly created buffer pool on success, NULL on error.
*/ */
AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size)); AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size));
/** /**
* Allocate and initialize a buffer pool with a more complex allocator. * Allocate and initialize a buffer pool with a more complex allocator.
@ -254,16 +271,17 @@ AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
* @param size size of each buffer in this pool * @param size size of each buffer in this pool
* @param opaque arbitrary user data used by the allocator * @param opaque arbitrary user data used by the allocator
* @param alloc a function that will be used to allocate new buffers when the * @param alloc a function that will be used to allocate new buffers when the
* pool is empty. * pool is empty. May be NULL, then the default allocator will be
* used (av_buffer_alloc()).
* @param pool_free a function that will be called immediately before the pool * @param pool_free a function that will be called immediately before the pool
* is freed. I.e. after av_buffer_pool_uninit() is called * is freed. I.e. after av_buffer_pool_uninit() is called
* by the caller and all the frames are returned to the pool * by the caller and all the frames are returned to the pool
* and freed. It is intended to uninitialize the user opaque * and freed. It is intended to uninitialize the user opaque
* data. * data. May be NULL.
* @return newly created buffer pool on success, NULL on error. * @return newly created buffer pool on success, NULL on error.
*/ */
AVBufferPool *av_buffer_pool_init2(int size, void *opaque, AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque,
AVBufferRef* (*alloc)(void *opaque, int size), AVBufferRef* (*alloc)(void *opaque, size_t size),
void (*pool_free)(void *opaque)); void (*pool_free)(void *opaque));
/** /**
@ -284,6 +302,19 @@ void av_buffer_pool_uninit(AVBufferPool **pool);
*/ */
AVBufferRef *av_buffer_pool_get(AVBufferPool *pool); AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
/**
* Query the original opaque parameter of an allocated buffer in the pool.
*
* @param ref a buffer reference to a buffer returned by av_buffer_pool_get.
* @return the opaque parameter set by the buffer allocator function of the
* buffer pool.
*
* @note the opaque parameter of ref is used by the buffer pool implementation,
* therefore you have to use this function to access the original opaque
* parameter of an allocated buffer.
*/
void *av_buffer_pool_buffer_get_opaque(const AVBufferRef *ref);
/** /**
* @} * @}
*/ */

571
ext_includes/ffmpeg/libavutil/channel_layout.h
View File

@ -23,6 +23,10 @@
#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
@ -34,6 +38,111 @@
* @{ * @{
*/ */
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,36 +155,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 (1ULL << AV_CHAN_TOP_SIDE_LEFT )
#define AV_CH_TOP_SIDE_RIGHT (1ULL << AV_CHAN_TOP_SIDE_RIGHT )
#define AV_CH_BOTTOM_FRONT_CENTER (1ULL << AV_CHAN_BOTTOM_FRONT_CENTER )
#define AV_CH_BOTTOM_FRONT_LEFT (1ULL << AV_CHAN_BOTTOM_FRONT_LEFT )
#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
/** /**
* @} * @}
@ -110,6 +229,7 @@
#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_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)
enum AVMatrixEncoding { enum AVMatrixEncoding {
AV_MATRIX_ENCODING_NONE, AV_MATRIX_ENCODING_NONE,
@ -122,6 +242,149 @@ 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).
*
* Unlike most structures in Libav, 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) }}
#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_OCTAGONAL AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_OCTAGONAL)
#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
/** /**
* 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.
* *
@ -138,7 +401,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);
/** /**
@ -152,7 +418,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);
/** /**
@ -161,23 +429,31 @@ 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
* @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);
/** /**
@ -188,20 +464,28 @@ int64_t av_get_default_channel_layout(int nb_channels);
* *
* @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);
/** /**
@ -209,7 +493,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);
/** /**
@ -220,9 +506,240 @@ 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.
* @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.
* @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 channel_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
* @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
* @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
* @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
* @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);
/** /**
* @} * @}

244
ext_includes/ffmpeg/libavutil/common.h
View File

@ -31,11 +31,7 @@
#endif #endif
#include <errno.h> #include <errno.h>
/* modification for MSVC by kode54 */
#ifndef _MSC_VER
#include <inttypes.h> #include <inttypes.h>
#endif
/* end modification */
#include <limits.h> #include <limits.h>
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
@ -45,19 +41,11 @@
#include "attributes.h" #include "attributes.h"
#include "macros.h" #include "macros.h"
#include "version.h"
#include "libavutil/avconfig.h"
#if AV_HAVE_BIGENDIAN
# define AV_NE(be, le) (be)
#else
# define AV_NE(be, le) (le)
#endif
//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))
/* assume b>0 */ /* assume b>0 */
#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) #define ROUNDED_DIV(a,b) (((a)>=0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
/* Fast a/(1<<b) rounded toward +inf. Assume a>=0 and b>=0 */ /* Fast a/(1<<b) rounded toward +inf. Assume a>=0 and b>=0 */
#define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \ #define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
: ((a) + (1<<(b)) - 1) >> (b)) : ((a) + (1<<(b)) - 1) >> (b))
@ -85,23 +73,13 @@
#define FFNABS(a) ((a) <= 0 ? (a) : (-(a))) #define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
/** /**
* Comparator. * Unsigned Absolute value.
* For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0 * This takes the absolute value of a signed int and returns it as a unsigned.
* if x == y. This is useful for instance in a qsort comparator callback. * This also works with INT_MIN which would otherwise not be representable
* Furthermore, compilers are able to optimize this to branchless code, and * As with many macros, this evaluates its argument twice.
* there is no risk of overflow with signed types.
* As with many macros, this evaluates its argument multiple times, it thus
* must not have a side-effect.
*/ */
#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y))) #define FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a))
#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a))
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
/* misc math functions */ /* misc math functions */
@ -110,8 +88,72 @@
# include "intmath.h" # include "intmath.h"
#endif #endif
/* Pull in unguarded fallback defines at the end of this file. */ #ifndef av_ceil_log2
#include "common.h" # define av_ceil_log2 av_ceil_log2_c
#endif
#ifndef av_clip
# define av_clip av_clip_c
#endif
#ifndef av_clip64
# define av_clip64 av_clip64_c
#endif
#ifndef av_clip_uint8
# define av_clip_uint8 av_clip_uint8_c
#endif
#ifndef av_clip_int8
# define av_clip_int8 av_clip_int8_c
#endif
#ifndef av_clip_uint16
# define av_clip_uint16 av_clip_uint16_c
#endif
#ifndef av_clip_int16
# define av_clip_int16 av_clip_int16_c
#endif
#ifndef av_clipl_int32
# define av_clipl_int32 av_clipl_int32_c
#endif
#ifndef av_clip_intp2
# define av_clip_intp2 av_clip_intp2_c
#endif
#ifndef av_clip_uintp2
# define av_clip_uintp2 av_clip_uintp2_c
#endif
#ifndef av_mod_uintp2
# define av_mod_uintp2 av_mod_uintp2_c
#endif
#ifndef av_sat_add32
# define av_sat_add32 av_sat_add32_c
#endif
#ifndef av_sat_dadd32
# define av_sat_dadd32 av_sat_dadd32_c
#endif
#ifndef av_sat_sub32
# define av_sat_sub32 av_sat_sub32_c
#endif
#ifndef av_sat_dsub32
# define av_sat_dsub32 av_sat_dsub32_c
#endif
#ifndef av_sat_add64
# define av_sat_add64 av_sat_add64_c
#endif
#ifndef av_sat_sub64
# define av_sat_sub64 av_sat_sub64_c
#endif
#ifndef av_clipf
# define av_clipf av_clipf_c
#endif
#ifndef av_clipd
# define av_clipd av_clipd_c
#endif
#ifndef av_popcount
# define av_popcount av_popcount_c
#endif
#ifndef av_popcount64
# define av_popcount64 av_popcount64_c
#endif
#ifndef av_parity
# define av_parity av_parity_c
#endif
#ifndef av_log2 #ifndef av_log2
av_const int av_log2(unsigned v); av_const int av_log2(unsigned v);
@ -244,7 +286,7 @@ static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
*/ */
static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p) static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
{ {
return a & ((1 << p) - 1); return a & ((1U << p) - 1);
} }
/** /**
@ -295,8 +337,49 @@ static av_always_inline int av_sat_dsub32_c(int a, int b)
return av_sat_sub32(a, av_sat_add32(b, b)); return av_sat_sub32(a, av_sat_add32(b, b));
} }
/**
* Add two signed 64-bit values with saturation.
*
* @param a one value
* @param b another value
* @return sum with signed saturation
*/
static av_always_inline int64_t av_sat_add64_c(int64_t a, int64_t b) {
#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_add_overflow)
int64_t tmp;
return !__builtin_add_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN);
#else
int64_t s = a+(uint64_t)b;
if ((int64_t)(a^b | ~s^b) >= 0)
return INT64_MAX ^ (b >> 63);
return s;
#endif
}
/**
* Subtract two signed 64-bit values with saturation.
*
* @param a one value
* @param b another value
* @return difference with signed saturation
*/
static av_always_inline int64_t av_sat_sub64_c(int64_t a, int64_t b) {
#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_sub_overflow)
int64_t tmp;
return !__builtin_sub_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN);
#else
if (b <= 0 && a >= INT64_MAX + b)
return INT64_MAX;
if (b >= 0 && a <= INT64_MIN + b)
return INT64_MIN;
return a - b;
#endif
}
/** /**
* Clip a float value into the amin-amax range. * Clip a float value into the amin-amax range.
* If a is nan or -inf amin will be returned.
* If a is +inf amax will be returned.
* @param a value to clip * @param a value to clip
* @param amin minimum value of the clip range * @param amin minimum value of the clip range
* @param amax maximum value of the clip range * @param amax maximum value of the clip range
@ -307,13 +390,13 @@ static av_always_inline av_const float av_clipf_c(float a, float amin, float ama
#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
if (amin > amax) abort(); if (amin > amax) abort();
#endif #endif
if (a < amin) return amin; return FFMIN(FFMAX(a, amin), amax);
else if (a > amax) return amax;
else return a;
} }
/** /**
* Clip a double value into the amin-amax range. * Clip a double value into the amin-amax range.
* If a is nan or -inf amin will be returned.
* If a is +inf amax will be returned.
* @param a value to clip * @param a value to clip
* @param amin minimum value of the clip range * @param amin minimum value of the clip range
* @param amax maximum value of the clip range * @param amax maximum value of the clip range
@ -324,9 +407,7 @@ static av_always_inline av_const double av_clipd_c(double a, double amin, double
#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
if (amin > amax) abort(); if (amin > amax) abort();
#endif #endif
if (a < amin) return amin; return FFMIN(FFMAX(a, amin), amax);
else if (a > amax) return amax;
else return a;
} }
/** Compute ceil(log2(x)). /** Compute ceil(log2(x)).
@ -335,7 +416,7 @@ static av_always_inline av_const double av_clipd_c(double a, double amin, double
*/ */
static av_always_inline av_const int av_ceil_log2_c(int x) static av_always_inline av_const int av_ceil_log2_c(int x)
{ {
return av_log2((x - 1) << 1); return av_log2((x - 1U) << 1);
} }
/** /**
@ -367,9 +448,6 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
return av_popcount(v) & 1; return av_popcount(v) & 1;
} }
#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
/** /**
* Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form. * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
* *
@ -377,7 +455,9 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
* @param GET_BYTE Expression reading one byte from the input. * @param GET_BYTE Expression reading one byte from the input.
* Evaluated up to 7 times (4 for the currently * Evaluated up to 7 times (4 for the currently
* assigned Unicode range). With a memory buffer * assigned Unicode range). With a memory buffer
* input, this could be *ptr++. * input, this could be *ptr++, or if you want to make sure
* that *ptr stops at the end of a NULL terminated string then
* *ptr ? *ptr++ : 0
* @param ERROR Expression to be evaluated on invalid input, * @param ERROR Expression to be evaluated on invalid input,
* typically a goto statement. * typically a goto statement.
* *
@ -391,11 +471,11 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
{\ {\
uint32_t top = (val & 128) >> 1;\ uint32_t top = (val & 128) >> 1;\
if ((val & 0xc0) == 0x80 || val >= 0xFE)\ if ((val & 0xc0) == 0x80 || val >= 0xFE)\
ERROR\ {ERROR}\
while (val & top) {\ while (val & top) {\
int tmp= (GET_BYTE) - 128;\ unsigned int tmp = (GET_BYTE) - 128;\
if(tmp>>6)\ if(tmp>>6)\
ERROR\ {ERROR}\
val= (val<<6) + tmp;\ val= (val<<6) + tmp;\
top <<= 5;\ top <<= 5;\
}\ }\
@ -412,13 +492,13 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
* typically a goto statement. * typically a goto statement.
*/ */
#define GET_UTF16(val, GET_16BIT, ERROR)\ #define GET_UTF16(val, GET_16BIT, ERROR)\
val = GET_16BIT;\ val = (GET_16BIT);\
{\ {\
unsigned int hi = val - 0xD800;\ unsigned int hi = val - 0xD800;\
if (hi < 0x800) {\ if (hi < 0x800) {\
val = GET_16BIT - 0xDC00;\ val = (GET_16BIT) - 0xDC00;\
if (val > 0x3FFU || hi > 0x3FFU)\ if (val > 0x3FFU || hi > 0x3FFU)\
ERROR\ {ERROR}\
val += (hi<<10) + 0x10000;\ val += (hi<<10) + 0x10000;\
}\ }\
}\ }\
@ -496,69 +576,3 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
#endif /* HAVE_AV_CONFIG_H */ #endif /* HAVE_AV_CONFIG_H */
#endif /* AVUTIL_COMMON_H */ #endif /* AVUTIL_COMMON_H */
/*
* The following definitions are outside the multiple inclusion guard
* to ensure they are immediately available in intmath.h.
*/
#ifndef av_ceil_log2
# define av_ceil_log2 av_ceil_log2_c
#endif
#ifndef av_clip
# define av_clip av_clip_c
#endif
#ifndef av_clip64
# define av_clip64 av_clip64_c
#endif
#ifndef av_clip_uint8
# define av_clip_uint8 av_clip_uint8_c
#endif
#ifndef av_clip_int8
# define av_clip_int8 av_clip_int8_c
#endif
#ifndef av_clip_uint16
# define av_clip_uint16 av_clip_uint16_c
#endif
#ifndef av_clip_int16
# define av_clip_int16 av_clip_int16_c
#endif
#ifndef av_clipl_int32
# define av_clipl_int32 av_clipl_int32_c
#endif
#ifndef av_clip_intp2
# define av_clip_intp2 av_clip_intp2_c
#endif
#ifndef av_clip_uintp2
# define av_clip_uintp2 av_clip_uintp2_c
#endif
#ifndef av_mod_uintp2
# define av_mod_uintp2 av_mod_uintp2_c
#endif
#ifndef av_sat_add32
# define av_sat_add32 av_sat_add32_c
#endif
#ifndef av_sat_dadd32
# define av_sat_dadd32 av_sat_dadd32_c
#endif
#ifndef av_sat_sub32
# define av_sat_sub32 av_sat_sub32_c
#endif
#ifndef av_sat_dsub32
# define av_sat_dsub32 av_sat_dsub32_c
#endif
#ifndef av_clipf
# define av_clipf av_clipf_c
#endif
#ifndef av_clipd
# define av_clipd av_clipd_c
#endif
#ifndef av_popcount
# define av_popcount av_popcount_c
#endif
#ifndef av_popcount64
# define av_popcount64 av_popcount64_c
#endif
#ifndef av_parity
# define av_parity av_parity_c
#endif

36
ext_includes/ffmpeg/libavutil/cpu.h
View File

@ -23,8 +23,6 @@
#include <stddef.h> #include <stddef.h>
#include "attributes.h"
#define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */ #define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */
/* lower 16 bits - CPU features */ /* lower 16 bits - CPU features */
@ -56,6 +54,8 @@
#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_ALTIVEC 0x0001 ///< standard #define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard
#define AV_CPU_FLAG_VSX 0x0002 ///< ISA 2.06 #define AV_CPU_FLAG_VSX 0x0002 ///< ISA 2.06
@ -71,6 +71,13 @@
#define AV_CPU_FLAG_VFP_VM (1 << 7) ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations #define AV_CPU_FLAG_VFP_VM (1 << 7) ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations
#define AV_CPU_FLAG_SETEND (1 <<16) #define AV_CPU_FLAG_SETEND (1 <<16)
#define AV_CPU_FLAG_MMI (1 << 0)
#define AV_CPU_FLAG_MSA (1 << 1)
//Loongarch SIMD extension.
#define AV_CPU_FLAG_LSX (1 << 0)
#define AV_CPU_FLAG_LASX (1 << 1)
/** /**
* 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
@ -85,25 +92,6 @@ int av_get_cpu_flags(void);
*/ */
void av_force_cpu_flags(int flags); void av_force_cpu_flags(int flags);
/**
* Set a mask on flags returned by av_get_cpu_flags().
* This function is mainly useful for testing.
* Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible
*/
attribute_deprecated void av_set_cpu_flags_mask(int mask);
/**
* Parse CPU flags from a string.
*
* The returned flags contain the specified flags as well as related unspecified flags.
*
* This function exists only for compatibility with libav.
* Please use av_parse_cpu_caps() when possible.
* @return a combination of AV_CPU_* flags, negative on error.
*/
attribute_deprecated
int av_parse_cpu_flags(const char *s);
/** /**
* Parse CPU caps from a string and update the given AV_CPU_* flags based on that. * Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
* *
@ -116,6 +104,12 @@ int av_parse_cpu_caps(unsigned *flags, const char *s);
*/ */
int av_cpu_count(void); int av_cpu_count(void);
/**
* Overrides cpu count detection and forces the specified count.
* Count < 1 disables forcing of specific count.
*/
void av_cpu_force_count(int count);
/** /**
* Get the maximum data alignment that may be required by FFmpeg. * Get the maximum data alignment that may be required by FFmpeg.
* *

1
ext_includes/ffmpeg/libavutil/crc.h
View File

@ -30,7 +30,6 @@
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @defgroup lavu_crc32 CRC * @defgroup lavu_crc32 CRC

106
ext_includes/ffmpeg/libavutil/csp.h Normal file
View File

@ -0,0 +1,106 @@
/*
* Copyright (c) 2016 Ronald S. Bultje <rsbultje@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.
* @author Ronald S. Bultje <rsbultje@gmail.com>
* @author Leo Izen <leo.izen@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;
/**
* 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);
/**
* @}
*/
#endif /* AVUTIL_CSP_H */

107
ext_includes/ffmpeg/libavutil/detection_bbox.h Normal file
View File

@ -0,0 +1,107 @@
/*
* 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_DETECTION_BBOX_H
#define AVUTIL_DETECTION_BBOX_H
#include "rational.h"
#include "avassert.h"
#include "frame.h"
typedef struct AVDetectionBBox {
/**
* Distance in pixels from the left/top edge of the frame,
* together with width and height, defining the bounding box.
*/
int x;
int y;
int w;
int h;
#define AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE 64
/**
* Detect result with confidence
*/
char detect_label[AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE];
AVRational detect_confidence;
/**
* At most 4 classifications based on the detected bounding box.
* For example, we can get max 4 different attributes with 4 different
* DNN models on one bounding box.
* classify_count is zero if no classification.
*/
#define AV_NUM_DETECTION_BBOX_CLASSIFY 4
uint32_t classify_count;
char classify_labels[AV_NUM_DETECTION_BBOX_CLASSIFY][AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE];
AVRational classify_confidences[AV_NUM_DETECTION_BBOX_CLASSIFY];
} AVDetectionBBox;
typedef struct AVDetectionBBoxHeader {
/**
* Information about how the bounding box is generated.
* for example, the DNN model name.
*/
char source[256];
/**
* Number of bounding boxes in the array.
*/
uint32_t nb_bboxes;
/**
* Offset in bytes from the beginning of this structure at which
* the array of bounding boxes starts.
*/
size_t bboxes_offset;
/**
* Size of each bounding box in bytes.
*/
size_t bbox_size;
} AVDetectionBBoxHeader;
/*
* Get the bounding box at the specified {@code idx}. Must be between 0 and nb_bboxes.
*/
static av_always_inline AVDetectionBBox *
av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
{
av_assert0(idx < header->nb_bboxes);
return (AVDetectionBBox *)((uint8_t *)header + header->bboxes_offset +
idx * header->bbox_size);
}
/**
* Allocates memory for AVDetectionBBoxHeader, plus an array of {@code nb_bboxes}
* AVDetectionBBox, and initializes the variables.
* Can be freed with a normal av_free() call.
*
* @param out_size if non-NULL, the size in bytes of the resulting data array is
* written here.
*/
AVDetectionBBoxHeader *av_detection_bbox_alloc(uint32_t nb_bboxes, size_t *out_size);
/**
* Allocates memory for AVDetectionBBoxHeader, plus an array of {@code nb_bboxes}
* AVDetectionBBox, in the given AVFrame {@code frame} as AVFrameSideData of type
* AV_FRAME_DATA_DETECTION_BBOXES and initializes the variables.
*/
AVDetectionBBoxHeader *av_detection_bbox_create_side_data(AVFrame *frame, uint32_t nb_bboxes);
#endif

2
ext_includes/ffmpeg/libavutil/dict.h
View File

@ -32,8 +32,6 @@
#include <stdint.h> #include <stdint.h>
#include "version.h"
/** /**
* @addtogroup lavu_dict AVDictionary * @addtogroup lavu_dict AVDictionary
* @ingroup lavu_data * @ingroup lavu_data

3
ext_includes/ffmpeg/libavutil/display.h
View File

@ -27,7 +27,6 @@
#define AVUTIL_DISPLAY_H #define AVUTIL_DISPLAY_H
#include <stdint.h> #include <stdint.h>
#include "common.h"
/** /**
* @addtogroup lavu_video * @addtogroup lavu_video
@ -88,7 +87,7 @@
double av_display_rotation_get(const int32_t matrix[9]); double av_display_rotation_get(const int32_t matrix[9]);
/** /**
* Initialize a transformation matrix describing a pure counterclockwise * 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 matrix an allocated transformation matrix (will be fully overwritten

236
ext_includes/ffmpeg/libavutil/dovi_meta.h Normal file
View File

@ -0,0 +1,236 @@
/*
* Copyright (c) 2020 Vacing Fang <vacingfang@tencent.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
* DOVI configuration
*/
#ifndef AVUTIL_DOVI_META_H
#define AVUTIL_DOVI_META_H
#include <stdint.h>
#include <stddef.h>
#include "rational.h"
/*
* DOVI configuration
* ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2
dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2
* @code
* uint8_t dv_version_major, the major version number that the stream complies with
* uint8_t dv_version_minor, the minor version number that the stream complies with
* uint8_t dv_profile, the Dolby Vision profile
* uint8_t dv_level, the Dolby Vision level
* uint8_t rpu_present_flag
* uint8_t el_present_flag
* uint8_t bl_present_flag
* uint8_t dv_bl_signal_compatibility_id
* @endcode
*
* @note The struct must be allocated with av_dovi_alloc() and
* its size is not a part of the public ABI.
*/
typedef struct AVDOVIDecoderConfigurationRecord {
uint8_t dv_version_major;
uint8_t dv_version_minor;
uint8_t dv_profile;
uint8_t dv_level;
uint8_t rpu_present_flag;
uint8_t el_present_flag;
uint8_t bl_present_flag;
uint8_t dv_bl_signal_compatibility_id;
} AVDOVIDecoderConfigurationRecord;
/**
* Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its
* fields to default values.
*
* @return the newly allocated struct or NULL on failure
*/
AVDOVIDecoderConfigurationRecord *av_dovi_alloc(size_t *size);
/**
* Dolby Vision RPU data header.
*
* @note sizeof(AVDOVIRpuDataHeader) is not part of the public ABI.
*/
typedef struct AVDOVIRpuDataHeader {
uint8_t rpu_type;
uint16_t rpu_format;
uint8_t vdr_rpu_profile;
uint8_t vdr_rpu_level;
uint8_t chroma_resampling_explicit_filter_flag;
uint8_t coef_data_type; /* informative, lavc always converts to fixed */
uint8_t coef_log2_denom;
uint8_t vdr_rpu_normalized_idc;
uint8_t bl_video_full_range_flag;
uint8_t bl_bit_depth; /* [8, 16] */
uint8_t el_bit_depth; /* [8, 16] */
uint8_t vdr_bit_depth; /* [8, 16] */
uint8_t spatial_resampling_filter_flag;
uint8_t el_spatial_resampling_filter_flag;
uint8_t disable_residual_flag;
} AVDOVIRpuDataHeader;
enum AVDOVIMappingMethod {
AV_DOVI_MAPPING_POLYNOMIAL = 0,
AV_DOVI_MAPPING_MMR = 1,
};
/**
* Coefficients of a piece-wise function. The pieces of the function span the
* value ranges between two adjacent pivot values.
*/
#define AV_DOVI_MAX_PIECES 8
typedef struct AVDOVIReshapingCurve {
uint8_t num_pivots; /* [2, 9] */
uint16_t pivots[AV_DOVI_MAX_PIECES + 1]; /* sorted ascending */
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES];
/* AV_DOVI_MAPPING_POLYNOMIAL */
uint8_t poly_order[AV_DOVI_MAX_PIECES]; /* [1, 2] */
int64_t poly_coef[AV_DOVI_MAX_PIECES][3]; /* x^0, x^1, x^2 */
/* AV_DOVI_MAPPING_MMR */
uint8_t mmr_order[AV_DOVI_MAX_PIECES]; /* [1, 3] */
int64_t mmr_constant[AV_DOVI_MAX_PIECES];
int64_t mmr_coef[AV_DOVI_MAX_PIECES][3/* order - 1 */][7];
} AVDOVIReshapingCurve;
enum AVDOVINLQMethod {
AV_DOVI_NLQ_NONE = -1,
AV_DOVI_NLQ_LINEAR_DZ = 0,
};
/**
* Coefficients of the non-linear inverse quantization. For the interpretation
* of these, see ETSI GS CCM 001.
*/
typedef struct AVDOVINLQParams {
uint16_t nlq_offset;
uint64_t vdr_in_max;
/* AV_DOVI_NLQ_LINEAR_DZ */
uint64_t linear_deadzone_slope;
uint64_t linear_deadzone_threshold;
} AVDOVINLQParams;
/**
* Dolby Vision RPU data mapping parameters.
*
* @note sizeof(AVDOVIDataMapping) is not part of the public ABI.
*/
typedef struct AVDOVIDataMapping {
uint8_t vdr_rpu_id;
uint8_t mapping_color_space;
uint8_t mapping_chroma_format_idc;
AVDOVIReshapingCurve curves[3]; /* per component */
/* Non-linear inverse quantization */
enum AVDOVINLQMethod nlq_method_idc;
uint32_t num_x_partitions;
uint32_t num_y_partitions;
AVDOVINLQParams nlq[3]; /* per component */
} AVDOVIDataMapping;
/**
* Dolby Vision RPU colorspace metadata parameters.
*
* @note sizeof(AVDOVIColorMetadata) is not part of the public ABI.
*/
typedef struct AVDOVIColorMetadata {
uint8_t dm_metadata_id;
uint8_t scene_refresh_flag;
/**
* Coefficients of the custom Dolby Vision IPT-PQ matrices. These are to be
* used instead of the matrices indicated by the frame's colorspace tags.
* The output of rgb_to_lms_matrix is to be fed into a BT.2020 LMS->RGB
* matrix based on a Hunt-Pointer-Estevez transform, but without any
* crosstalk. (See the definition of the ICtCp colorspace for more
* information.)
*/
AVRational ycc_to_rgb_matrix[9]; /* before PQ linearization */
AVRational ycc_to_rgb_offset[3]; /* input offset of neutral value */
AVRational rgb_to_lms_matrix[9]; /* after PQ linearization */
/**
* Extra signal metadata (see Dolby patents for more info).
*/
uint16_t signal_eotf;
uint16_t signal_eotf_param0;
uint16_t signal_eotf_param1;
uint32_t signal_eotf_param2;
uint8_t signal_bit_depth;
uint8_t signal_color_space;
uint8_t signal_chroma_format;
uint8_t signal_full_range_flag; /* [0, 3] */
uint16_t source_min_pq;
uint16_t source_max_pq;
uint16_t source_diagonal;
} AVDOVIColorMetadata;
/**
* Combined struct representing a combination of header, mapping and color
* metadata, for attaching to frames as side data.
*
* @note The struct must be allocated with av_dovi_metadata_alloc() and
* its size is not a part of the public ABI.
*/
typedef struct AVDOVIMetadata {
/**
* Offset in bytes from the beginning of this structure at which the
* respective structs start.
*/
size_t header_offset; /* AVDOVIRpuDataHeader */
size_t mapping_offset; /* AVDOVIDataMapping */
size_t color_offset; /* AVDOVIColorMetadata */
} AVDOVIMetadata;
static av_always_inline AVDOVIRpuDataHeader *
av_dovi_get_header(const AVDOVIMetadata *data)
{
return (AVDOVIRpuDataHeader *)((uint8_t *) data + data->header_offset);
}
static av_always_inline AVDOVIDataMapping *
av_dovi_get_mapping(const AVDOVIMetadata *data)
{
return (AVDOVIDataMapping *)((uint8_t *) data + data->mapping_offset);
}
static av_always_inline AVDOVIColorMetadata *
av_dovi_get_color(const AVDOVIMetadata *data)
{
return (AVDOVIColorMetadata *)((uint8_t *) data + data->color_offset);
}
/**
* Allocate an AVDOVIMetadata structure and initialize its
* fields to default values.
*
* @param size If this parameter is non-NULL, the size in bytes of the
* allocated struct will be written here on success
*
* @return the newly allocated struct or NULL on failure
*/
AVDOVIMetadata *av_dovi_metadata_alloc(size_t *size);
#endif /* AVUTIL_DOVI_META_H */

2
ext_includes/ffmpeg/libavutil/error.h
View File

@ -27,6 +27,8 @@
#include <errno.h> #include <errno.h>
#include <stddef.h> #include <stddef.h>
#include "macros.h"
/** /**
* @addtogroup lavu_error * @addtogroup lavu_error
* *

26
ext_includes/ffmpeg/libavutil/eval.h
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;
/** /**
@ -86,6 +84,30 @@ int av_expr_parse(AVExpr **expr, const char *s,
*/ */
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque); 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
*
* @param counter a zero-initialized array where the count of each variable will be stored
* @param size size of array
* @return 0 on success, a negative value indicates that no expression or array was passed
* or size was zero
*/
int av_expr_count_vars(AVExpr *e, unsigned *counter, int size);
/**
* Track the presence of user provided functions and their number of occurrences
* in a parsed expression.
*
* @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()
* then for arg=2 this will use upto 5 entries.
* @param size size of array
* @param arg number of arguments the counted functions have
* @return 0 on success, a negative value indicates that no expression or array was passed
* or size was zero
*/
int av_expr_count_func(AVExpr *e, unsigned *counter, int size, int arg);
/** /**
* Free a parsed expression previously created with av_expr_parse(). * Free a parsed expression previously created with av_expr_parse().
*/ */

2
ext_includes/ffmpeg/libavutil/ffversion.h
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 "N-92936-ged3b64402e" #define FFMPEG_VERSION "n5.1.2"
#endif /* AVUTIL_FFVERSION_H */ #endif /* AVUTIL_FFVERSION_H */

253
ext_includes/ffmpeg/libavutil/fifo.h
View File

@ -24,10 +24,205 @@
#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"
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.
*/
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), nothing is written and an error
* is returned.
*
* @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 +233,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 +243,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 +277,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 +287,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 +300,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 +316,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 +331,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 +351,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 +366,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 +381,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 +408,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 +420,7 @@ 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 */

3
ext_includes/ffmpeg/libavutil/file.h
View File

@ -19,9 +19,10 @@
#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 "attributes.h"
/** /**
* @file * @file

260
ext_includes/ffmpeg/libavutil/film_grain_params.h Normal file
View File

@ -0,0 +1,260 @@
/*
* 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_FILM_GRAIN_PARAMS_H
#define AVUTIL_FILM_GRAIN_PARAMS_H
#include "frame.h"
enum AVFilmGrainParamsType {
AV_FILM_GRAIN_PARAMS_NONE = 0,
/**
* The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
*/
AV_FILM_GRAIN_PARAMS_AV1,
/**
* The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
*/
AV_FILM_GRAIN_PARAMS_H274,
};
/**
* This structure describes how to handle film grain synthesis for AOM codecs.
*
* @note The struct must be allocated as part of AVFilmGrainParams using
* av_film_grain_params_alloc(). Its size is not a part of the public ABI.
*/
typedef struct AVFilmGrainAOMParams {
/**
* Number of points, and the scale and value for each point of the
* piecewise linear scaling function for the uma plane.
*/
int num_y_points;
uint8_t y_points[14][2 /* value, scaling */];
/**
* Signals whether to derive the chroma scaling function from the luma.
* Not equivalent to copying the luma values and scales.
*/
int chroma_scaling_from_luma;
/**
* If chroma_scaling_from_luma is set to 0, signals the chroma scaling
* function parameters.
*/
int num_uv_points[2 /* cb, cr */];
uint8_t uv_points[2 /* cb, cr */][10][2 /* value, scaling */];
/**
* Specifies the shift applied to the chroma components. For AV1, its within
* [8; 11] and determines the range and quantization of the film grain.
*/
int scaling_shift;
/**
* Specifies the auto-regression lag.
*/
int ar_coeff_lag;
/**
* Luma auto-regression coefficients. The number of coefficients is given by
* 2 * ar_coeff_lag * (ar_coeff_lag + 1).
*/
int8_t ar_coeffs_y[24];
/**
* Chroma auto-regression coefficients. The number of coefficients is given by
* 2 * ar_coeff_lag * (ar_coeff_lag + 1) + !!num_y_points.
*/
int8_t ar_coeffs_uv[2 /* cb, cr */][25];
/**
* Specifies the range of the auto-regressive coefficients. Values of 6,
* 7, 8 and so on represent a range of [-2, 2), [-1, 1), [-0.5, 0.5) and
* so on. For AV1 must be between 6 and 9.
*/
int ar_coeff_shift;
/**
* Signals the down shift applied to the generated gaussian numbers during
* synthesis.
*/
int grain_scale_shift;
/**
* Specifies the luma/chroma multipliers for the index to the component
* scaling function.
*/
int uv_mult[2 /* cb, cr */];
int uv_mult_luma[2 /* cb, cr */];
/**
* Offset used for component scaling function. For AV1 its a 9-bit value
* with a range [-256, 255]
*/
int uv_offset[2 /* cb, cr */];
/**
* Signals whether to overlap film grain blocks.
*/
int overlap_flag;
/**
* Signals to clip to limited color levels after film grain application.
*/
int limit_output_range;
} AVFilmGrainAOMParams;
/**
* This structure describes how to handle film grain synthesis for codecs using
* the ITU-T H.274 Versatile suplemental enhancement information message.
*
* @note The struct must be allocated as part of AVFilmGrainParams using
* av_film_grain_params_alloc(). Its size is not a part of the public ABI.
*/
typedef struct AVFilmGrainH274Params {
/**
* Specifies the film grain simulation mode.
* 0 = Frequency filtering, 1 = Auto-regression
*/
int model_id;
/**
* Specifies the bit depth used for the luma component.
*/
int bit_depth_luma;
/**
* Specifies the bit depth used for the chroma components.
*/
int bit_depth_chroma;
enum AVColorRange color_range;
enum AVColorPrimaries color_primaries;
enum AVColorTransferCharacteristic color_trc;
enum AVColorSpace color_space;
/**
* Specifies the blending mode used to blend the simulated film grain
* with the decoded images.
*
* 0 = Additive, 1 = Multiplicative
*/
int blending_mode_id;
/**
* Specifies a scale factor used in the film grain characterization equations.
*/
int log2_scale_factor;
/**
* Indicates if the modelling of film grain for a given component is present.
*/
int component_model_present[3 /* y, cb, cr */];
/**
* Specifies the number of intensity intervals for which a specific set of
* model values has been estimated, with a range of [1, 256].
*/
uint16_t num_intensity_intervals[3 /* y, cb, cr */];
/**
* Specifies the number of model values present for each intensity interval
* in which the film grain has been modelled, with a range of [1, 6].
*/
uint8_t num_model_values[3 /* y, cb, cr */];
/**
* Specifies the lower ounds of each intensity interval for whichthe set of
* model values applies for the component.
*/
uint8_t intensity_interval_lower_bound[3 /* y, cb, cr */][256 /* intensity interval */];
/**
* Specifies the upper bound of each intensity interval for which the set of
* model values applies for the component.
*/
uint8_t intensity_interval_upper_bound[3 /* y, cb, cr */][256 /* intensity interval */];
/**
* Specifies the model values for the component for each intensity interval.
* - When model_id == 0, the following applies:
* For comp_model_value[y], the range of values is [0, 2^bit_depth_luma - 1]
* For comp_model_value[cb..cr], the range of values is [0, 2^bit_depth_chroma - 1]
* - Otherwise, the following applies:
* For comp_model_value[y], the range of values is [-2^(bit_depth_luma - 1), 2^(bit_depth_luma - 1) - 1]
* For comp_model_value[cb..cr], the range of values is [-2^(bit_depth_chroma - 1), 2^(bit_depth_chroma - 1) - 1]
*/
int16_t comp_model_value[3 /* y, cb, cr */][256 /* intensity interval */][6 /* model value */];
} AVFilmGrainH274Params;
/**
* This structure describes how to handle film grain synthesis in video
* for specific codecs. Must be present on every frame where film grain is
* meant to be synthesised for correct presentation.
*
* @note The struct must be allocated with av_film_grain_params_alloc() and
* its size is not a part of the public ABI.
*/
typedef struct AVFilmGrainParams {
/**
* Specifies the codec for which this structure is valid.
*/
enum AVFilmGrainParamsType type;
/**
* Seed to use for the synthesis process, if the codec allows for it.
*
* @note For H.264, this refers to `pic_offset` as defined in
* SMPTE RDD 5-2006.
*/
uint64_t seed;
/**
* Additional fields may be added both here and in any structure included.
* If a codec's film grain structure differs slightly over another
* codec's, fields within may change meaning depending on the type.
*/
union {
AVFilmGrainAOMParams aom;
AVFilmGrainH274Params h274;
} codec;
} AVFilmGrainParams;
/**
* Allocate an AVFilmGrainParams structure and set its fields to
* default values. The resulting struct can be freed using av_freep().
* If size is not NULL it will be set to the number of bytes allocated.
*
* @return An AVFilmGrainParams filled with default values or NULL
* on failure.
*/
AVFilmGrainParams *av_film_grain_params_alloc(size_t *size);
/**
* Allocate a complete AVFilmGrainParams and add it to the frame.
*
* @param frame The frame which side data is added to.
*
* @return The AVFilmGrainParams structure to be filled by caller.
*/
AVFilmGrainParams *av_film_grain_params_create_side_data(AVFrame *frame);
#endif /* AVUTIL_FILM_GRAIN_PARAMS_H */

290
ext_includes/ffmpeg/libavutil/frame.h
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"
@ -142,28 +143,11 @@ enum AVFrameSideDataType {
*/ */
AV_FRAME_DATA_ICC_PROFILE, AV_FRAME_DATA_ICC_PROFILE,
#if FF_API_FRAME_QP
/**
* Implementation-specific description of the format of AV_FRAME_QP_TABLE_DATA.
* The contents of this side data are undocumented and internal; use
* av_frame_set_qp_table() and av_frame_get_qp_table() to access this in a
* meaningful way instead.
*/
AV_FRAME_DATA_QP_TABLE_PROPERTIES,
/**
* Raw QP table data. Its format is described by
* AV_FRAME_DATA_QP_TABLE_PROPERTIES. Use av_frame_set_qp_table() and
* av_frame_get_qp_table() to access this instead.
*/
AV_FRAME_DATA_QP_TABLE_DATA,
#endif
/** /**
* Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t * Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t
* where the first uint32_t describes how many (1-3) of the other timecodes are used. * where the first uint32_t describes how many (1-3) of the other timecodes are used.
* The timecode format is described in the av_timecode_get_smpte_from_framenum() * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
* function in libavutil/timecode.c. * function in libavutil/timecode.h.
*/ */
AV_FRAME_DATA_S12M_TIMECODE, AV_FRAME_DATA_S12M_TIMECODE,
@ -173,6 +157,58 @@ enum AVFrameSideDataType {
* volume transform - application 4 of SMPTE 2094-40:2016 standard. * volume transform - application 4 of SMPTE 2094-40:2016 standard.
*/ */
AV_FRAME_DATA_DYNAMIC_HDR_PLUS, AV_FRAME_DATA_DYNAMIC_HDR_PLUS,
/**
* Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of
* array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size.
*/
AV_FRAME_DATA_REGIONS_OF_INTEREST,
/**
* Encoding parameters for a video frame, as described by AVVideoEncParams.
*/
AV_FRAME_DATA_VIDEO_ENC_PARAMS,
/**
* User data unregistered metadata associated with a video frame.
* This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose
* The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of
* uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte.
*/
AV_FRAME_DATA_SEI_UNREGISTERED,
/**
* Film grain parameters for a frame, described by AVFilmGrainParams.
* Must be present for every frame which should have film grain applied.
*/
AV_FRAME_DATA_FILM_GRAIN_PARAMS,
/**
* Bounding boxes for object detection and classification,
* as described by AVDetectionBBoxHeader.
*/
AV_FRAME_DATA_DETECTION_BBOXES,
/**
* Dolby Vision RPU raw data, suitable for passing to x265
* or other libraries. Array of uint8_t, with NAL emulation
* bytes intact.
*/
AV_FRAME_DATA_DOVI_RPU_BUFFER,
/**
* Parsed Dolby Vision metadata, suitable for passing to a software
* implementation. The payload is the AVDOVIMetadata struct defined in
* libavutil/dovi_meta.h.
*/
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,
}; };
enum AVActiveFormatDescription { enum AVActiveFormatDescription {
@ -195,11 +231,67 @@ enum AVActiveFormatDescription {
typedef struct AVFrameSideData { typedef struct AVFrameSideData {
enum AVFrameSideDataType type; enum AVFrameSideDataType type;
uint8_t *data; uint8_t *data;
int size; size_t size;
AVDictionary *metadata; AVDictionary *metadata;
AVBufferRef *buf; AVBufferRef *buf;
} AVFrameSideData; } AVFrameSideData;
/**
* Structure describing a single Region Of Interest.
*
* When multiple regions are defined in a single side-data block, they
* should be ordered from most to least important - some encoders are only
* capable of supporting a limited number of distinct regions, so will have
* to truncate the list.
*
* When overlapping regions are defined, the first region containing a given
* area of the frame applies.
*/
typedef struct AVRegionOfInterest {
/**
* Must be set to the size of this data structure (that is,
* sizeof(AVRegionOfInterest)).
*/
uint32_t self_size;
/**
* Distance in pixels from the top edge of the frame to the top and
* bottom edges and from the left edge of the frame to the left and
* right edges of the rectangle defining this region of interest.
*
* The constraints on a region are encoder dependent, so the region
* actually affected may be slightly larger for alignment or other
* reasons.
*/
int top;
int bottom;
int left;
int right;
/**
* Quantisation offset.
*
* Must be in the range -1 to +1. A value of zero indicates no quality
* change. A negative value asks for better quality (less quantisation),
* while a positive value asks for worse quality (greater quantisation).
*
* The range is calibrated so that the extreme values indicate the
* largest possible offset - if the rest of the frame is encoded with the
* worst possible quality, an offset of -1 indicates that this region
* should be encoded with the best possible quality anyway. Intermediate
* values are then interpolated in some codec-dependent way.
*
* For example, in 10-bit H.264 the quantisation parameter varies between
* -12 and 51. A typical qoffset value of -1/10 therefore indicates that
* this region should be encoded with a QP around one-tenth of the full
* range better than the rest of the frame. So, if most of the frame
* were to be encoded with a QP of around 30, this region would get a QP
* of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3).
* An extreme value of -1 would indicate that this region should be
* encoded with the best possible quality regardless of the treatment of
* the rest of the frame - that is, should be encoded at a QP of -12.
*/
AVRational qoffset;
} AVRegionOfInterest;
/** /**
* This structure describes decoded (raw) audio or video data. * This structure describes decoded (raw) audio or video data.
* *
@ -234,21 +326,32 @@ typedef struct AVFrame {
#define AV_NUM_DATA_POINTERS 8 #define AV_NUM_DATA_POINTERS 8
/** /**
* pointer to the picture/channel planes. * pointer to the picture/channel planes.
* This might be different from the first allocated byte * This might be different from the first allocated byte. For video,
* it could even point to the end of the image data.
*
* All pointers in data and extended_data must point into one of the
* AVBufferRef in buf or extended_buf.
* *
* Some decoders access areas outside 0,0 - width,height, please * Some decoders access areas outside 0,0 - width,height, please
* see avcodec_align_dimensions2(). Some filters and swscale can read * see avcodec_align_dimensions2(). Some filters and swscale can read
* up to 16 bytes beyond the planes, if these filters are to be used, * up to 16 bytes beyond the planes, if these filters are to be used,
* then 16 extra bytes must be allocated. * then 16 extra bytes must be allocated.
* *
* NOTE: Except for hwaccel formats, pointers not needed by the format * NOTE: Pointers not needed by the format MUST be set to NULL.
* MUST be set to NULL. *
* @attention In case of video, the data[] pointers can point to the
* end of image data in order to reverse line order, when used in
* combination with negative values in the linesize[] array.
*/ */
uint8_t *data[AV_NUM_DATA_POINTERS]; uint8_t *data[AV_NUM_DATA_POINTERS];
/** /**
* For video, size in bytes of each picture line. * For video, a positive or negative value, which is typically indicating
* For audio, size in bytes of each plane. * the size in bytes of each picture line, but it can also be:
* - the negative byte size of lines for vertical flipping
* (with data[n] pointing to the end of the data
* - a positive or negative multiple of the byte size as for accessing
* even and odd fields of a frame (possibly flipped)
* *
* For audio, only linesize[0] may be set. For planar audio, each channel * For audio, only linesize[0] may be set. For planar audio, each channel
* plane must be the same size. * plane must be the same size.
@ -260,6 +363,9 @@ typedef struct AVFrame {
* *
* @note The linesize may be larger than the size of usable data -- there * @note The linesize may be larger than the size of usable data -- there
* may be extra padding present for performance reasons. * may be extra padding present for performance reasons.
*
* @attention In case of video, line size values can be negative to achieve
* a vertically inverted iteration over image lines.
*/ */
int linesize[AV_NUM_DATA_POINTERS]; int linesize[AV_NUM_DATA_POINTERS];
@ -325,15 +431,6 @@ typedef struct AVFrame {
*/ */
int64_t pts; int64_t pts;
#if FF_API_PKT_PTS
/**
* PTS copied from the AVPacket that was decoded to produce this frame.
* @deprecated use the pts field instead
*/
attribute_deprecated
int64_t pkt_pts;
#endif
/** /**
* DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used) * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)
* This is also the Presentation time of this AVFrame calculated from * This is also the Presentation time of this AVFrame calculated from
@ -341,6 +438,14 @@ typedef struct AVFrame {
*/ */
int64_t pkt_dts; int64_t pkt_dts;
/**
* Time base for the timestamps in this frame.
* In the future, this field may be set on frames output by decoders or
* filters, but its value will be by default ignored on input to encoders
* or filters.
*/
AVRational time_base;
/** /**
* picture number in bitstream order * picture number in bitstream order
*/ */
@ -360,14 +465,6 @@ typedef struct AVFrame {
*/ */
void *opaque; void *opaque;
#if FF_API_ERROR_FRAME
/**
* @deprecated unused
*/
attribute_deprecated
uint64_t error[AV_NUM_DATA_POINTERS];
#endif
/** /**
* When decoding, this signals how much the picture must be delayed. * When decoding, this signals how much the picture must be delayed.
* extra_delay = repeat_pict / (2*fps) * extra_delay = repeat_pict / (2*fps)
@ -404,16 +501,20 @@ typedef struct AVFrame {
*/ */
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. If all elements of * AVBuffer references backing the data for this frame. All the pointers in
* this array are NULL, then this frame is not reference counted. This array * data and extended_data must point inside one of the buffers in buf or
* must be filled contiguously -- if buf[i] is non-NULL then buf[j] must * extended_buf. This array must be filled contiguously -- if buf[i] is
* also be non-NULL for all j < i. * non-NULL then buf[j] must also be non-NULL for all j < i.
* *
* There may be at most one AVBuffer per data plane, so for video this array * There may be at most one AVBuffer per data plane, so for video this array
* always contains all the references. For planar audio with more than * always contains all the references. For planar audio with more than
@ -528,13 +629,19 @@ typedef struct AVFrame {
int decode_error_flags; int decode_error_flags;
#define FF_DECODE_ERROR_INVALID_BITSTREAM 1 #define FF_DECODE_ERROR_INVALID_BITSTREAM 1
#define FF_DECODE_ERROR_MISSING_REFERENCE 2 #define FF_DECODE_ERROR_MISSING_REFERENCE 2
#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4
#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
@ -545,24 +652,6 @@ typedef struct AVFrame {
*/ */
int pkt_size; int pkt_size;
#if FF_API_FRAME_QP
/**
* QP table
*/
attribute_deprecated
int8_t *qscale_table;
/**
* QP store stride
*/
attribute_deprecated
int qstride;
attribute_deprecated
int qscale_type;
attribute_deprecated
AVBufferRef *qp_table_buf;
#endif
/** /**
* For hwaccel-format frames, this should be a reference to the * For hwaccel-format frames, this should be a reference to the
* AVHWFramesContext describing the frame. * AVHWFramesContext describing the frame.
@ -608,71 +697,23 @@ 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;
} AVFrame; } AVFrame;
#if FF_API_FRAME_GET_SET
/**
* Accessors for some AVFrame fields. These used to be provided for ABI
* compatibility, and do not need to be used anymore.
*/
attribute_deprecated
int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
attribute_deprecated
void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
attribute_deprecated
int64_t av_frame_get_pkt_duration (const AVFrame *frame);
attribute_deprecated
void av_frame_set_pkt_duration (AVFrame *frame, int64_t val);
attribute_deprecated
int64_t av_frame_get_pkt_pos (const AVFrame *frame);
attribute_deprecated
void av_frame_set_pkt_pos (AVFrame *frame, int64_t val);
attribute_deprecated
int64_t av_frame_get_channel_layout (const AVFrame *frame);
attribute_deprecated
void av_frame_set_channel_layout (AVFrame *frame, int64_t val);
attribute_deprecated
int av_frame_get_channels (const AVFrame *frame);
attribute_deprecated
void av_frame_set_channels (AVFrame *frame, int val);
attribute_deprecated
int av_frame_get_sample_rate (const AVFrame *frame);
attribute_deprecated
void av_frame_set_sample_rate (AVFrame *frame, int val);
attribute_deprecated
AVDictionary *av_frame_get_metadata (const AVFrame *frame);
attribute_deprecated
void av_frame_set_metadata (AVFrame *frame, AVDictionary *val);
attribute_deprecated
int av_frame_get_decode_error_flags (const AVFrame *frame);
attribute_deprecated
void av_frame_set_decode_error_flags (AVFrame *frame, int val);
attribute_deprecated
int av_frame_get_pkt_size(const AVFrame *frame);
attribute_deprecated
void av_frame_set_pkt_size(AVFrame *frame, int val);
#if FF_API_FRAME_QP
attribute_deprecated
int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
attribute_deprecated
int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
#endif
attribute_deprecated
enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
attribute_deprecated
void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
attribute_deprecated
enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
attribute_deprecated
void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
#endif
#if FF_API_COLORSPACE_NAME
/** /**
* Get the name of a colorspace. * Get the name of a colorspace.
* @return a static string identifying the colorspace; can be NULL. * @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); 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().
@ -740,7 +781,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.
@ -830,7 +871,7 @@ AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane);
*/ */
AVFrameSideData *av_frame_new_side_data(AVFrame *frame, AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
enum AVFrameSideDataType type, enum AVFrameSideDataType type,
int size); size_t size);
/** /**
* Add a new side data to a frame from an existing AVBufferRef * Add a new side data to a frame from an existing AVBufferRef
@ -856,8 +897,7 @@ AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
enum AVFrameSideDataType type); enum AVFrameSideDataType type);
/** /**
* If side data of the supplied type exists in the frame, free it and remove it * Remove and free all side data instances of the given type.
* from the frame.
*/ */
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type); void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);

7
ext_includes/ffmpeg/libavutil/hash.h
View File

@ -27,10 +27,9 @@
#ifndef AVUTIL_HASH_H #ifndef AVUTIL_HASH_H
#define AVUTIL_HASH_H #define AVUTIL_HASH_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "version.h"
/** /**
* @defgroup lavu_hash Hash Functions * @defgroup lavu_hash Hash Functions
* @ingroup lavu_crypto * @ingroup lavu_crypto
@ -181,11 +180,7 @@ void av_hash_init(struct AVHashContext *ctx);
* @param[in] src Data to be added to the hash context * @param[in] src Data to be added to the hash context
* @param[in] len Size of the additional data * @param[in] len Size of the additional data
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, int len);
#else
void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, size_t len); void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, size_t len);
#endif
/** /**
* Finalize a hash context and compute the actual hash value. * Finalize a hash context and compute the actual hash value.

285
ext_includes/ffmpeg/libavutil/hdr_dynamic_vivid_metadata.h 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 */

1
ext_includes/ffmpeg/libavutil/hmac.h
View File

@ -23,7 +23,6 @@
#include <stdint.h> #include <stdint.h>
#include "version.h"
/** /**
* @defgroup lavu_hmac HMAC * @defgroup lavu_hmac HMAC
* @ingroup lavu_crypto * @ingroup lavu_crypto

25
ext_includes/ffmpeg/libavutil/hwcontext.h
View File

@ -36,6 +36,7 @@ enum AVHWDeviceType {
AV_HWDEVICE_TYPE_DRM, AV_HWDEVICE_TYPE_DRM,
AV_HWDEVICE_TYPE_OPENCL, AV_HWDEVICE_TYPE_OPENCL,
AV_HWDEVICE_TYPE_MEDIACODEC, AV_HWDEVICE_TYPE_MEDIACODEC,
AV_HWDEVICE_TYPE_VULKAN,
}; };
typedef struct AVHWDeviceInternal AVHWDeviceInternal; typedef struct AVHWDeviceInternal AVHWDeviceInternal;
@ -327,6 +328,26 @@ int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx,
enum AVHWDeviceType type, enum AVHWDeviceType type,
AVBufferRef *src_ctx, int flags); AVBufferRef *src_ctx, int flags);
/**
* Create a new device of the specified type from an existing device.
*
* This function performs the same action as av_hwdevice_ctx_create_derived,
* however, it is able to set options for the new device to be derived.
*
* @param dst_ctx On success, a reference to the newly-created
* AVHWDeviceContext.
* @param type The type of the new device to create.
* @param src_ctx A reference to an existing AVHWDeviceContext which will be
* used to create the new device.
* @param options Options for the new device to create, same format as in
* av_hwdevice_ctx_create.
* @param flags Currently unused; should be set to zero.
* @return Zero on success, a negative AVERROR code on failure.
*/
int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ctx,
enum AVHWDeviceType type,
AVBufferRef *src_ctx,
AVDictionary *options, int flags);
/** /**
* Allocate an AVHWFramesContext tied to a given device context. * Allocate an AVHWFramesContext tied to a given device context.
@ -550,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.

17
ext_includes/ffmpeg/libavutil/hwcontext_cuda.h
View File

@ -49,4 +49,21 @@ typedef struct AVCUDADeviceContext {
* AVHWFramesContext.hwctx is currently not used * AVHWFramesContext.hwctx is currently not used
*/ */
/**
* @defgroup hwcontext_cuda Device context creation flags
*
* Flags for av_hwdevice_ctx_create.
*
* @{
*/
/**
* Use primary device context instead of creating a new one.
*/
#define AV_CUDA_USE_PRIMARY_CONTEXT (1 << 0)
/**
* @}
*/
#endif /* AVUTIL_HWCONTEXT_CUDA_H */ #endif /* AVUTIL_HWCONTEXT_CUDA_H */

9
ext_includes/ffmpeg/libavutil/hwcontext_d3d11va.h
View File

@ -164,6 +164,15 @@ typedef struct AVD3D11VAFramesContext {
* This field is ignored/invalid if a user-allocated texture is provided. * This field is ignored/invalid if a user-allocated texture is provided.
*/ */
UINT MiscFlags; UINT MiscFlags;
/**
* In case if texture structure member above is not NULL contains the same texture
* pointer for all elements and different indexes into the array texture.
* In case if texture structure member above is NULL, all elements contains
* pointers to separate non-array textures and 0 indexes.
* This field is ignored/invalid if a user-allocated texture is provided.
*/
AVD3D11FrameDescriptor *texture_infos;
} AVD3D11VAFramesContext; } AVD3D11VAFramesContext;
#endif /* AVUTIL_HWCONTEXT_D3D11VA_H */ #endif /* AVUTIL_HWCONTEXT_D3D11VA_H */

100
ext_includes/ffmpeg/libavutil/hwcontext_opencl.h Normal file
View File

@ -0,0 +1,100 @@
/*
* 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_HWCONTEXT_OPENCL_H
#define AVUTIL_HWCONTEXT_OPENCL_H
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
#include "frame.h"
/**
* @file
* API-specific header for AV_HWDEVICE_TYPE_OPENCL.
*
* Pools allocated internally are always dynamic, and are primarily intended
* to be used in OpenCL-only cases. If interoperation is required, it is
* typically required to allocate frames in the other API and then map the
* frames context to OpenCL with av_hwframe_ctx_create_derived().
*/
/**
* OpenCL frame descriptor for pool allocation.
*
* In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
* with the data pointer pointing at an object of this type describing the
* planes of the frame.
*/
typedef struct AVOpenCLFrameDescriptor {
/**
* Number of planes in the frame.
*/
int nb_planes;
/**
* OpenCL image2d objects for each plane of the frame.
*/
cl_mem planes[AV_NUM_DATA_POINTERS];
} AVOpenCLFrameDescriptor;
/**
* OpenCL device details.
*
* Allocated as AVHWDeviceContext.hwctx
*/
typedef struct AVOpenCLDeviceContext {
/**
* The primary device ID of the device. If multiple OpenCL devices
* are associated with the context then this is the one which will
* be used for all operations internal to FFmpeg.
*/
cl_device_id device_id;
/**
* The OpenCL context which will contain all operations and frames on
* this device.
*/
cl_context context;
/**
* The default command queue for this device, which will be used by all
* frames contexts which do not have their own command queue. If not
* intialised by the user, a default queue will be created on the
* primary device.
*/
cl_command_queue command_queue;
} AVOpenCLDeviceContext;
/**
* OpenCL-specific data associated with a frame pool.
*
* Allocated as AVHWFramesContext.hwctx.
*/
typedef struct AVOpenCLFramesContext {
/**
* The command queue used for internal asynchronous operations on this
* device (av_hwframe_transfer_data(), av_hwframe_map()).
*
* If this is not set, the command queue from the associated device is
* used instead.
*/
cl_command_queue command_queue;
} AVOpenCLFramesContext;
#endif /* AVUTIL_HWCONTEXT_OPENCL_H */

45
ext_includes/ffmpeg/libavutil/hwcontext_videotoolbox.h
View File

@ -29,11 +29,14 @@
* @file * @file
* An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX. * An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
* *
* This API currently does not support frame allocation, as the raw VideoToolbox * This API supports frame allocation using a native CVPixelBufferPool
* API does allocation, and FFmpeg itself never has the need to allocate frames. * instead of an AVBufferPool.
* *
* If the API user sets a custom pool, AVHWFramesContext.pool must return * If the API user sets a custom pool, AVHWFramesContext.pool must return
* AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef. * AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef.
* Note that the underlying CVPixelBuffer could be retained by OS frameworks
* depending on application usage, so it is preferable to let CoreVideo manage
* the pool using the default implementation.
* *
* Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always * Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always
* NULL. * NULL.
@ -51,4 +54,42 @@ enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt);
*/ */
uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt); uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt);
/**
* Same as av_map_videotoolbox_format_from_pixfmt function, but can map and
* return full range pixel formats via a flag.
*/
uint32_t av_map_videotoolbox_format_from_pixfmt2(enum AVPixelFormat pix_fmt, bool full_range);
/**
* Convert an AVChromaLocation to a VideoToolbox/CoreVideo chroma location string.
* Returns 0 if no known equivalent was found.
*/
CFStringRef av_map_videotoolbox_chroma_loc_from_av(enum AVChromaLocation loc);
/**
* Convert an AVColorSpace to a VideoToolbox/CoreVideo color matrix string.
* Returns 0 if no known equivalent was found.
*/
CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space);
/**
* Convert an AVColorPrimaries to a VideoToolbox/CoreVideo color primaries string.
* Returns 0 if no known equivalent was found.
*/
CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri);
/**
* Convert an AVColorTransferCharacteristic to a VideoToolbox/CoreVideo color transfer
* function string.
* Returns 0 if no known equivalent was found.
*/
CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc);
/**
* Update a CVPixelBufferRef's metadata to based on an AVFrame.
* Returns 0 if no known equivalent was found.
*/
int av_vt_pixbuf_set_attachments(void *log_ctx,
CVPixelBufferRef pixbuf, const struct AVFrame *src);
#endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */ #endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */

281
ext_includes/ffmpeg/libavutil/hwcontext_vulkan.h Normal file
View File

@ -0,0 +1,281 @@
/*
* 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_HWCONTEXT_VULKAN_H
#define AVUTIL_HWCONTEXT_VULKAN_H
#if defined(_WIN32) && !defined(VK_USE_PLATFORM_WIN32_KHR)
#define VK_USE_PLATFORM_WIN32_KHR
#endif
#include <vulkan/vulkan.h>
#include "pixfmt.h"
#include "frame.h"
/**
* @file
* API-specific header for AV_HWDEVICE_TYPE_VULKAN.
*
* For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
* with the data pointer set to an AVVkFrame.
*/
/**
* Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
* All of these can be set before init to change what the context uses
*/
typedef struct AVVulkanDeviceContext {
/**
* Custom memory allocator, else NULL
*/
const VkAllocationCallbacks *alloc;
/**
* Pointer to the instance-provided vkGetInstanceProcAddr loading function.
* If NULL, will pick either libvulkan or libvolk, depending on libavutil's
* compilation settings, and set this field.
*/
PFN_vkGetInstanceProcAddr get_proc_addr;
/**
* Vulkan instance. Must be at least version 1.2.
*/
VkInstance inst;
/**
* Physical device
*/
VkPhysicalDevice phys_dev;
/**
* Active device
*/
VkDevice act_dev;
/**
* This structure should be set to the set of features that present and enabled
* during device creation. When a device is created by FFmpeg, it will default to
* enabling all that are present of the shaderImageGatherExtended,
* fragmentStoresAndAtomics, shaderInt64 and vertexPipelineStoresAndAtomics features.
*/
VkPhysicalDeviceFeatures2 device_features;
/**
* Enabled instance extensions.
* If supplying your own device context, set this to an array of strings, with
* each entry containing the specified Vulkan extension string to enable.
* Duplicates are possible and accepted.
* If no extensions are enabled, set these fields to NULL, and 0 respectively.
*/
const char * const *enabled_inst_extensions;
int nb_enabled_inst_extensions;
/**
* Enabled device extensions. By default, VK_KHR_external_memory_fd,
* VK_EXT_external_memory_dma_buf, VK_EXT_image_drm_format_modifier,
* VK_KHR_external_semaphore_fd and VK_EXT_external_memory_host are enabled if found.
* If supplying your own device context, these fields takes the same format as
* the above fields, with the same conditions that duplicates are possible
* and accepted, and that NULL and 0 respectively means no extensions are enabled.
*/
const char * const *enabled_dev_extensions;
int nb_enabled_dev_extensions;
/**
* Queue family index for graphics operations, and the number of queues
* enabled for it. If unavaiable, will be set to -1. Not required.
* av_hwdevice_create() will attempt to find a dedicated queue for each
* queue family, or pick the one with the least unrelated flags set.
* Queue indices here may overlap if a queue has to share capabilities.
*/
int queue_family_index;
int nb_graphics_queues;
/**
* Queue family index for transfer operations and the number of queues
* enabled. Required.
*/
int queue_family_tx_index;
int nb_tx_queues;
/**
* Queue family index for compute operations and the number of queues
* enabled. Required.
*/
int queue_family_comp_index;
int nb_comp_queues;
/**
* Queue family index for video encode ops, and the amount of queues enabled.
* If the device doesn't support such, queue_family_encode_index will be -1.
* Not required.
*/
int queue_family_encode_index;
int nb_encode_queues;
/**
* Queue family index for video decode ops, and the amount of queues enabled.
* If the device doesn't support such, queue_family_decode_index will be -1.
* Not required.
*/
int queue_family_decode_index;
int nb_decode_queues;
} AVVulkanDeviceContext;
/**
* Defines the behaviour of frame allocation.
*/
typedef enum AVVkFrameFlags {
/* Unless this flag is set, autodetected flags will be OR'd based on the
* device and tiling during av_hwframe_ctx_init(). */
AV_VK_FRAME_FLAG_NONE = (1ULL << 0),
/* Image planes will be allocated in a single VkDeviceMemory, rather
* than as per-plane VkDeviceMemory allocations. Required for exporting
* to VAAPI on Intel devices. */
AV_VK_FRAME_FLAG_CONTIGUOUS_MEMORY = (1ULL << 1),
} AVVkFrameFlags;
/**
* Allocated as AVHWFramesContext.hwctx, used to set pool-specific options
*/
typedef struct AVVulkanFramesContext {
/**
* Controls the tiling of allocated frames. If left as optimal tiling,
* then during av_hwframe_ctx_init() will decide based on whether the device
* supports DRM modifiers, or if the linear_images flag is set, otherwise
* will allocate optimally-tiled images.
*/
VkImageTiling tiling;
/**
* Defines extra usage of output frames. If left as 0, the following bits
* are set: TRANSFER_SRC, TRANSFER_DST. SAMPLED and STORAGE.
*/
VkImageUsageFlagBits usage;
/**
* Extension data for image creation.
* If VkImageDrmFormatModifierListCreateInfoEXT is present in the chain,
* and the device supports DRM modifiers, then images will be allocated
* with the specific requested DRM modifiers.
* Additional structures may be added at av_hwframe_ctx_init() time,
* which will be freed automatically on uninit(), so users need only free
* any structures they've allocated themselves.
*/
void *create_pnext;
/**
* Extension data for memory allocation. Must have as many entries as
* the number of planes of the sw_format.
* This will be chained to VkExportMemoryAllocateInfo, which is used
* to make all pool images exportable to other APIs if the necessary
* extensions are present in enabled_dev_extensions.
*/
void *alloc_pnext[AV_NUM_DATA_POINTERS];
/**
* A combination of AVVkFrameFlags. Unless AV_VK_FRAME_FLAG_NONE is set,
* autodetected flags will be OR'd based on the device and tiling during
* av_hwframe_ctx_init().
*/
AVVkFrameFlags flags;
} AVVulkanFramesContext;
/*
* Frame structure, the VkFormat of the image will always match
* the pool's sw_format.
* All frames, imported or allocated, will be created with the
* VK_IMAGE_CREATE_ALIAS_BIT flag set, so the memory may be aliased if needed.
*
* If all queue family indices in the device context are the same,
* images will be created with the EXCLUSIVE sharing mode. Otherwise, all images
* will be created using the CONCURRENT sharing mode.
*
* @note the size of this structure is not part of the ABI, to allocate
* you must use @av_vk_frame_alloc().
*/
typedef struct AVVkFrame {
/**
* Vulkan images to which the memory is bound to.
*/
VkImage img[AV_NUM_DATA_POINTERS];
/**
* The same tiling must be used for all images in the frame.
*/
VkImageTiling tiling;
/**
* Memory backing the images. Could be less than the amount of planes,
* in which case the offset value will indicate the binding offset of
* each plane in the memory.
*/
VkDeviceMemory mem[AV_NUM_DATA_POINTERS];
size_t size[AV_NUM_DATA_POINTERS];
/**
* OR'd flags for all memory allocated
*/
VkMemoryPropertyFlagBits flags;
/**
* Updated after every barrier
*/
VkAccessFlagBits access[AV_NUM_DATA_POINTERS];
VkImageLayout layout[AV_NUM_DATA_POINTERS];
/**
* Synchronization timeline semaphores, one for each sw_format plane.
* Must not be freed manually. Must be waited on at every submission using
* the value in sem_value, and must be signalled at every submission,
* using an incremented value.
*/
VkSemaphore sem[AV_NUM_DATA_POINTERS];
/**
* Up to date semaphore value at which each image becomes accessible.
* Clients must wait on this value when submitting a command queue,
* and increment it when signalling.
*/
uint64_t sem_value[AV_NUM_DATA_POINTERS];
/**
* Internal data.
*/
struct AVVkFrameInternal *internal;
/**
* Describes the binding offset of each plane to the VkDeviceMemory.
*/
ptrdiff_t offset[AV_NUM_DATA_POINTERS];
} AVVkFrame;
/**
* Allocates a single AVVkFrame and initializes everything as 0.
* @note Must be freed via av_free()
*/
AVVkFrame *av_vk_frame_alloc(void);
/**
* Returns the format of each image up to the number of planes for a given sw_format.
* Returns NULL on unsupported formats.
*/
const VkFormat *av_vkfmt_from_pixfmt(enum AVPixelFormat p);
#endif /* AVUTIL_HWCONTEXT_VULKAN_H */

36
ext_includes/ffmpeg/libavutil/imgutils.h
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"
/** /**
@ -67,6 +69,20 @@ int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane);
*/ */
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);
/**
* 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 linesizes the array containing the linesize for each
* plane, should be filled by av_image_fill_linesizes()
* @return >= 0 in case of success, a negative error code otherwise
*
* @note The linesize parameters have the type ptrdiff_t here, while they are
* int for av_image_fill_linesizes().
*/
int av_image_fill_plane_sizes(size_t size[4], enum AVPixelFormat pix_fmt,
int height, const ptrdiff_t linesizes[4]);
/** /**
* Fill plane data pointers for an image with pixel format pix_fmt and * Fill plane data pointers for an image with pixel format pix_fmt and
* height height. * height height.
@ -110,6 +126,24 @@ 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,
int bytewidth, int height); int bytewidth, int height);
/**
* Copy image data located in uncacheable (e.g. GPU mapped) memory. Where
* available, this function will use special functionality for reading from such
* memory, which may result in greatly improved performance compared to plain
* av_image_copy_plane().
*
* bytewidth must be contained by both absolute values of dst_linesize
* and src_linesize, otherwise the function behavior is undefined.
*
* @note The linesize parameters have the type ptrdiff_t here, while they are
* int for av_image_copy_plane().
* @note On x86, the linesizes currently need to be aligned to the cacheline
* size (i.e. 64) to get improved performance.
*/
void av_image_copy_plane_uc_from(uint8_t *dst, ptrdiff_t dst_linesize,
const uint8_t *src, ptrdiff_t src_linesize,
ptrdiff_t bytewidth, int height);
/** /**
* Copy image in src_data to dst_data. * Copy image in src_data to dst_data.
* *

15
ext_includes/ffmpeg/libavutil/intreadwrite.h
View File

@ -542,6 +542,21 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
# define AV_WN64A(p, v) AV_WNA(64, p, v) # define AV_WN64A(p, v) AV_WNA(64, p, v)
#endif #endif
#if AV_HAVE_BIGENDIAN
# define AV_RLA(s, p) av_bswap##s(AV_RN##s##A(p))
# define AV_WLA(s, p, v) AV_WN##s##A(p, av_bswap##s(v))
#else
# define AV_RLA(s, p) AV_RN##s##A(p)
# define AV_WLA(s, p, v) AV_WN##s##A(p, v)
#endif
#ifndef AV_RL64A
# define AV_RL64A(p) AV_RLA(64, p)
#endif
#ifndef AV_WL64A
# define AV_WL64A(p, v) AV_WLA(64, p, v)
#endif
/* /*
* The AV_COPYxxU macros are suitable for copying data to/from unaligned * The AV_COPYxxU macros are suitable for copying data to/from unaligned
* memory locations. * memory locations.

15
ext_includes/ffmpeg/libavutil/lfg.h
View File

@ -24,6 +24,12 @@
#include <stdint.h> #include <stdint.h>
/**
* Context structure for the Lagged Fibonacci PRNG.
* 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
* to allow easy instanciation.
*/
typedef struct AVLFG { typedef struct AVLFG {
unsigned int state[64]; unsigned int state[64];
int index; int index;
@ -45,8 +51,9 @@ int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length);
* it may be good enough and faster for your specific use case. * it may be good enough and faster for your specific use case.
*/ */
static inline unsigned int av_lfg_get(AVLFG *c){ static inline unsigned int av_lfg_get(AVLFG *c){
c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 63]; unsigned a = c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 63];
return c->state[c->index++ & 63]; c->index += 1U;
return a;
} }
/** /**
@ -57,7 +64,9 @@ static inline unsigned int av_lfg_get(AVLFG *c){
static inline unsigned int av_mlfg_get(AVLFG *c){ static inline unsigned int av_mlfg_get(AVLFG *c){
unsigned int a= c->state[(c->index-55) & 63]; unsigned int a= c->state[(c->index-55) & 63];
unsigned int b= c->state[(c->index-24) & 63]; unsigned int b= c->state[(c->index-24) & 63];
return c->state[c->index++ & 63] = 2*a*b+a+b; a = c->state[c->index & 63] = 2*a*b+a+b;
c->index += 1U;
return a;
} }
/** /**

57
ext_includes/ffmpeg/libavutil/log.h
View File

@ -22,7 +22,6 @@
#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" #include "version.h"
@ -107,21 +106,6 @@ typedef struct AVClass {
*/ */
int parent_log_context_offset; int parent_log_context_offset;
/**
* Return next AVOptions-enabled child or NULL
*/
void* (*child_next)(void *obj, void *prev);
/**
* Return an AVClass corresponding to the next potential
* AVOptions-enabled child.
*
* The difference between child_next and this is that
* child_next iterates over _already existing_ objects, while
* child_class_next iterates over _all possible_ children.
*/
const struct AVClass* (*child_class_next)(const struct AVClass *prev);
/** /**
* Category used for visualization (like color) * Category used for visualization (like color)
* This is only set if the category is equal for all objects using this class. * This is only set if the category is equal for all objects using this class.
@ -140,6 +124,26 @@ typedef struct AVClass {
* available since version (52.12) * available since version (52.12)
*/ */
int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags); int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
/**
* Return next AVOptions-enabled child or NULL
*/
void* (*child_next)(void *obj, void *prev);
/**
* Iterate over the AVClasses corresponding to potential AVOptions-enabled
* children.
*
* @param iter pointer to opaque iteration state. The caller must initialize
* *iter to NULL before the first call.
* @return AVClass for the next AVOptions-enabled child or NULL if there are
* no more such children.
*
* @note The difference between child_next and this is that child_next
* iterates over _already existing_ objects, while child_class_iterate
* iterates over _all possible_ children.
*/
const struct AVClass* (*child_class_iterate)(void **iter);
} AVClass; } AVClass;
/** /**
@ -233,6 +237,27 @@ typedef struct AVClass {
*/ */
void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4); void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
/**
* Send the specified message to the log once with the initial_level and then with
* the subsequent_level. By default, all logging messages are sent to
* stderr. This behavior can be altered by setting a different logging callback
* function.
* @see av_log
*
* @param avcl A pointer to an arbitrary struct of which the first field is a
* pointer to an AVClass struct or NULL if general log.
* @param initial_level importance level of the message expressed using a @ref
* lavu_log_constants "Logging Constant" for the first occurance.
* @param subsequent_level importance level of the message expressed using a @ref
* lavu_log_constants "Logging Constant" after the first occurance.
* @param fmt The format string (printf-compatible) that specifies how
* subsequent arguments are converted to output.
* @param state a variable to keep trak of if a message has already been printed
* this must be initialized to 0 before the first use. The same state
* must not be accessed by 2 Threads simultaneously.
*/
void av_log_once(void* avcl, int initial_level, int subsequent_level, int *state, const char *fmt, ...) av_printf_format(5, 6);
/** /**
* Send the specified message to the log if the level is less than or equal * Send the specified message to the log if the level is less than or equal

66
ext_includes/ffmpeg/libavutil/lzo.h Normal file
View File

@ -0,0 +1,66 @@
/*
* LZO 1x decompression
* copyright (c) 2006 Reimar Doeffinger
*
* 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_LZO_H
#define AVUTIL_LZO_H
/**
* @defgroup lavu_lzo LZO
* @ingroup lavu_crypto
*
* @{
*/
#include <stdint.h>
/** @name Error flags returned by av_lzo1x_decode
* @{ */
/// end of the input buffer reached before decoding finished
#define AV_LZO_INPUT_DEPLETED 1
/// decoded data did not fit into output buffer
#define AV_LZO_OUTPUT_FULL 2
/// a reference to previously decoded data was wrong
#define AV_LZO_INVALID_BACKPTR 4
/// a non-specific error in the compressed bitstream
#define AV_LZO_ERROR 8
/** @} */
#define AV_LZO_INPUT_PADDING 8
#define AV_LZO_OUTPUT_PADDING 12
/**
* @brief Decodes LZO 1x compressed data.
* @param out output buffer
* @param outlen size of output buffer, number of bytes left are returned here
* @param in input buffer
* @param inlen size of input buffer, number of bytes left are returned here
* @return 0 on success, otherwise a combination of the error flags above
*
* Make sure all buffers are appropriately padded, in must provide
* AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes.
*/
int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen);
/**
* @}
*/
#endif /* AVUTIL_LZO_H */

30
ext_includes/ffmpeg/libavutil/macros.h
View File

@ -25,6 +25,36 @@
#ifndef AVUTIL_MACROS_H #ifndef AVUTIL_MACROS_H
#define AVUTIL_MACROS_H #define AVUTIL_MACROS_H
#include "libavutil/avconfig.h"
#if AV_HAVE_BIGENDIAN
# define AV_NE(be, le) (be)
#else
# define AV_NE(be, le) (le)
#endif
/**
* Comparator.
* For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
* if x == y. This is useful for instance in a qsort comparator callback.
* Furthermore, compilers are able to optimize this to branchless code, and
* there is no risk of overflow with signed types.
* As with many macros, this evaluates its argument multiple times, it thus
* must not have a side-effect.
*/
#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
/** /**
* @addtogroup preproc_misc Preprocessor String Macros * @addtogroup preproc_misc Preprocessor String Macros
* *

1
ext_includes/ffmpeg/libavutil/mathematics.h
View File

@ -134,6 +134,7 @@ int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
* *
* The operation is mathematically equivalent to `a * b / c`, but writing that * The operation is mathematically equivalent to `a * b / c`, but writing that
* directly can overflow, and does not support different rounding methods. * directly can overflow, and does not support different rounding methods.
* If the result is not representable then INT64_MIN is returned.
* *
* @see av_rescale(), av_rescale_q(), av_rescale_q_rnd() * @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()
*/ */

9
ext_includes/ffmpeg/libavutil/md5.h
View File

@ -31,7 +31,6 @@
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @defgroup lavu_md5 MD5 * @defgroup lavu_md5 MD5
@ -64,11 +63,7 @@ void av_md5_init(struct AVMD5 *ctx);
* @param src input data to update hash with * @param src input data to update hash with
* @param len input data length * @param len input data length
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len);
#else
void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, size_t len); void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, size_t len);
#endif
/** /**
* Finish hashing and output digest value. * Finish hashing and output digest value.
@ -85,11 +80,7 @@ void av_md5_final(struct AVMD5 *ctx, uint8_t *dst);
* @param src The data to hash * @param src The data to hash
* @param len The length of the data, in bytes * @param len The length of the data, in bytes
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len);
#else
void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len); void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len);
#endif
/** /**
* @} * @}

52
ext_includes/ffmpeg/libavutil/mem.h
View File

@ -31,8 +31,8 @@
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "error.h"
#include "avutil.h" #include "avutil.h"
#include "version.h"
/** /**
* @addtogroup lavu_mem * @addtogroup lavu_mem
@ -49,6 +49,10 @@
* dealing with memory consistently possible on all platforms. * dealing with memory consistently possible on all platforms.
* *
* @{ * @{
*/
#if FF_API_DECLARE_ALIGNED
/**
* *
* @defgroup lavu_mem_macros Alignment Macros * @defgroup lavu_mem_macros Alignment Macros
* Helper macros for declaring aligned variables. * Helper macros for declaring aligned variables.
@ -125,6 +129,7 @@
/** /**
* @} * @}
*/ */
#endif
/** /**
* @defgroup lavu_mem_attrs Function Attributes * @defgroup lavu_mem_attrs Function Attributes
@ -232,20 +237,20 @@ av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
* @see av_mallocz() * @see av_mallocz()
* @see av_malloc_array() * @see av_malloc_array()
*/ */
av_alloc_size(1, 2) void *av_mallocz_array(size_t nmemb, size_t size); void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
#if FF_API_AV_MALLOCZ_ARRAY
/** /**
* Non-inlined equivalent of av_mallocz_array(). * @deprecated use av_calloc()
*
* Created for symmetry with the calloc() C function.
*/ */
void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib; 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
@ -254,10 +259,11 @@ void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
* 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()
*/ */
@ -305,8 +311,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`
@ -314,19 +319,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`.
@ -337,7 +342,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);
@ -666,16 +671,7 @@ void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
* @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
*/ */
static inline int av_size_mult(size_t a, size_t b, size_t *r) int av_size_mult(size_t a, size_t b, size_t *r);
{
size_t t = a * b;
/* Hack inspired from glibc: don't try the division if nelem and elsize
* are both less than sqrt(SIZE_MAX). */
if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
return AVERROR(EINVAL);
*r = t;
return 0;
}
/** /**
* Set the maximum size that may be allocated in one block. * Set the maximum size that may be allocated in one block.

7
ext_includes/ffmpeg/libavutil/murmur3.h
View File

@ -27,10 +27,9 @@
#ifndef AVUTIL_MURMUR3_H #ifndef AVUTIL_MURMUR3_H
#define AVUTIL_MURMUR3_H #define AVUTIL_MURMUR3_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "version.h"
/** /**
* @defgroup lavu_murmur3 Murmur3 * @defgroup lavu_murmur3 Murmur3
* @ingroup lavu_hash * @ingroup lavu_hash
@ -99,11 +98,7 @@ void av_murmur3_init(struct AVMurMur3 *c);
* @param[in] src Input data to update hash with * @param[in] src Input data to update hash with
* @param[in] len Number of bytes to read from `src` * @param[in] len Number of bytes to read from `src`
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len);
#else
void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, size_t len); void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, size_t len);
#endif
/** /**
* Finish hashing and output digest value. * Finish hashing and output digest value.

54
ext_includes/ffmpeg/libavutil/opt.h
View File

@ -29,11 +29,11 @@
#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"
#include "samplefmt.h" #include "samplefmt.h"
#include "version.h"
/** /**
* @defgroup avoptions AVOptions * @defgroup avoptions AVOptions
@ -114,7 +114,7 @@
* libavcodec exports generic options, while its priv_data field exports * libavcodec exports generic options, while its priv_data field exports
* codec-specific options). In such a case, it is possible to set up the * codec-specific options). In such a case, it is possible to set up the
* parent struct to export a child's options. To do that, simply * parent struct to export a child's options. To do that, simply
* implement AVClass.child_next() and AVClass.child_class_next() in the * implement AVClass.child_next() and AVClass.child_class_iterate() in the
* parent struct's AVClass. * parent struct's AVClass.
* Assuming that the test_struct from above now also contains a * Assuming that the test_struct from above now also contains a
* child_struct field: * child_struct field:
@ -143,23 +143,25 @@
* return t->child_struct; * return t->child_struct;
* return NULL * return NULL
* } * }
* const AVClass child_class_next(const AVClass *prev) * const AVClass child_class_iterate(void **iter)
* { * {
* return prev ? NULL : &child_class; * const AVClass *c = *iter ? NULL : &child_class;
* *iter = (void*)(uintptr_t)c;
* return c;
* } * }
* @endcode * @endcode
* Putting child_next() and child_class_next() as defined above into * Putting child_next() and child_class_iterate() as defined above into
* test_class will now make child_struct's options accessible through * test_class will now make child_struct's options accessible through
* test_struct (again, proper setup as described above needs to be done on * test_struct (again, proper setup as described above needs to be done on
* child_struct right after it is created). * child_struct right after it is created).
* *
* From the above example it might not be clear why both child_next() * From the above example it might not be clear why both child_next()
* and child_class_next() are needed. The distinction is that child_next() * and child_class_iterate() are needed. The distinction is that child_next()
* iterates over actually existing objects, while child_class_next() * iterates over actually existing objects, while child_class_iterate()
* iterates over all possible child classes. E.g. if an AVCodecContext * iterates over all possible child classes. E.g. if an AVCodecContext
* was initialized to use a codec which has private options, then its * was initialized to use a codec which has private options, then its
* child_next() will return AVCodecContext.priv_data and finish * child_next() will return AVCodecContext.priv_data and finish
* iterating. OTOH child_class_next() on AVCodecContext.av_class will * iterating. OTOH child_class_iterate() on AVCodecContext.av_class will
* iterate over all available codecs with private options. * iterate over all available codecs with private options.
* *
* @subsection avoptions_implement_named_constants Named constants * @subsection avoptions_implement_named_constants Named constants
@ -194,7 +196,7 @@
* For enumerating there are basically two cases. The first is when you want to * For enumerating there are basically two cases. The first is when you want to
* get all options that may potentially exist on the struct and its children * get all options that may potentially exist on the struct and its children
* (e.g. when constructing documentation). In that case you should call * (e.g. when constructing documentation). In that case you should call
* av_opt_child_class_next() recursively on the parent struct's AVClass. The * av_opt_child_class_iterate() recursively on the parent struct's AVClass. The
* second case is when you have an already initialized struct with all its * second case is when you have an already initialized struct with all its
* children and you want to get all options that can be actually written or read * children and you want to get all options that can be actually written or read
* from it. In that case you should call av_opt_child_next() recursively (and * from it. In that case you should call av_opt_child_next() recursively (and
@ -236,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,
}; };
/** /**
@ -288,8 +293,10 @@ typedef struct AVOption {
*/ */
#define AV_OPT_FLAG_READONLY 128 #define AV_OPT_FLAG_READONLY 128
#define AV_OPT_FLAG_BSF_PARAM (1<<8) ///< a generic parameter which can be set by the user for bit stream filtering #define AV_OPT_FLAG_BSF_PARAM (1<<8) ///< a generic parameter which can be set by the user for bit stream filtering
#define AV_OPT_FLAG_RUNTIME_PARAM (1<<15) ///< a generic parameter which can be set by the user at runtime
#define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering #define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
#define AV_OPT_FLAG_DEPRECATED (1<<17) ///< set if option is deprecated, users should refer to AVOption.help text for more information #define AV_OPT_FLAG_DEPRECATED (1<<17) ///< set if option is deprecated, users should refer to AVOption.help text for more information
#define AV_OPT_FLAG_CHILD_CONSTS (1<<18) ///< set if option constants can also reside in child objects
//FIXME think about enc-audio, ... style flags //FIXME think about enc-audio, ... style flags
/** /**
@ -647,10 +654,10 @@ void *av_opt_child_next(void *obj, void *prev);
/** /**
* Iterate over potential AVOptions-enabled children of parent. * Iterate over potential AVOptions-enabled children of parent.
* *
* @param prev result of a previous call to this function or NULL * @param iter a pointer where iteration state is stored.
* @return AVClass corresponding to next potential child or NULL * @return AVClass corresponding to next potential child or NULL
*/ */
const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev); const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter);
/** /**
* @defgroup opt_set_funcs Option setting functions * @defgroup opt_set_funcs Option setting functions
@ -669,6 +676,9 @@ const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *pre
* scalars or named flags separated by '+' or '-'. Prefixing a flag * scalars or named flags separated by '+' or '-'. Prefixing a flag
* with '+' causes it to be set without affecting the other flags; * with '+' causes it to be set without affecting the other flags;
* similarly, '-' unsets a flag. * similarly, '-' unsets a flag.
* If the field is of a dictionary type, it has to be a ':' separated list of
* key=value parameters. Values containing ':' special characters must be
* escaped.
* @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
* is passed here, then the option may be set on a child of obj. * is passed here, then the option may be set on a child of obj.
* *
@ -687,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.
@ -729,9 +743,10 @@ int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, in
/** /**
* @note the returned string will be av_malloc()ed and must be av_free()ed by the caller * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
* *
* @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the
* AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set * option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT
* to NULL instead of an allocated empty string. * and is set to NULL, *out_val will be set to NULL instead of an allocated
* empty string.
*/ */
int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val); int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val);
int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val); int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val);
@ -741,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
@ -783,9 +802,16 @@ int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags
/** /**
* Copy options from src object into dest object. * Copy options from src object into dest object.
* *
* The underlying AVClass of both src and dest must coincide. The guarantee
* below does not apply if this is not fulfilled.
*
* Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object. * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
* Original memory allocated for such options is freed unless both src and dest options points to the same memory. * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
* *
* Even on error it is guaranteed that allocated options from src and dest
* no longer alias each other afterwards; in particular calling av_opt_free()
* on both src and dest is safe afterwards if dest has been memdup'ed from src.
*
* @param dest Object to copy from * @param dest Object to copy from
* @param src Object to copy into * @param src Object to copy into
* @return 0 on success, negative on error * @return 0 on success, negative on error

34
ext_includes/ffmpeg/libavutil/pixdesc.h
View File

@ -22,15 +22,10 @@
#ifndef AVUTIL_PIXDESC_H #ifndef AVUTIL_PIXDESC_H
#define AVUTIL_PIXDESC_H #define AVUTIL_PIXDESC_H
/* modification for MSVC by kode54 */
#ifndef _MSC_VER
#include <inttypes.h> #include <inttypes.h>
#endif
/* end modification */
#include "attributes.h" #include "attributes.h"
#include "pixfmt.h" #include "pixfmt.h"
#include "version.h"
typedef struct AVComponentDescriptor { typedef struct AVComponentDescriptor {
/** /**
@ -60,17 +55,6 @@ typedef struct AVComponentDescriptor {
* Number of bits in the component. * Number of bits in the component.
*/ */
int depth; int depth;
#if FF_API_PLUS1_MINUS1
/** deprecated, use step instead */
attribute_deprecated int step_minus1;
/** deprecated, use depth instead */
attribute_deprecated int depth_minus1;
/** deprecated, use offset instead */
attribute_deprecated int offset_plus1;
#endif
} AVComponentDescriptor; } AVComponentDescriptor;
/** /**
@ -151,24 +135,6 @@ typedef struct AVPixFmtDescriptor {
*/ */
#define AV_PIX_FMT_FLAG_RGB (1 << 5) #define AV_PIX_FMT_FLAG_RGB (1 << 5)
/**
* The pixel format is "pseudo-paletted". This means that it contains a
* fixed palette in the 2nd plane but the palette is fixed/constant for each
* PIX_FMT. This allows interpreting the data as if it was PAL8, which can
* in some cases be simpler. Or the data can be interpreted purely based on
* the pixel format without using the palette.
* An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8
*
* @deprecated This flag is deprecated, and will be removed. When it is removed,
* the extra palette allocation in AVFrame.data[1] is removed as well. Only
* actual paletted formats (as indicated by AV_PIX_FMT_FLAG_PAL) will have a
* palette. Starting with FFmpeg versions which have this flag deprecated, the
* extra "pseudo" palette is already ignored, and API users are not required to
* allocate a palette for AV_PIX_FMT_FLAG_PSEUDOPAL formats (it was required
* before the deprecation, though).
*/
#define AV_PIX_FMT_FLAG_PSEUDOPAL (1 << 6)
/** /**
* The pixel format has an alpha channel. This is set on all formats that * The pixel format has an alpha channel. This is set on all formats that
* support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always * support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always

1
ext_includes/ffmpeg/libavutil/pixelutils.h
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])

154
ext_includes/ffmpeg/libavutil/pixfmt.h
View File

@ -112,21 +112,11 @@ enum AVPixelFormat {
AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
#if FF_API_VAAPI
/** @name Deprecated pixel formats */
/**@{*/
AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
AV_PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a VASurfaceID
/**@}*/
AV_PIX_FMT_VAAPI = AV_PIX_FMT_VAAPI_VLD,
#else
/** /**
* Hardware acceleration through VA-API, data[3] contains a * Hardware acceleration through VA-API, data[3] contains a
* VASurfaceID. * VASurfaceID.
*/ */
AV_PIX_FMT_VAAPI, AV_PIX_FMT_VAAPI,
#endif
AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@ -257,20 +247,22 @@ enum AVPixelFormat {
AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian
AV_PIX_FMT_YUVJ411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range AV_PIX_FMT_YUVJ411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */ AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */ AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */ AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */ AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */ AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */ AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */ AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */ AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */ AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */ AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
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
@ -345,6 +337,36 @@ enum AVPixelFormat {
AV_PIX_FMT_YUVA444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian AV_PIX_FMT_YUVA444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
AV_PIX_FMT_YUVA444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian AV_PIX_FMT_YUVA444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
AV_PIX_FMT_NV24, ///< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
AV_PIX_FMT_NV42, ///< as above, but U and V bytes are swapped
/**
* Vulkan hardware images.
*
* data[0] points to an AVVkFrame
*/
AV_PIX_FMT_VULKAN,
AV_PIX_FMT_Y210BE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian
AV_PIX_FMT_Y210LE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
AV_PIX_FMT_X2RGB10LE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
AV_PIX_FMT_X2RGB10BE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
AV_PIX_FMT_X2BGR10LE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
AV_PIX_FMT_X2BGR10BE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined
AV_PIX_FMT_P210BE, ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
AV_PIX_FMT_P210LE, ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
AV_PIX_FMT_P410BE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-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_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_P416LE, ///< interleaved chroma YUV 4:4:4, 48bpp, 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
}; };
@ -433,33 +455,43 @@ enum AVPixelFormat {
#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_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_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE)
#define AV_PIX_FMT_X2BGR10 AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE)
#define AV_PIX_FMT_P210 AV_PIX_FMT_NE(P210BE, P210LE)
#define AV_PIX_FMT_P410 AV_PIX_FMT_NE(P410BE, P410LE)
#define AV_PIX_FMT_P216 AV_PIX_FMT_NE(P216BE, P216LE)
#define AV_PIX_FMT_P416 AV_PIX_FMT_NE(P416BE, P416LE)
/** /**
* Chromaticity coordinates of the source primaries. * Chromaticity coordinates of the source primaries.
* These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1. * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273.
*/ */
enum AVColorPrimaries { enum AVColorPrimaries {
AVCOL_PRI_RESERVED0 = 0, AVCOL_PRI_RESERVED0 = 0,
AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
AVCOL_PRI_UNSPECIFIED = 2, AVCOL_PRI_UNSPECIFIED = 2,
AVCOL_PRI_RESERVED = 3, AVCOL_PRI_RESERVED = 3,
AVCOL_PRI_BT470M = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20) AVCOL_PRI_BT470M = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
AVCOL_PRI_SMPTE240M = 7, ///< functionally identical to above AVCOL_PRI_SMPTE240M = 7, ///< identical to above, also called "SMPTE C" even though it uses D65
AVCOL_PRI_FILM = 8, ///< colour filters using Illuminant C AVCOL_PRI_FILM = 8, ///< colour filters using Illuminant C
AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020 AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020
AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ) AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428, AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
AVCOL_PRI_SMPTE431 = 11, ///< SMPTE ST 431-2 (2011) / DCI P3 AVCOL_PRI_SMPTE431 = 11, ///< SMPTE ST 431-2 (2011) / DCI P3
AVCOL_PRI_SMPTE432 = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3 AVCOL_PRI_SMPTE432 = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3
AVCOL_PRI_JEDEC_P22 = 22, ///< JEDEC P22 phosphors AVCOL_PRI_EBU3213 = 22, ///< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors
AVCOL_PRI_JEDEC_P22 = AVCOL_PRI_EBU3213,
AVCOL_PRI_NB ///< Not part of ABI AVCOL_PRI_NB ///< Not part of ABI
}; };
/** /**
* Color Transfer Characteristic. * Color Transfer Characteristic.
* These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2. * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2.
*/ */
enum AVColorTransferCharacteristic { enum AVColorTransferCharacteristic {
AVCOL_TRC_RESERVED0 = 0, AVCOL_TRC_RESERVED0 = 0,
@ -488,18 +520,18 @@ enum AVColorTransferCharacteristic {
/** /**
* YUV colorspace type. * YUV colorspace type.
* These values match the ones defined by ISO/IEC 23001-8_2013 § 7.3. * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3.
*/ */
enum AVColorSpace { enum AVColorSpace {
AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB) AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
AVCOL_SPC_UNSPECIFIED = 2, AVCOL_SPC_UNSPECIFIED = 2,
AVCOL_SPC_RESERVED = 3, AVCOL_SPC_RESERVED = 3, ///< reserved for future use by ITU-T and ISO/IEC just like 15-255 are
AVCOL_SPC_FCC = 4, ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20) AVCOL_SPC_FCC = 4, ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
AVCOL_SPC_SMPTE240M = 7, ///< functionally identical to above AVCOL_SPC_SMPTE240M = 7, ///< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
AVCOL_SPC_YCGCO = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16 AVCOL_SPC_YCGCO = 8, ///< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
AVCOL_SPC_YCOCG = AVCOL_SPC_YCGCO, AVCOL_SPC_YCOCG = AVCOL_SPC_YCGCO,
AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system
AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system
@ -511,12 +543,60 @@ enum AVColorSpace {
}; };
/** /**
* MPEG vs JPEG YUV range. * Visual content value range.
*
* These values are based on definitions that can be found in multiple
* specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance
* and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital
* Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit
* integer representation). At the time of writing, the BT.2100 one is
* recommended, as it also defines the full range representation.
*
* Common definitions:
* - For RGB and luma planes such as Y in YCbCr and I in ICtCp,
* 'E' is the original value in range of 0.0 to 1.0.
* - For chroma planes such as Cb,Cr and Ct,Cp, 'E' is the original
* value in range of -0.5 to 0.5.
* - 'n' is the output bit depth.
* - For additional definitions such as rounding and clipping to valid n
* bit unsigned integer range, please refer to BT.2100 (Table 9).
*/ */
enum AVColorRange { enum AVColorRange {
AVCOL_RANGE_UNSPECIFIED = 0, AVCOL_RANGE_UNSPECIFIED = 0,
AVCOL_RANGE_MPEG = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
AVCOL_RANGE_JPEG = 2, ///< the normal 2^n-1 "JPEG" YUV ranges /**
* Narrow or limited range content.
*
* - For luma planes:
*
* (219 * E + 16) * 2^(n-8)
*
* F.ex. the range of 16-235 for 8 bits
*
* - For chroma planes:
*
* (224 * E + 128) * 2^(n-8)
*
* F.ex. the range of 16-240 for 8 bits
*/
AVCOL_RANGE_MPEG = 1,
/**
* Full range content.
*
* - For RGB and luma planes:
*
* (2^n - 1) * E
*
* F.ex. the range of 0-255 for 8 bits
*
* - For chroma planes:
*
* (2^n - 1) * E + 2^(n - 1)
*
* F.ex. the range of 1-255 for 8 bits
*/
AVCOL_RANGE_JPEG = 2,
AVCOL_RANGE_NB ///< Not part of ABI AVCOL_RANGE_NB ///< Not part of ABI
}; };

6
ext_includes/ffmpeg/libavutil/rational.h
View File

@ -207,6 +207,12 @@ int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
*/ */
uint32_t av_q2intfloat(AVRational q); uint32_t av_q2intfloat(AVRational q);
/**
* Return the best rational so that a and b are multiple of it.
* If the resulting denominator is larger than max_den, return def.
*/
AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def);
/** /**
* @} * @}
*/ */

6
ext_includes/ffmpeg/libavutil/ripemd.h
View File

@ -28,10 +28,10 @@
#ifndef AVUTIL_RIPEMD_H #ifndef AVUTIL_RIPEMD_H
#define AVUTIL_RIPEMD_H #define AVUTIL_RIPEMD_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @defgroup lavu_ripemd RIPEMD * @defgroup lavu_ripemd RIPEMD
@ -66,11 +66,7 @@ int av_ripemd_init(struct AVRIPEMD* context, int bits);
* @param data input data to update hash with * @param data input data to update hash with
* @param len input data length * @param len input data length
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, unsigned int len);
#else
void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, size_t len); void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, size_t len);
#endif
/** /**
* Finish hashing and output digest value. * Finish hashing and output digest value.

8
ext_includes/ffmpeg/libavutil/samplefmt.h
View File

@ -21,9 +21,6 @@
#include <stdint.h> #include <stdint.h>
#include "avutil.h"
#include "attributes.h"
/** /**
* @addtogroup lavu_audio * @addtogroup lavu_audio
* @{ * @{
@ -195,9 +192,8 @@ int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
* @param nb_samples the number of samples in a single channel * @param nb_samples the number of samples in a single channel
* @param sample_fmt the sample format * @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 minimum size in bytes required for the buffer on success,
* @todo return minimum size in bytes required for the buffer in case * or a negative error code on failure
* of success at the next bump
*/ */
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
const uint8_t *buf, const uint8_t *buf,

5
ext_includes/ffmpeg/libavutil/sha.h
View File

@ -31,7 +31,6 @@
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @defgroup lavu_sha SHA * @defgroup lavu_sha SHA
@ -74,11 +73,7 @@ int av_sha_init(struct AVSHA* context, int bits);
* @param data input data to update hash with * @param data input data to update hash with
* @param len input data length * @param len input data length
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len);
#else
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len); void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len);
#endif
/** /**
* Finish hashing and output digest value. * Finish hashing and output digest value.

5
ext_includes/ffmpeg/libavutil/sha512.h
View File

@ -32,7 +32,6 @@
#include <stdint.h> #include <stdint.h>
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @defgroup lavu_sha512 SHA-512 * @defgroup lavu_sha512 SHA-512
@ -76,11 +75,7 @@ int av_sha512_init(struct AVSHA512* context, int bits);
* @param data input data to update hash with * @param data input data to update hash with
* @param len input data length * @param len input data length
*/ */
#if FF_API_CRYPTO_SIZE_T
void av_sha512_update(struct AVSHA512* context, const uint8_t* data, unsigned int len);
#else
void av_sha512_update(struct AVSHA512* context, const uint8_t* data, size_t len); void av_sha512_update(struct AVSHA512* context, const uint8_t* data, size_t len);
#endif
/** /**
* Finish hashing and output digest value. * Finish hashing and output digest value.

67
ext_includes/ffmpeg/libavutil/timecode.h
View File

@ -49,9 +49,9 @@ typedef struct {
* Adjust frame number for NTSC drop frame time code. * Adjust frame number for NTSC drop frame time code.
* *
* @param framenum frame number to adjust * @param framenum frame number to adjust
* @param fps frame per second, 30 or 60 * @param fps frame per second, multiples of 30
* @return adjusted frame number * @return adjusted frame number
* @warning adjustment is only valid in NTSC 29.97 and 59.94 * @warning adjustment is only valid for multiples of NTSC 29.97
*/ */
int av_timecode_adjust_ntsc_framenum2(int framenum, int fps); int av_timecode_adjust_ntsc_framenum2(int framenum, int fps);
@ -62,14 +62,39 @@ int av_timecode_adjust_ntsc_framenum2(int framenum, int fps);
* @param framenum frame number * @param framenum frame number
* @return the SMPTE binary representation * @return the SMPTE binary representation
* *
* See SMPTE ST 314M-2005 Sec 4.4.2.2.1 "Time code pack (TC)"
* the format description as follows:
* bits 0-5: hours, in BCD(6bits)
* bits 6: BGF1
* bits 7: BGF2 (NTSC) or FIELD (PAL)
* bits 8-14: minutes, in BCD(7bits)
* bits 15: BGF0 (NTSC) or BGF2 (PAL)
* bits 16-22: seconds, in BCD(7bits)
* bits 23: FIELD (NTSC) or BGF0 (PAL)
* bits 24-29: frames, in BCD(6bits)
* bits 30: drop frame flag (0: non drop, 1: drop)
* bits 31: color frame flag (0: unsync mode, 1: sync mode)
* @note BCD numbers (6 or 7 bits): 4 or 5 lower bits for units, 2 higher bits for tens.
* @note Frame number adjustment is automatically done in case of drop timecode, * @note Frame number adjustment is automatically done in case of drop timecode,
* you do NOT have to call av_timecode_adjust_ntsc_framenum2(). * you do NOT have to call av_timecode_adjust_ntsc_framenum2().
* @note The frame number is relative to tc->start. * @note The frame number is relative to tc->start.
* @note Color frame (CF), binary group flags (BGF) and biphase mark polarity * @note Color frame (CF) and binary group flags (BGF) bits are set to zero.
* correction (PC) bits are set to zero.
*/ */
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum); uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum);
/**
* Convert sei info to SMPTE 12M binary representation.
*
* @param rate frame rate in rational form
* @param drop drop flag
* @param hh hour
* @param mm minute
* @param ss second
* @param ff frame number
* @return the SMPTE binary representation
*/
uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff);
/** /**
* Load timecode string in buf. * Load timecode string in buf.
* *
@ -84,6 +109,23 @@ uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
*/ */
char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum); char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum);
/**
* Get the timecode string from the SMPTE timecode format.
*
* In contrast to av_timecode_make_smpte_tc_string this function supports 50/60
* fps timecodes by using the field bit.
*
* @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long
* @param rate frame rate of the timecode
* @param tcsmpte the 32-bit SMPTE timecode
* @param prevent_df prevent the use of a drop flag when it is known the DF bit
* is arbitrary
* @param skip_field prevent the use of a field flag when it is known the field
* bit is arbitrary (e.g. because it is used as PC flag)
* @return the buf parameter
*/
char *av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field);
/** /**
* Get the timecode string from the SMPTE timecode format. * Get the timecode string from the SMPTE timecode format.
* *
@ -118,6 +160,23 @@ char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit);
*/ */
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx); int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx);
/**
* Init a timecode struct from the passed timecode components.
*
* @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)
* @param tc pointer to an allocated AVTimecode
* @param rate frame rate in rational form
* @param flags miscellaneous flags such as drop frame, +24 hours, ...
* (see AVTimecodeFlag)
* @param hh hours
* @param mm minutes
* @param ss seconds
* @param ff frames
* @return 0 on success, AVERROR otherwise
*/
int av_timecode_init_from_components(AVTimecode *tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void *log_ctx);
/** /**
* Parse timecode representation (hh:mm:ss[:;.]ff). * Parse timecode representation (hh:mm:ss[:;.]ff).
* *

1
ext_includes/ffmpeg/libavutil/tree.h
View File

@ -28,7 +28,6 @@
#define AVUTIL_TREE_H #define AVUTIL_TREE_H
#include "attributes.h" #include "attributes.h"
#include "version.h"
/** /**
* @addtogroup lavu_tree AVTree * @addtogroup lavu_tree AVTree

161
ext_includes/ffmpeg/libavutil/tx.h Normal file
View File

@ -0,0 +1,161 @@
/*
* 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_TX_H
#define AVUTIL_TX_H
#include <stdint.h>
#include <stddef.h>
typedef struct AVTXContext AVTXContext;
typedef struct AVComplexFloat {
float re, im;
} AVComplexFloat;
typedef struct AVComplexDouble {
double re, im;
} AVComplexDouble;
typedef struct AVComplexInt32 {
int32_t re, im;
} AVComplexInt32;
enum AVTXType {
/**
* 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.
* The stride parameter must be set to the size of a single sample in bytes.
*/
AV_TX_FLOAT_FFT = 0,
AV_TX_DOUBLE_FFT = 2,
AV_TX_INT32_FFT = 4,
/**
* Standard MDCT with a sample data type of float, double or int32_t,
* 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
* sample in the output array in bytes. The input must be a flat array.
*
* For inverse transforms, the stride specifies the spacing between each
* sample in the input array in bytes. The output must be a flat array.
*
* 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
* inverse transform, set the AV_TX_FULL_IMDCT flag on init.
*/
AV_TX_FLOAT_MDCT = 1,
AV_TX_DOUBLE_MDCT = 3,
AV_TX_INT32_MDCT = 5,
/**
* 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.
*
* The stride parameter must be set to the size of a single sample 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_FLOAT_RDFT = 6,
AV_TX_DOUBLE_RDFT = 7,
AV_TX_INT32_RDFT = 8,
/* Not part of the API, do not use */
AV_TX_NB,
};
/**
* Function pointer to a function to perform the transform.
*
* @note Using a different context than the one allocated during av_tx_init()
* is not allowed.
*
* @param s the transform context
* @param out the output array
* @param in the input array
* @param stride the input or output stride in bytes
*
* The out and in arrays must be aligned to the maximum required by the CPU
* architecture unless the AV_TX_UNALIGNED flag was set in av_tx_init().
* The stride must follow the constraints the transform type has specified.
*/
typedef void (*av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride);
/**
* Flags for av_tx_init()
*/
enum AVTXFlags {
/**
* Performs an in-place transformation on the input. The output argument
* of av_tn_fn() MUST match the input. May be unsupported or slower for some
* transform types.
*/
AV_TX_INPLACE = 1ULL << 0,
/**
* Relaxes alignment requirement for the in and out arrays of av_tx_fn().
* May be slower with certain transform types.
*/
AV_TX_UNALIGNED = 1ULL << 1,
/**
* Performs a full inverse MDCT rather than leaving out samples that can be
* derived through symmetry. Requires an output array of 'len' floats,
* rather than the usual 'len/2' floats.
* Ignored for all transforms but inverse MDCTs.
*/
AV_TX_FULL_IMDCT = 1ULL << 2,
};
/**
* Initialize a transform context with the given configuration
* (i)MDCTs with an odd length are currently not supported.
*
* @param ctx the context to allocate, will be NULL on error
* @param tx pointer to the transform function pointer to set
* @param type type the type of transform
* @param inv whether to do an inverse or a forward transform
* @param len the size of the transform in samples
* @param scale pointer to the value to scale the output if supported by type
* @param flags a bitmask of AVTXFlags or 0
*
* @return 0 on success, negative error code on failure
*/
int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type,
int inv, int len, const void *scale, uint64_t flags);
/**
* Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
*/
void av_tx_uninit(AVTXContext **ctx);
#endif /* AVUTIL_TX_H */

147
ext_includes/ffmpeg/libavutil/uuid.h Normal file
View File

@ -0,0 +1,147 @@
/*
* 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.
* @return A non-zero value in case of an error.
*/
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 */

38
ext_includes/ffmpeg/libavutil/version.h
View File

@ -78,8 +78,8 @@
* @{ * @{
*/ */
#define LIBAVUTIL_VERSION_MAJOR 56 #define LIBAVUTIL_VERSION_MAJOR 57
#define LIBAVUTIL_VERSION_MINOR 25 #define LIBAVUTIL_VERSION_MINOR 28
#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,31 +105,15 @@
* @{ * @{
*/ */
#ifndef FF_API_VAAPI #define FF_API_D2STR (LIBAVUTIL_VERSION_MAJOR < 58)
#define FF_API_VAAPI (LIBAVUTIL_VERSION_MAJOR < 57) #define FF_API_DECLARE_ALIGNED (LIBAVUTIL_VERSION_MAJOR < 58)
#endif #define FF_API_COLORSPACE_NAME (LIBAVUTIL_VERSION_MAJOR < 58)
#ifndef FF_API_FRAME_QP #define FF_API_AV_MALLOCZ_ARRAY (LIBAVUTIL_VERSION_MAJOR < 58)
#define FF_API_FRAME_QP (LIBAVUTIL_VERSION_MAJOR < 57) #define FF_API_FIFO_PEEK2 (LIBAVUTIL_VERSION_MAJOR < 58)
#endif #define FF_API_FIFO_OLD_API (LIBAVUTIL_VERSION_MAJOR < 58)
#ifndef FF_API_PLUS1_MINUS1 #define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 58)
#define FF_API_PLUS1_MINUS1 (LIBAVUTIL_VERSION_MAJOR < 57) #define FF_API_OLD_CHANNEL_LAYOUT (LIBAVUTIL_VERSION_MAJOR < 58)
#endif #define FF_API_AV_FOPEN_UTF8 (LIBAVUTIL_VERSION_MAJOR < 58)
#ifndef FF_API_ERROR_FRAME
#define FF_API_ERROR_FRAME (LIBAVUTIL_VERSION_MAJOR < 57)
#endif
#ifndef FF_API_PKT_PTS
#define FF_API_PKT_PTS (LIBAVUTIL_VERSION_MAJOR < 57)
#endif
#ifndef FF_API_CRYPTO_SIZE_T
#define FF_API_CRYPTO_SIZE_T (LIBAVUTIL_VERSION_MAJOR < 57)
#endif
#ifndef FF_API_FRAME_GET_SET
#define FF_API_FRAME_GET_SET (LIBAVUTIL_VERSION_MAJOR < 57)
#endif
#ifndef FF_API_PSEUDOPAL
#define FF_API_PSEUDOPAL (LIBAVUTIL_VERSION_MAJOR < 57)
#endif
/** /**
* @} * @}

171
ext_includes/ffmpeg/libavutil/video_enc_params.h Normal file
View File

@ -0,0 +1,171 @@
/*
* 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_VIDEO_ENC_PARAMS_H
#define AVUTIL_VIDEO_ENC_PARAMS_H
#include <stddef.h>
#include <stdint.h>
#include "libavutil/avassert.h"
#include "libavutil/frame.h"
enum AVVideoEncParamsType {
AV_VIDEO_ENC_PARAMS_NONE = -1,
/**
* VP9 stores:
* - per-frame base (luma AC) quantizer index, exported as AVVideoEncParams.qp
* - deltas for luma DC, chroma AC and chroma DC, exported in the
* corresponding entries in AVVideoEncParams.delta_qp
* - per-segment delta, exported as for each block as AVVideoBlockParams.delta_qp
*
* To compute the resulting quantizer index for a block:
* - for luma AC, add the base qp and the per-block delta_qp, saturating to
* unsigned 8-bit.
* - for luma DC and chroma AC/DC, add the corresponding
* AVVideoBlockParams.delta_qp to the luma AC index, again saturating to
* unsigned 8-bit.
*/
AV_VIDEO_ENC_PARAMS_VP9,
/**
* H.264 stores:
* - in PPS (per-picture):
* * initial QP_Y (luma) value, exported as AVVideoEncParams.qp
* * delta(s) for chroma QP values (same for both, or each separately),
* exported as in the corresponding entries in AVVideoEncParams.delta_qp
* - per-slice QP delta, not exported directly, added to the per-MB value
* - per-MB delta; not exported directly; the final per-MB quantizer
* parameter - QP_Y - minus the value in AVVideoEncParams.qp is exported
* as AVVideoBlockParams.qp_delta.
*/
AV_VIDEO_ENC_PARAMS_H264,
/*
* MPEG-2-compatible quantizer.
*
* Summing the frame-level qp with the per-block delta_qp gives the
* resulting quantizer for the block.
*/
AV_VIDEO_ENC_PARAMS_MPEG2,
};
/**
* Video encoding parameters for a given frame. This struct is allocated along
* with an optional array of per-block AVVideoBlockParams descriptors.
* Must be allocated with av_video_enc_params_alloc().
*/
typedef struct AVVideoEncParams {
/**
* Number of blocks in the array.
*
* May be 0, in which case no per-block information is present. In this case
* the values of blocks_offset / block_size are unspecified and should not
* be accessed.
*/
unsigned int nb_blocks;
/**
* Offset in bytes from the beginning of this structure at which the array
* of blocks starts.
*/
size_t blocks_offset;
/*
* Size of each block in bytes. May not match sizeof(AVVideoBlockParams).
*/
size_t block_size;
/**
* Type of the parameters (the codec they are used with).
*/
enum AVVideoEncParamsType type;
/**
* Base quantisation parameter for the frame. The final quantiser for a
* given block in a given plane is obtained from this value, possibly
* combined with {@code delta_qp} and the per-block delta in a manner
* documented for each type.
*/
int32_t qp;
/**
* Quantisation parameter offset from the base (per-frame) qp for a given
* plane (first index) and AC/DC coefficients (second index).
*/
int32_t delta_qp[4][2];
} AVVideoEncParams;
/**
* Data structure for storing block-level encoding information.
* It is allocated as a part of AVVideoEncParams and should be retrieved with
* av_video_enc_params_block().
*
* sizeof(AVVideoBlockParams) is not a part of the ABI and new fields may be
* added to it.
*/
typedef struct AVVideoBlockParams {
/**
* Distance in luma pixels from the top-left corner of the visible frame
* to the top-left corner of the block.
* Can be negative if top/right padding is present on the coded frame.
*/
int src_x, src_y;
/**
* Width and height of the block in luma pixels.
*/
int w, h;
/**
* Difference between this block's final quantization parameter and the
* corresponding per-frame value.
*/
int32_t delta_qp;
} AVVideoBlockParams;
/*
* Get the block at the specified {@code idx}. Must be between 0 and nb_blocks.
*/
static av_always_inline AVVideoBlockParams*
av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
{
av_assert0(idx < par->nb_blocks);
return (AVVideoBlockParams *)((uint8_t *)par + par->blocks_offset +
idx * par->block_size);
}
/**
* Allocates memory for AVVideoEncParams of the given type, plus an array of
* {@code nb_blocks} AVVideoBlockParams and initializes the variables. Can be
* freed with a normal av_free() call.
*
* @param out_size if non-NULL, the size in bytes of the resulting data array is
* written here.
*/
AVVideoEncParams *av_video_enc_params_alloc(enum AVVideoEncParamsType type,
unsigned int nb_blocks, size_t *out_size);
/**
* Allocates memory for AVEncodeInfoFrame plus an array of
* {@code nb_blocks} AVEncodeInfoBlock in the given AVFrame {@code frame}
* as AVFrameSideData of type AV_FRAME_DATA_VIDEO_ENC_PARAMS
* and initializes the variables.
*/
AVVideoEncParams*
av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type,
unsigned int nb_blocks);
#endif /* AVUTIL_VIDEO_ENC_PARAMS_H */

101
ext_includes/ffmpeg/libswresample/swresample.h
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
@ -73,7 +74,7 @@
* 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,
AVChannelLayout *out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
AVChannelLayout *in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate,
int log_offset, void *log_ctx);
/** /**
* @} * @}
* *
@ -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.

7
ext_includes/ffmpeg/libswresample/version.h
View File

@ -26,10 +26,11 @@
* Libswresample version macros * Libswresample version macros
*/ */
#include "libavutil/avutil.h" #include "libavutil/version.h"
#define LIBSWRESAMPLE_VERSION_MAJOR 3 #include "version_major.h"
#define LIBSWRESAMPLE_VERSION_MINOR 4
#define LIBSWRESAMPLE_VERSION_MINOR 7
#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
ext_includes/ffmpeg/libswresample/version_major.h 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 */

32
ext_libs/CMakeLists.txt
View File

@ -40,20 +40,20 @@ if(MSVC)
if(USE_FFMPEG AND NOT FFMPEG_LIBRARIES) if(USE_FFMPEG AND NOT FFMPEG_LIBRARIES)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib ${CMAKE_CURRENT_BINARY_DIR}/avcodec.exp add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib ${CMAKE_CURRENT_BINARY_DIR}/avcodec.exp
COMMAND lib COMMAND lib
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-59.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-59.def)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib ${CMAKE_CURRENT_BINARY_DIR}/avformat.exp add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib ${CMAKE_CURRENT_BINARY_DIR}/avformat.exp
COMMAND lib COMMAND lib
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avformat.lib ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-59.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avformat.lib
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-59.def)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib ${CMAKE_CURRENT_BINARY_DIR}/avutil.exp add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib ${CMAKE_CURRENT_BINARY_DIR}/avutil.exp
COMMAND lib COMMAND lib
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avutil.lib ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-57.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avutil.lib
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-57.def)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib ${CMAKE_CURRENT_BINARY_DIR}/swresample.exp add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib ${CMAKE_CURRENT_BINARY_DIR}/swresample.exp
COMMAND lib COMMAND lib
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/swresample.lib ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-4.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/swresample.lib
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-4.def)
file(GLOB AVCODEC_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavcodec/*.h") file(GLOB AVCODEC_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavcodec/*.h")
file(GLOB AVFORMAT_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavformat/*.h") file(GLOB AVFORMAT_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavformat/*.h")
file(GLOB AVUTIL_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavutil/*.h") file(GLOB AVUTIL_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavutil/*.h")
@ -147,20 +147,20 @@ elseif(MINGW)
if(USE_FFMPEG AND NOT FFMPEG_LIBRARIES) if(USE_FFMPEG AND NOT FFMPEG_LIBRARIES)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib
COMMAND ${DLLTOOL} COMMAND ${DLLTOOL}
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def -l ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib -D avcodec-vgmstream-58.dll ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-59.def -l ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib -D avcodec-vgmstream-59.dll
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-59.def)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib
COMMAND ${DLLTOOL} COMMAND ${DLLTOOL}
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def -l ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib -D avformat-vgmstream-58.dll ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-59.def -l ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib -D avformat-vgmstream-59.dll
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-59.def)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib
COMMAND ${DLLTOOL} COMMAND ${DLLTOOL}
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def -l ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib -D avutil-vgmstream-56.dll ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-57.def -l ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib -D avutil-vgmstream-57.dll
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-57.def)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib
COMMAND ${DLLTOOL} COMMAND ${DLLTOOL}
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def -l ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib -D swresample-vgmstream-3.dll ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-4.def -l ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib -D swresample-vgmstream-4.dll
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-4.def)
add_custom_target(ffmpeg add_custom_target(ffmpeg
DEPENDS DEPENDS
${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib

18
ext_libs/Makefile
View File

@ -17,17 +17,17 @@ libmpg123-0.a: libmpg123-0.def
libg719_decode.a: libg719_decode.def libg719_decode.a: libg719_decode.def
$(DLLTOOL) -d libg719_decode.def -l libg719_decode.a $(DLLTOOL) -d libg719_decode.def -l libg719_decode.a
libavcodec.a: avcodec-vgmstream-58.dll avcodec-vgmstream-58.def libavcodec.a: avcodec-vgmstream-59.dll avcodec-vgmstream-59.def
$(DLLTOOL) -D avcodec-vgmstream-58.dll -d avcodec-vgmstream-58.def -l libavcodec.a $(DLLTOOL) -D avcodec-vgmstream-59.dll -d avcodec-vgmstream-59.def -l libavcodec.a
libavformat.a: avformat-vgmstream-58.dll avformat-vgmstream-58.def libavformat.a: avformat-vgmstream-59.dll avformat-vgmstream-59.def
$(DLLTOOL) -D avformat-vgmstream-58.dll -d avformat-vgmstream-58.def -l libavformat.a $(DLLTOOL) -D avformat-vgmstream-59.dll -d avformat-vgmstream-59.def -l libavformat.a
libavutil.a: avutil-vgmstream-56.dll avutil-vgmstream-56.def libavutil.a: avutil-vgmstream-57.dll avutil-vgmstream-57.def
$(DLLTOOL) -D avutil-vgmstream-56.dll -d avutil-vgmstream-56.def -l libavutil.a $(DLLTOOL) -D avutil-vgmstream-57.dll -d avutil-vgmstream-57.def -l libavutil.a
libswresample.a: swresample-vgmstream-3.dll swresample-vgmstream-3.def libswresample.a: swresample-vgmstream-4.dll swresample-vgmstream-4.def
$(DLLTOOL) -D swresample-vgmstream-3.dll -d swresample-vgmstream-3.def -l libswresample.a $(DLLTOOL) -D swresample-vgmstream-4.dll -d swresample-vgmstream-4.def -l libswresample.a
libatrac9.a: libatrac9.dll libatrac9.def libatrac9.a: libatrac9.dll libatrac9.def
$(DLLTOOL) -D libatrac9.dll -d libatrac9.def -l libatrac9.a $(DLLTOOL) -D libatrac9.dll -d libatrac9.def -l libatrac9.a
@ -42,6 +42,6 @@ libspeex/libspeex.a: libspeex/libspeex.dll libspeex/libspeex.def
$(DLLTOOL) -D libspeex.dll -d libspeex/libspeex.def -l libspeex/libspeex.a $(DLLTOOL) -D libspeex.dll -d libspeex/libspeex.def -l libspeex/libspeex.a
clean: clean:
$(RMF) libvorbis.a libmpg123-0.a libg719_decode.a libavcodec.a libavformat.a libavutil.a libswresample.a libatrac9.a libcelt-0061.a libcelt-0110.a $(RMF) libvorbis.a libmpg123-0.a libg719_decode.a libavcodec.a libavformat.a libavutil.a libswresample.a libatrac9.a libcelt-0061.a libcelt-0110.a libspeex/libspeex.a
.PHONY: clean .PHONY: clean

BIN
ext_libs/avcodec-vgmstream-58.dll
View File

Binary file not shown.

76
ext_libs/avcodec-vgmstream-58.def → ext_libs/avcodec-vgmstream-59.def
View File

@ -1,10 +1,6 @@
EXPORTS EXPORTS
av_ac3_parse_header av_ac3_parse_header
av_adts_header_parse av_adts_header_parse
av_bitstream_filter_close
av_bitstream_filter_filter
av_bitstream_filter_init
av_bitstream_filter_next
av_bsf_alloc av_bsf_alloc
av_bsf_flush av_bsf_flush
av_bsf_free av_bsf_free
@ -19,35 +15,18 @@ EXPORTS
av_bsf_list_finalize av_bsf_list_finalize
av_bsf_list_free av_bsf_list_free
av_bsf_list_parse_str av_bsf_list_parse_str
av_bsf_next
av_bsf_receive_packet av_bsf_receive_packet
av_bsf_send_packet av_bsf_send_packet
av_codec_ffversion av_codec_ffversion
av_codec_get_chroma_intra_matrix
av_codec_get_codec_descriptor
av_codec_get_codec_properties
av_codec_get_lowres
av_codec_get_max_lowres
av_codec_get_pkt_timebase
av_codec_get_seek_preroll
av_codec_is_decoder av_codec_is_decoder
av_codec_is_encoder av_codec_is_encoder
av_codec_iterate av_codec_iterate
av_codec_next
av_codec_set_chroma_intra_matrix
av_codec_set_codec_descriptor
av_codec_set_lowres
av_codec_set_pkt_timebase
av_codec_set_seek_preroll
av_copy_packet
av_copy_packet_side_data
av_cpb_properties_alloc av_cpb_properties_alloc
av_d3d11va_alloc_context av_d3d11va_alloc_context
av_dct_calc av_dct_calc
av_dct_end av_dct_end
av_dct_init av_dct_init
av_dirac_parse_sequence_header av_dirac_parse_sequence_header
av_dup_packet
av_dv_codec_profile av_dv_codec_profile
av_dv_codec_profile2 av_dv_codec_profile2
av_dv_frame_profile av_dv_frame_profile
@ -57,22 +36,19 @@ EXPORTS
av_fft_end av_fft_end
av_fft_init av_fft_init
av_fft_permute av_fft_permute
av_free_packet av_fopen_utf8
av_get_audio_frame_duration av_get_audio_frame_duration
av_get_audio_frame_duration2 av_get_audio_frame_duration2
av_get_bits_per_sample av_get_bits_per_sample
av_get_codec_tag_string
av_get_exact_bits_per_sample av_get_exact_bits_per_sample
av_get_pcm_codec av_get_pcm_codec
av_get_profile_name av_get_profile_name
av_grow_packet av_grow_packet
av_hwaccel_next
av_imdct_calc av_imdct_calc
av_imdct_half av_imdct_half
av_init_packet av_init_packet
av_jni_get_java_vm av_jni_get_java_vm
av_jni_set_java_vm av_jni_set_java_vm
av_lockmgr_register
av_mdct_calc av_mdct_calc
av_mdct_end av_mdct_end
av_mdct_init av_mdct_init
@ -92,7 +68,6 @@ EXPORTS
av_packet_get_side_data av_packet_get_side_data
av_packet_make_refcounted av_packet_make_refcounted
av_packet_make_writable av_packet_make_writable
av_packet_merge_side_data
av_packet_move_ref av_packet_move_ref
av_packet_new_side_data av_packet_new_side_data
av_packet_pack_dictionary av_packet_pack_dictionary
@ -100,25 +75,16 @@ EXPORTS
av_packet_rescale_ts av_packet_rescale_ts
av_packet_shrink_side_data av_packet_shrink_side_data
av_packet_side_data_name av_packet_side_data_name
av_packet_split_side_data
av_packet_unpack_dictionary av_packet_unpack_dictionary
av_packet_unref av_packet_unref
av_parser_change
av_parser_close av_parser_close
av_parser_init av_parser_init
av_parser_iterate av_parser_iterate
av_parser_next
av_parser_parse2 av_parser_parse2
av_picture_copy
av_picture_crop
av_picture_pad
av_qsv_alloc_context av_qsv_alloc_context
av_rdft_calc av_rdft_calc
av_rdft_end av_rdft_end
av_rdft_init av_rdft_init
av_register_bitstream_filter
av_register_codec_parser
av_register_hwaccel
av_shrink_packet av_shrink_packet
av_vorbis_parse_frame av_vorbis_parse_frame
av_vorbis_parse_frame_flags av_vorbis_parse_frame_flags
@ -132,42 +98,33 @@ EXPORTS
avcodec_chroma_pos_to_enum avcodec_chroma_pos_to_enum
avcodec_close avcodec_close
avcodec_configuration avcodec_configuration
avcodec_copy_context
avcodec_dct_alloc avcodec_dct_alloc
avcodec_dct_get_class avcodec_dct_get_class
avcodec_dct_init avcodec_dct_init
avcodec_decode_audio4
avcodec_decode_subtitle2 avcodec_decode_subtitle2
avcodec_decode_video2
avcodec_default_execute avcodec_default_execute
avcodec_default_execute2 avcodec_default_execute2
avcodec_default_get_buffer2 avcodec_default_get_buffer2
avcodec_default_get_encode_buffer
avcodec_default_get_format avcodec_default_get_format
avcodec_descriptor_get avcodec_descriptor_get
avcodec_descriptor_get_by_name avcodec_descriptor_get_by_name
avcodec_descriptor_next avcodec_descriptor_next
avcodec_encode_audio2
avcodec_encode_subtitle avcodec_encode_subtitle
avcodec_encode_video2
avcodec_enum_to_chroma_pos avcodec_enum_to_chroma_pos
avcodec_fill_audio_frame avcodec_fill_audio_frame
avcodec_find_best_pix_fmt_of_2
avcodec_find_best_pix_fmt_of_list avcodec_find_best_pix_fmt_of_list
avcodec_find_best_pix_fmt2
avcodec_find_decoder avcodec_find_decoder
avcodec_find_decoder_by_name avcodec_find_decoder_by_name
avcodec_find_encoder avcodec_find_encoder
avcodec_find_encoder_by_name avcodec_find_encoder_by_name
avcodec_flush_buffers avcodec_flush_buffers
avcodec_free_context avcodec_free_context
avcodec_get_chroma_sub_sample
avcodec_get_class avcodec_get_class
avcodec_get_context_defaults3
avcodec_get_frame_class avcodec_get_frame_class
avcodec_get_hw_config avcodec_get_hw_config
avcodec_get_hw_frames_parameters avcodec_get_hw_frames_parameters
avcodec_get_name avcodec_get_name
avcodec_get_pix_fmt_loss
avcodec_get_subtitle_rect_class avcodec_get_subtitle_rect_class
avcodec_get_type avcodec_get_type
avcodec_is_open avcodec_is_open
@ -182,38 +139,21 @@ EXPORTS
avcodec_profile_name avcodec_profile_name
avcodec_receive_frame avcodec_receive_frame
avcodec_receive_packet avcodec_receive_packet
avcodec_register
avcodec_register_all
avcodec_send_frame avcodec_send_frame
avcodec_send_packet avcodec_send_packet
avcodec_string avcodec_string
avcodec_version avcodec_version
avpicture_alloc
avpicture_fill
avpicture_free
avpicture_get_size
avpicture_layout
avpriv_ac3_channel_layout_tab
avpriv_ac3_parse_header avpriv_ac3_parse_header
avpriv_align_put_bits avpriv_adts_header_parse
avpriv_bprint_to_extradata
avpriv_codec_get_cap_skip_frame_fill_param avpriv_codec_get_cap_skip_frame_fill_param
avpriv_copy_bits
avpriv_dca_convert_bitstream
avpriv_dca_parse_core_frame_header
avpriv_dca_sample_rates
avpriv_find_pix_fmt
avpriv_find_start_code avpriv_find_start_code
avpriv_get_raw_pix_fmt_tags avpriv_get_raw_pix_fmt_tags
avpriv_mpa_bitrate_tab avpriv_mpeg4audio_get_config2
avpriv_mpa_freq_tab
avpriv_mpeg4audio_get_config
avpriv_mpeg4audio_sample_rates
avpriv_mpegaudio_decode_header avpriv_mpegaudio_decode_header
avpriv_pix_fmt_bps_avi avpriv_packet_list_free
avpriv_pix_fmt_bps_mov avpriv_packet_list_get
avpriv_put_string avpriv_packet_list_put
avpriv_pix_fmt_find
avpriv_split_xiph_headers avpriv_split_xiph_headers
avpriv_tak_parse_streaminfo avpriv_tak_parse_streaminfo
avpriv_toupper4
avsubtitle_free avsubtitle_free

BIN
ext_libs/avcodec-vgmstream-59.dll Normal file
View File

Binary file not shown.

BIN
ext_libs/avformat-vgmstream-58.dll
View File

Binary file not shown.

46
ext_libs/avformat-vgmstream-58.def → ext_libs/avformat-vgmstream-59.def
View File

@ -1,12 +1,12 @@
EXPORTS EXPORTS
av_add_index_entry av_add_index_entry
av_append_packet av_append_packet
av_apply_bitstream_filters
av_codec_get_id av_codec_get_id
av_codec_get_tag av_codec_get_tag
av_codec_get_tag2 av_codec_get_tag2
av_demuxer_iterate av_demuxer_iterate
av_demuxer_open av_disposition_from_string
av_disposition_to_string
av_dump_format av_dump_format
av_filename_number_test av_filename_number_test
av_find_best_stream av_find_best_stream
@ -14,25 +14,9 @@ EXPORTS
av_find_input_format av_find_input_format
av_find_program_from_stream av_find_program_from_stream
av_fmt_ctx_get_duration_estimation_method av_fmt_ctx_get_duration_estimation_method
av_fopen_utf8
av_format_ffversion av_format_ffversion
av_format_get_audio_codec
av_format_get_control_message_cb
av_format_get_data_codec
av_format_get_metadata_header_padding
av_format_get_opaque
av_format_get_open_cb
av_format_get_probe_score
av_format_get_subtitle_codec
av_format_get_video_codec
av_format_inject_global_side_data av_format_inject_global_side_data
av_format_set_audio_codec
av_format_set_control_message_cb
av_format_set_data_codec
av_format_set_metadata_header_padding
av_format_set_opaque
av_format_set_open_cb
av_format_set_subtitle_codec
av_format_set_video_codec
av_get_frame_filename av_get_frame_filename
av_get_frame_filename2 av_get_frame_filename2
av_get_output_timestamp av_get_output_timestamp
@ -43,16 +27,14 @@ EXPORTS
av_guess_sample_aspect_ratio av_guess_sample_aspect_ratio
av_hex_dump av_hex_dump
av_hex_dump_log av_hex_dump_log
av_iformat_next
av_index_search_timestamp av_index_search_timestamp
av_interleaved_write_frame av_interleaved_write_frame
av_interleaved_write_uncoded_frame av_interleaved_write_uncoded_frame
av_match_ext av_match_ext
av_muxer_iterate av_muxer_iterate
av_new_program av_new_program
av_oformat_next
av_pkt_dump_log2
av_pkt_dump2 av_pkt_dump2
av_pkt_dump_log2
av_probe_input_buffer av_probe_input_buffer
av_probe_input_buffer2 av_probe_input_buffer2
av_probe_input_format av_probe_input_format
@ -62,21 +44,15 @@ EXPORTS
av_read_frame av_read_frame
av_read_pause av_read_pause
av_read_play av_read_play
av_register_all
av_register_input_format
av_register_output_format
av_sdp_create av_sdp_create
av_seek_frame av_seek_frame
av_stream_add_side_data av_stream_add_side_data
av_stream_get_class
av_stream_get_codec_timebase av_stream_get_codec_timebase
av_stream_get_end_pts av_stream_get_end_pts
av_stream_get_parser av_stream_get_parser
av_stream_get_r_frame_rate
av_stream_get_recommended_encoder_configuration
av_stream_get_side_data av_stream_get_side_data
av_stream_new_side_data av_stream_new_side_data
av_stream_set_r_frame_rate
av_stream_set_recommended_encoder_configuration
av_url_split av_url_split
av_write_frame av_write_frame
av_write_trailer av_write_trailer
@ -94,6 +70,9 @@ EXPORTS
avformat_get_mov_video_tags avformat_get_mov_video_tags
avformat_get_riff_audio_tags avformat_get_riff_audio_tags
avformat_get_riff_video_tags avformat_get_riff_video_tags
avformat_index_get_entries_count
avformat_index_get_entry
avformat_index_get_entry_from_timestamp
avformat_init_output avformat_init_output
avformat_license avformat_license
avformat_match_stream_specifier avformat_match_stream_specifier
@ -126,11 +105,13 @@ EXPORTS
avio_get_str16le avio_get_str16le
avio_handshake avio_handshake
avio_open avio_open
avio_open2
avio_open_dir avio_open_dir
avio_open_dyn_buf avio_open_dyn_buf
avio_open2
avio_pause avio_pause
avio_print_string_array
avio_printf avio_printf
avio_protocol_get_class
avio_put_str avio_put_str
avio_put_str16be avio_put_str16be
avio_put_str16le avio_put_str16le
@ -151,6 +132,7 @@ EXPORTS
avio_seek_time avio_seek_time
avio_size avio_size
avio_skip avio_skip
avio_vprintf
avio_w8 avio_w8
avio_wb16 avio_wb16
avio_wb24 avio_wb24
@ -162,8 +144,8 @@ EXPORTS
avio_wl64 avio_wl64
avio_write avio_write
avio_write_marker avio_write_marker
avpriv_io_delete
avpriv_io_move
avpriv_new_chapter avpriv_new_chapter
avpriv_register_devices avpriv_register_devices
avpriv_set_pts_info avpriv_set_pts_info
avpriv_stream_set_need_parsing
avpriv_update_cur_dts

BIN
ext_libs/avformat-vgmstream-59.dll Normal file
View File

Binary file not shown.

BIN
ext_libs/avutil-vgmstream-56.dll
View File

Binary file not shown.

125
ext_libs/avutil-vgmstream-56.def → ext_libs/avutil-vgmstream-57.def
View File

@ -57,12 +57,14 @@ EXPORTS
av_buffer_get_ref_count av_buffer_get_ref_count
av_buffer_is_writable av_buffer_is_writable
av_buffer_make_writable av_buffer_make_writable
av_buffer_pool_buffer_get_opaque
av_buffer_pool_get av_buffer_pool_get
av_buffer_pool_init av_buffer_pool_init
av_buffer_pool_init2 av_buffer_pool_init2
av_buffer_pool_uninit av_buffer_pool_uninit
av_buffer_realloc av_buffer_realloc
av_buffer_ref av_buffer_ref
av_buffer_replace
av_buffer_unref av_buffer_unref
av_calloc av_calloc
av_camellia_alloc av_camellia_alloc
@ -74,7 +76,27 @@ EXPORTS
av_cast5_crypt2 av_cast5_crypt2
av_cast5_init av_cast5_init
av_cast5_size av_cast5_size
av_channel_description
av_channel_description_bprint
av_channel_from_string
av_channel_layout_channel_from_index
av_channel_layout_channel_from_string
av_channel_layout_check
av_channel_layout_compare
av_channel_layout_copy
av_channel_layout_default
av_channel_layout_describe
av_channel_layout_describe_bprint
av_channel_layout_extract_channel av_channel_layout_extract_channel
av_channel_layout_from_mask
av_channel_layout_from_string
av_channel_layout_index_from_channel
av_channel_layout_index_from_string
av_channel_layout_standard
av_channel_layout_subset
av_channel_layout_uninit
av_channel_name
av_channel_name_bprint
av_chroma_location_from_name av_chroma_location_from_name
av_chroma_location_name av_chroma_location_name
av_cmp_i av_cmp_i
@ -91,10 +113,14 @@ EXPORTS
av_content_light_metadata_alloc av_content_light_metadata_alloc
av_content_light_metadata_create_side_data av_content_light_metadata_create_side_data
av_cpu_count av_cpu_count
av_cpu_force_count
av_cpu_max_align av_cpu_max_align
av_crc av_crc
av_crc_get_table av_crc_get_table
av_crc_init av_crc_init
av_csp_luma_coeffs_from_avcsp
av_csp_primaries_desc_from_id
av_csp_primaries_id_from_desc
av_d2q av_d2q
av_d2str av_d2str
av_default_get_category av_default_get_category
@ -103,6 +129,8 @@ EXPORTS
av_des_crypt av_des_crypt
av_des_init av_des_init
av_des_mac av_des_mac
av_detection_bbox_alloc
av_detection_bbox_create_side_data
av_dict_copy av_dict_copy
av_dict_count av_dict_count
av_dict_free av_dict_free
@ -117,12 +145,16 @@ EXPORTS
av_display_rotation_set av_display_rotation_set
av_div_i av_div_i
av_div_q av_div_q
av_dovi_alloc
av_dovi_metadata_alloc
av_downmix_info_update_side_data av_downmix_info_update_side_data
av_dynamic_hdr_plus_alloc av_dynamic_hdr_plus_alloc
av_dynamic_hdr_plus_create_side_data av_dynamic_hdr_plus_create_side_data
av_dynamic_hdr_vivid_alloc
av_dynamic_hdr_vivid_create_side_data
av_dynarray2_add
av_dynarray_add av_dynarray_add
av_dynarray_add_nofree av_dynarray_add_nofree
av_dynarray2_add
av_encryption_info_add_side_data av_encryption_info_add_side_data
av_encryption_info_alloc av_encryption_info_alloc
av_encryption_info_clone av_encryption_info_clone
@ -133,6 +165,8 @@ EXPORTS
av_encryption_init_info_free av_encryption_init_info_free
av_encryption_init_info_get_side_data av_encryption_init_info_get_side_data
av_escape av_escape
av_expr_count_func
av_expr_count_vars
av_expr_eval av_expr_eval
av_expr_free av_expr_free
av_expr_parse av_expr_parse
@ -141,21 +175,38 @@ EXPORTS
av_fast_mallocz av_fast_mallocz
av_fast_realloc av_fast_realloc
av_fifo_alloc av_fifo_alloc
av_fifo_alloc2
av_fifo_alloc_array av_fifo_alloc_array
av_fifo_auto_grow_limit
av_fifo_can_read
av_fifo_can_write
av_fifo_drain av_fifo_drain
av_fifo_drain2
av_fifo_elem_size
av_fifo_free av_fifo_free
av_fifo_freep av_fifo_freep
av_fifo_freep2
av_fifo_generic_peek av_fifo_generic_peek
av_fifo_generic_peek_at av_fifo_generic_peek_at
av_fifo_generic_read av_fifo_generic_read
av_fifo_generic_write av_fifo_generic_write
av_fifo_grow av_fifo_grow
av_fifo_grow2
av_fifo_peek
av_fifo_peek_to_cb
av_fifo_read
av_fifo_read_to_cb
av_fifo_realloc2 av_fifo_realloc2
av_fifo_reset av_fifo_reset
av_fifo_reset2
av_fifo_size av_fifo_size
av_fifo_space av_fifo_space
av_fifo_write
av_fifo_write_from_cb
av_file_map av_file_map
av_file_unmap av_file_unmap
av_film_grain_params_alloc
av_film_grain_params_create_side_data
av_find_best_pix_fmt_of_2 av_find_best_pix_fmt_of_2
av_find_info_tag av_find_info_tag
av_find_nearest_q_idx av_find_nearest_q_idx
@ -168,20 +219,8 @@ EXPORTS
av_frame_copy av_frame_copy
av_frame_copy_props av_frame_copy_props
av_frame_free av_frame_free
av_frame_get_best_effort_timestamp
av_frame_get_buffer av_frame_get_buffer
av_frame_get_channel_layout
av_frame_get_channels
av_frame_get_color_range
av_frame_get_colorspace
av_frame_get_decode_error_flags
av_frame_get_metadata
av_frame_get_pkt_duration
av_frame_get_pkt_pos
av_frame_get_pkt_size
av_frame_get_plane_buffer av_frame_get_plane_buffer
av_frame_get_qp_table
av_frame_get_sample_rate
av_frame_get_side_data av_frame_get_side_data
av_frame_is_writable av_frame_is_writable
av_frame_make_writable av_frame_make_writable
@ -190,23 +229,12 @@ EXPORTS
av_frame_new_side_data_from_buf av_frame_new_side_data_from_buf
av_frame_ref av_frame_ref
av_frame_remove_side_data av_frame_remove_side_data
av_frame_set_best_effort_timestamp
av_frame_set_channel_layout
av_frame_set_channels
av_frame_set_color_range
av_frame_set_colorspace
av_frame_set_decode_error_flags
av_frame_set_metadata
av_frame_set_pkt_duration
av_frame_set_pkt_pos
av_frame_set_pkt_size
av_frame_set_qp_table
av_frame_set_sample_rate
av_frame_side_data_name av_frame_side_data_name
av_frame_unref av_frame_unref
av_free av_free
av_freep av_freep
av_gcd av_gcd
av_gcd_q
av_get_alt_sample_fmt av_get_alt_sample_fmt
av_get_bits_per_pixel av_get_bits_per_pixel
av_get_bytes_per_sample av_get_bytes_per_sample
@ -260,6 +288,7 @@ EXPORTS
av_hwdevice_ctx_alloc av_hwdevice_ctx_alloc
av_hwdevice_ctx_create av_hwdevice_ctx_create
av_hwdevice_ctx_create_derived av_hwdevice_ctx_create_derived
av_hwdevice_ctx_create_derived_opts
av_hwdevice_ctx_init av_hwdevice_ctx_init
av_hwdevice_find_type_by_name av_hwdevice_find_type_by_name
av_hwdevice_get_hwframe_constraints av_hwdevice_get_hwframe_constraints
@ -281,31 +310,35 @@ EXPORTS
av_image_check_size2 av_image_check_size2
av_image_copy av_image_copy
av_image_copy_plane av_image_copy_plane
av_image_copy_plane_uc_from
av_image_copy_to_buffer av_image_copy_to_buffer
av_image_copy_uc_from av_image_copy_uc_from
av_image_fill_arrays av_image_fill_arrays
av_image_fill_black av_image_fill_black
av_image_fill_linesizes av_image_fill_linesizes
av_image_fill_max_pixsteps av_image_fill_max_pixsteps
av_image_fill_plane_sizes
av_image_fill_pointers av_image_fill_pointers
av_image_get_buffer_size av_image_get_buffer_size
av_image_get_linesize av_image_get_linesize
av_int_list_length_for_size
av_int2i av_int2i
av_int_list_length_for_size
av_lfg_init av_lfg_init
av_lfg_init_from_data av_lfg_init_from_data
av_log av_log
av_log2
av_log2_16bit
av_log2_i
av_log_default_callback av_log_default_callback
av_log_format_line av_log_format_line
av_log_format_line2 av_log_format_line2
av_log_get_flags av_log_get_flags
av_log_get_level av_log_get_level
av_log_once
av_log_set_callback av_log_set_callback
av_log_set_flags av_log_set_flags
av_log_set_level av_log_set_level
av_log2 av_lzo1x_decode
av_log2_16bit
av_log2_i
av_malloc av_malloc
av_malloc_array av_malloc_array
av_mallocz av_mallocz
@ -332,7 +365,7 @@ EXPORTS
av_murmur3_init_seeded av_murmur3_init_seeded
av_murmur3_update av_murmur3_update
av_nearer_q av_nearer_q
av_opt_child_class_next av_opt_child_class_iterate
av_opt_child_next av_opt_child_next
av_opt_copy av_opt_copy
av_opt_eval_double av_opt_eval_double
@ -348,6 +381,7 @@ EXPORTS
av_opt_freep_ranges av_opt_freep_ranges
av_opt_get av_opt_get
av_opt_get_channel_layout av_opt_get_channel_layout
av_opt_get_chlayout
av_opt_get_dict_val av_opt_get_dict_val
av_opt_get_double av_opt_get_double
av_opt_get_image_size av_opt_get_image_size
@ -367,11 +401,12 @@ EXPORTS
av_opt_set av_opt_set
av_opt_set_bin av_opt_set_bin
av_opt_set_channel_layout av_opt_set_channel_layout
av_opt_set_chlayout
av_opt_set_defaults av_opt_set_defaults
av_opt_set_defaults2 av_opt_set_defaults2
av_opt_set_dict av_opt_set_dict
av_opt_set_dict_val
av_opt_set_dict2 av_opt_set_dict2
av_opt_set_dict_val
av_opt_set_double av_opt_set_double
av_opt_set_from_string av_opt_set_from_string
av_opt_set_image_size av_opt_set_image_size
@ -383,7 +418,6 @@ EXPORTS
av_opt_show2 av_opt_show2
av_parse_color av_parse_color
av_parse_cpu_caps av_parse_cpu_caps
av_parse_cpu_flags
av_parse_ratio av_parse_ratio
av_parse_time av_parse_time
av_parse_video_rate av_parse_video_rate
@ -424,19 +458,19 @@ EXPORTS
av_samples_fill_arrays av_samples_fill_arrays
av_samples_get_buffer_size av_samples_get_buffer_size
av_samples_set_silence av_samples_set_silence
av_set_cpu_flags_mask
av_set_options_string av_set_options_string
av_sha_alloc
av_sha_final
av_sha_init
av_sha_size
av_sha_update
av_sha512_alloc av_sha512_alloc
av_sha512_final av_sha512_final
av_sha512_init av_sha512_init
av_sha512_size av_sha512_size
av_sha512_update av_sha512_update
av_sha_alloc
av_sha_final
av_sha_init
av_sha_size
av_sha_update
av_shr_i av_shr_i
av_size_mult
av_small_strptime av_small_strptime
av_spherical_alloc av_spherical_alloc
av_spherical_from_name av_spherical_from_name
@ -480,11 +514,14 @@ EXPORTS
av_thread_message_queue_set_free_func av_thread_message_queue_set_free_func
av_timecode_adjust_ntsc_framenum2 av_timecode_adjust_ntsc_framenum2
av_timecode_check_frame_rate av_timecode_check_frame_rate
av_timecode_get_smpte
av_timecode_get_smpte_from_framenum av_timecode_get_smpte_from_framenum
av_timecode_init av_timecode_init
av_timecode_init_from_components
av_timecode_init_from_string av_timecode_init_from_string
av_timecode_make_mpeg_tc_string av_timecode_make_mpeg_tc_string
av_timecode_make_smpte_tc_string av_timecode_make_smpte_tc_string
av_timecode_make_smpte_tc_string2
av_timecode_make_string av_timecode_make_string
av_timegm av_timegm
av_tree_destroy av_tree_destroy
@ -497,11 +534,21 @@ EXPORTS
av_twofish_crypt av_twofish_crypt
av_twofish_init av_twofish_init
av_twofish_size av_twofish_size
av_tx_init
av_tx_uninit
av_usleep av_usleep
av_utf8_decode av_utf8_decode
av_util_ffversion av_util_ffversion
av_uuid_parse
av_uuid_parse_range
av_uuid_unparse
av_uuid_urn_parse
av_vbprintf av_vbprintf
av_version_info av_version_info
av_video_enc_params_alloc
av_video_enc_params_create_side_data
av_vk_frame_alloc
av_vkfmt_from_pixfmt
av_vlog av_vlog
av_write_image_line av_write_image_line
av_write_image_line2 av_write_image_line2
@ -517,7 +564,6 @@ EXPORTS
avpriv_get_gamma_from_trc avpriv_get_gamma_from_trc
avpriv_get_trc_function_from_trc avpriv_get_trc_function_from_trc
avpriv_init_lls avpriv_init_lls
avpriv_open
avpriv_report_missing_feature avpriv_report_missing_feature
avpriv_request_sample avpriv_request_sample
avpriv_scalarproduct_float_c avpriv_scalarproduct_float_c
@ -526,7 +572,6 @@ EXPORTS
avpriv_slicethread_execute avpriv_slicethread_execute
avpriv_slicethread_free avpriv_slicethread_free
avpriv_solve_lls avpriv_solve_lls
avpriv_tempfile
avpriv_vga16_font avpriv_vga16_font
avutil_configuration avutil_configuration
avutil_license avutil_license

BIN
ext_libs/avutil-vgmstream-57.dll Normal file
View File

Binary file not shown.

16
ext_libs/ext_libs.vcxproj
View File

@ -68,24 +68,24 @@
</Command> </Command>
<Outputs>libg719_decode.lib;libg719_decode.exp;%(Outputs)</Outputs> <Outputs>libg719_decode.lib;libg719_decode.exp;%(Outputs)</Outputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="avcodec-vgmstream-58.def"> <CustomBuild Include="avcodec-vgmstream-59.def">
<Message>Building library stub</Message> <Message>Building library stub</Message>
<Command>lib /def:avcodec-vgmstream-58.def /machine:x86 /out:avcodec.lib</Command> <Command>lib /def:avcodec-vgmstream-59.def /machine:x86 /out:avcodec.lib</Command>
<Outputs>avcodec.lib;avcodec.exp;%(Outputs)</Outputs> <Outputs>avcodec.lib;avcodec.exp;%(Outputs)</Outputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="avformat-vgmstream-58.def"> <CustomBuild Include="avformat-vgmstream-59.def">
<Message>Building library stub</Message> <Message>Building library stub</Message>
<Command>lib /def:avformat-vgmstream-58.def /machine:x86 /out:avformat.lib</Command> <Command>lib /def:avformat-vgmstream-59.def /machine:x86 /out:avformat.lib</Command>
<Outputs>avformat.lib;avformat.exp;%(Outputs)</Outputs> <Outputs>avformat.lib;avformat.exp;%(Outputs)</Outputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="avutil-vgmstream-56.def"> <CustomBuild Include="avutil-vgmstream-57.def">
<Message>Building library stub</Message> <Message>Building library stub</Message>
<Command>lib /def:avutil-vgmstream-56.def /machine:x86 /out:avutil.lib</Command> <Command>lib /def:avutil-vgmstream-57.def /machine:x86 /out:avutil.lib</Command>
<Outputs>avutil.lib;avutil.exp;%(Outputs)</Outputs> <Outputs>avutil.lib;avutil.exp;%(Outputs)</Outputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="swresample-vgmstream-3.def"> <CustomBuild Include="swresample-vgmstream-4.def">
<Message>Building library stub</Message> <Message>Building library stub</Message>
<Command>lib /def:swresample-vgmstream-3.def /machine:x86 /out:swresample.lib</Command> <Command>lib /def:swresample-vgmstream-4.def /machine:x86 /out:swresample.lib</Command>
<Outputs>swresample.lib;swresample.exp;%(Outputs)</Outputs> <Outputs>swresample.lib;swresample.exp;%(Outputs)</Outputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="libatrac9.def"> <CustomBuild Include="libatrac9.def">

3
ext_libs/ffmpeg_extra.sh
View File

@ -1,3 +1,6 @@
#!/bin/sh #!/bin/sh
# patch script for media-autobuild_suite (or apply manually)
# allows Windows XP builds of FFmpeg (may be outdated)
git apply ffmpeg-revert-bcrypt-random.patch git apply ffmpeg-revert-bcrypt-random.patch

142
ext_libs/ffmpeg_options.txt
View File

@ -1,38 +1,138 @@
# This is for the convenient https://github.com/jb-alvarado/media-autobuild_suite.git # FFMPEG OPTIONS
# options used in scripts. for full list usew "sh ./configure --help", and "sh ./configure --list-(various)"
###############################################################################
# GENERAL CONFIG
# suffix to avoid clashing with other libs (ommit or overwrite if linking to system's FFmpeg)
--build-suffix=-vgmstream --build-suffix=-vgmstream
--enable-shared
--disable-static # not very useful for vgmstream so could be disabled
#--disable-logging
# code licensing (defaults LGPLv2.1)
# enables various video-related code, and possibly some ASM optimization, hard to tell, may not be useful
# --enable-gpl
# --disable-version3
# thread would be unneeded for audio, but some FFmpeg code (libavutil/thread.h) seems to use them for mutex init
# pthreads may create a libpthread.dll dependency, w32threads seems ok, while no threads seem to work fine (uses static vars as flags)
--disable-pthreads
--disable-w32threads --disable-w32threads
--enable-gpl --disable-os2threads
# config (only need shared libs = .dll/.so)
--disable-static
--enable-shared
# programs (ffplay, ffprobe, ffmpeg), docs (*pages)
--disable-programs
--disable-doc --disable-doc
--disable-ffplay
--disable-ffprobe # components (some aren't enabled anyway but force just in case they get autodetected)
--disable-avdevice --disable-avdevice
--disable-ffmpeg --disable-swresample
--disable-swscale
--disable-postproc --disable-postproc
--disable-avfilter --disable-avfilter
--disable-swscale
--disable-network --disable-network
# individual components (re-enabled below as needed): decoders, encoder, hwaccels, demuxers, muxers, parsers, protocols, bsfs, indevs, outdevs, filters
--disable-everything
# in theory this disables most of the values below, but will include them just in case
--disable-autodetect
# these should't be used, but seems to be autodetected by /configure so disable just in case
--disable-iconv
--disable-mediafoundation
--disable-schannel
--disable-sdl2
--disable-zlib
# all these should be implicit (video hwaccels), but same thing
--disable-swscale-alpha --disable-swscale-alpha
--disable-vdpau
--disable-dxva2
--disable-amf --disable-amf
--disable-cuda --disable-cuda
--disable-cuvid
--disable-d3d11va --disable-d3d11va
--disable-dxva2
--disable-ffnvcodec --disable-ffnvcodec
--disable-nvenc --disable-nvenc
--disable-nvdec --disable-nvdec
--disable-hwaccels --disable-vdpau
--disable-sdl2
--disable-iconv # this can't be disabled, for av_get_random_seed though shouldn't be needed (maybe indirectly by asf?)
--disable-everything # Windows XP doesn't support bcrypt though, see "ffmpeg-revert-bcrypt-random.patch" if XP support is really needed
--enable-hwaccels # (--disable-random is available but seems to affect/disable a huge number of things)
# (--disable-bcrypt)
# swresample is for regular opus, probably may be disabled when using libopus
# (left in case it's needed in the future)
--enable-swresample --enable-swresample
--enable-libopus --enable-libopus
###############################################################################
# FORMATS
# use "sh ./configure --list-demuxers / --list-parser / --list-decoders" for the whole thing
# demuxers take data containers and splits into streams or frames (handles regular formats)
# - ac3,eac3,spdif: PS2/PS3 games
# - asf,xwma: Windows/X360 games
# - mov: iOS audio, iOS/Switch videos (M4A/MP4)
# - oma: PSP/PS3 demuxed videos
# - xmv: Xbox videos
# - ogg: common
# - flac: common (rare in games)
# - wav: common
# - aac: 3DS games, demuxed videos
# - mp3: common (for rare cases, shouldn't be used directly)
# - smacker,bink,binka: games with RAD Game Tools videos/audio
# - caf: iOS games
# - mpc,mpc8: Android games
# - tak,ape: extra for rips with compressed .wav
--enable-demuxer=ac3,eac3,spdif,asf,xwma,mov,oma,xmv,ogg,flac,wav,aac,mp3,smacker,bink,binka,caf,mpc,mpc8,tak,ape
# parsers take data streams and splits into frames (handles raw-ish formats)
# - ac3: raw AC3
# - mpegaudio: common
# - xma: X360 games
# - vorbis: common (for rare cases, shouldn't be used directly)
# - opus: Switch/PC games
--enable-parser=ac3,mpegaudio,xma,vorbis,opus --enable-parser=ac3,mpegaudio,xma,vorbis,opus
--enable-demuxer=ac3,asf,xwma,mov,oma,ogg,tak,dsf,wav,aac,dts,dtshd,mp3,bink,flac,msf,xmv,caf,ape,smacker,pcm_s8,spdif,mpc,mpc8
--enable-decoder=ac3,wmapro,wmav1,wmav2,wmavoice,wmalossless,xma1,xma2,dca,tak,dsd_lsbf,dsd_lsbf_planar,dsd_mbf,dsd_msbf_planar,aac,atrac3,atrac3p,mp1float,mp2float,mp3float,binkaudio_dct,binkaudio_rdft,flac,pcm_s16be,pcm_s16be_planar,pcm_s16le,pcm_s16le_planar,vorbis,ape,adpcm_ima_qt,smackaud,libopus,pcm_s8,pcm_s8_planar,mpc7,mpc8,alac,adpcm_ima_dk3,adpcm_ima_dk4 # decoders take frames and decodes (handles codecs)
--disable-parser=mpeg4video,h263 # (swap libopus with opus if needed)
--disable-decoder=mpeg2video,h263,h264,mpeg1video,mpeg2video,mpeg4,hevc,vp9 # - ac3,eac3: PS2/PS3 games
--disable-cuvid # - wmapro,wmav1,wmav2,xma1,xma2: Windows/X360 games
--disable-version3 # - aac
# - atrac3,atrac3p: PSP/PS3 games
# - mp2float,mp3float: common
# - smackaud,binkaudio_dct,binkaudio_rdft: games with RAD Game Tools videos/audio
# - pcm_s16be,pcm_s16be_planar,pcm_s16le,pcm_s16le_planar,pcm_s8,pcm_s8_planar: for .wav not detected properly in riff.c
# - flac: common (rare in games)
# - vorbis: common (for rare cases, shouldn't be used directly)
# - opus/libopus: Switch/PC games
# - mpc7,mpc8: Android games
# - alac,adpcm_ima_qt: iOS games
# - adpcm_ima_dk3,adpcm_ima_dk4: Saturn videos
# - tak,ape: extra for rips with compressed .wav
--enable-decoder=ac3,eac3,wmapro,wmav1,wmav2,xma1,xma2,aac,atrac3,atrac3p,mp2float,mp3float,smackaud,binkaudio_dct,binkaudio_rdft,pcm_s16be,pcm_s16be_planar,pcm_s16le,pcm_s16le_planar,pcm_s8,pcm_s8_planar,flac,vorbis,libopus,mpc7,mpc8,alac,adpcm_ima_qt,adpcm_ima_dk3,adpcm_ima_dk4,tak,ape
###############################################################################
# OS/TESTS
# Windows builds may need the following:
#--target-os=mingw32 --arch=x86 / --arch=x86_64 --extra-ldflags=-static-libgcc
# GCC options (probably not needed on Windows, PIC used for static libs to make shared libs also needs -Wl,-Bsymbolic)
#--enable-pic
#--extra-cflags=-fPIC
#--extra-cflags=-m32 / -m64
# if you want to test resulting config separate from the DLL, ffmpeg CLI to .wav can be enabled with:
#--enable-ffmpeg
#--enable-encoder=pcm_s16be,pcm_s16be_planar,pcm_s16le,pcm_s16le_planar
#--enable-muxer=wav
#--enable-protocol=data,file,subfile
#--enable-filter=aformat,ainterleave,aresample
#--enable-sdl2
#--extra-cflags=-g -DDEBUG

BIN
ext_libs/swresample-vgmstream-3.dll
View File

Binary file not shown.

2
ext_libs/swresample-vgmstream-3.def → ext_libs/swresample-vgmstream-4.def
View File

@ -1,7 +1,9 @@
EXPORTS EXPORTS
swr_alloc swr_alloc
swr_alloc_set_opts swr_alloc_set_opts
swr_alloc_set_opts2
swr_build_matrix swr_build_matrix
swr_build_matrix2
swr_close swr_close
swr_config_frame swr_config_frame
swr_convert swr_convert

BIN
ext_libs/swresample-vgmstream-4.dll Normal file
View File

Binary file not shown.