mirror of
https://github.com/vgmstream/vgmstream.git
synced 2024-11-12 01:30:49 +01:00
update ffmpeg
- 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:
parent
4429bb0fca
commit
86c4d81506
@ -68,67 +68,55 @@ if(USE_FFMPEG)
|
||||
if(FFMPEG_PATH)
|
||||
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
|
||||
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
|
||||
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)
|
||||
list(APPEND FFMPEG_CONF_DECODER libopus)
|
||||
else()
|
||||
list(APPEND FFMPEG_CONF_DECODER opus)
|
||||
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_DEMUXER "${FFMPEG_CONF_DEMUXER}")
|
||||
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
|
||||
--enable-static
|
||||
--disable-shared
|
||||
--enable-gpl
|
||||
--disable-version3
|
||||
--disable-programs
|
||||
--disable-doc
|
||||
--disable-ffplay
|
||||
--disable-ffprobe
|
||||
--disable-avdevice
|
||||
--disable-ffmpeg
|
||||
--disable-swscale
|
||||
--disable-postproc
|
||||
--disable-avfilter
|
||||
--disable-swscale
|
||||
--disable-network
|
||||
--disable-everything
|
||||
--disable-iconv
|
||||
--disable-mediafoundation
|
||||
--disable-schannel
|
||||
--disable-sdl2
|
||||
--disable-zlib
|
||||
--disable-swscale-alpha
|
||||
--disable-vdpau
|
||||
--disable-dxva2
|
||||
--disable-amf
|
||||
--disable-cuda
|
||||
--disable-cuvid
|
||||
--disable-dxva2
|
||||
--disable-d3d11va
|
||||
--disable-ffnvcodec
|
||||
--disable-nvenc
|
||||
--disable-nvdec
|
||||
--disable-hwaccels
|
||||
--disable-sdl2
|
||||
--disable-iconv
|
||||
--disable-everything
|
||||
--enable-hwaccels
|
||||
--enable-swresample
|
||||
--disable-vdpau
|
||||
--enable-parser=${FFMPEG_CONF_PARSER}
|
||||
--enable-demuxer=${FFMPEG_CONF_DEMUXER}
|
||||
--enable-decoder=${FFMPEG_CONF_DECODER}
|
||||
--disable-parser=${FFMPEG_CONF_DISABLE_PARSER}
|
||||
--disable-decoder=${FFMPEG_CONF_DISABLE_DECODER}
|
||||
--disable-cuvid
|
||||
--disable-version3
|
||||
--disable-zlib
|
||||
--enable-swresample
|
||||
--extra-libs=-static
|
||||
--extra-cflags=--static
|
||||
--pkg-config-flags=--static
|
||||
|
@ -151,10 +151,10 @@ macro(install_dlls INSTALL_PREFIX)
|
||||
set(VORBIS_DLL ${VGM_SOURCE_DIR}/ext_libs/libvorbis.dll)
|
||||
set(G719_DLL ${VGM_SOURCE_DIR}/ext_libs/libg719_decode.dll)
|
||||
set(FFMPEG_DLL
|
||||
${VGM_SOURCE_DIR}/ext_libs/avcodec-vgmstream-58.dll
|
||||
${VGM_SOURCE_DIR}/ext_libs/avformat-vgmstream-58.dll
|
||||
${VGM_SOURCE_DIR}/ext_libs/avutil-vgmstream-56.dll
|
||||
${VGM_SOURCE_DIR}/ext_libs/swresample-vgmstream-3.dll)
|
||||
${VGM_SOURCE_DIR}/ext_libs/avcodec-vgmstream-59.dll
|
||||
${VGM_SOURCE_DIR}/ext_libs/avformat-vgmstream-59.dll
|
||||
${VGM_SOURCE_DIR}/ext_libs/avutil-vgmstream-57.dll
|
||||
${VGM_SOURCE_DIR}/ext_libs/swresample-vgmstream-4.dll)
|
||||
set(ATRAC9_DLL ${VGM_SOURCE_DIR}/ext_libs/libatrac9.dll)
|
||||
set(CELT_DLL
|
||||
${VGM_SOURCE_DIR}/ext_libs/libcelt-0061.dll
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -67,6 +67,10 @@ typedef struct AVDCT {
|
||||
ptrdiff_t line_size);
|
||||
|
||||
int bits_per_sample;
|
||||
|
||||
void (*get_pixels_unaligned)(int16_t *block /* align 16 */,
|
||||
const uint8_t *pixels,
|
||||
ptrdiff_t line_size);
|
||||
} AVDCT;
|
||||
|
||||
/**
|
||||
|
328
ext_includes/ffmpeg/libavcodec/bsf.h
Normal file
328
ext_includes/ffmpeg/libavcodec/bsf.h
Normal 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
387
ext_includes/ffmpeg/libavcodec/codec.h
Normal 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
128
ext_includes/ffmpeg/libavcodec/codec_desc.h
Normal 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
634
ext_includes/ffmpeg/libavcodec/codec_id.h
Normal 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
246
ext_includes/ffmpeg/libavcodec/codec_par.h
Normal 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
170
ext_includes/ffmpeg/libavcodec/defs.h
Normal 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
|
@ -23,7 +23,6 @@
|
||||
|
||||
#include "libavutil/pixfmt.h"
|
||||
#include "libavutil/rational.h"
|
||||
#include "avcodec.h"
|
||||
|
||||
/* minimum number of bytes to read from a DV stream in order to
|
||||
* determine the profile */
|
||||
|
731
ext_includes/ffmpeg/libavcodec/packet.h
Normal file
731
ext_includes/ffmpeg/libavcodec/packet.h
Normal 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
|
@ -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 */
|
@ -55,7 +55,6 @@
|
||||
#include "libavutil/attributes.h"
|
||||
|
||||
#include "avcodec.h"
|
||||
#include "version.h"
|
||||
|
||||
struct AVCodecContext;
|
||||
struct AVFrame;
|
||||
@ -153,24 +152,6 @@ int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
|
||||
*/
|
||||
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 */
|
||||
|
@ -27,8 +27,9 @@
|
||||
|
||||
#include "libavutil/version.h"
|
||||
|
||||
#define LIBAVCODEC_VERSION_MAJOR 58
|
||||
#define LIBAVCODEC_VERSION_MINOR 43
|
||||
#include "version_major.h"
|
||||
|
||||
#define LIBAVCODEC_VERSION_MINOR 37
|
||||
#define LIBAVCODEC_VERSION_MICRO 100
|
||||
|
||||
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
|
||||
@ -41,97 +42,4 @@
|
||||
|
||||
#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 */
|
||||
|
54
ext_includes/ffmpeg/libavcodec/version_major.h
Normal file
54
ext_includes/ffmpeg/libavcodec/version_major.h
Normal 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 */
|
@ -27,10 +27,11 @@
|
||||
* 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 "libavutil/attributes.h"
|
||||
#include "version.h"
|
||||
#include "avcodec.h"
|
||||
|
||||
/**
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -27,12 +27,13 @@
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "libavutil/common.h"
|
||||
#include "libavutil/attributes.h"
|
||||
#include "libavutil/dict.h"
|
||||
#include "libavutil/log.h"
|
||||
|
||||
#include "libavformat/version.h"
|
||||
#include "libavformat/version_major.h"
|
||||
|
||||
/**
|
||||
* Seeking works like for a local file.
|
||||
@ -148,9 +149,9 @@ enum AVIODataMarkerType {
|
||||
|
||||
/**
|
||||
* Bytestream IO Context.
|
||||
* New fields can be added to the end with minor version bumps.
|
||||
* Removal, reordering and changes to existing fields require a major
|
||||
* version bump.
|
||||
* New public fields can be added with minor version bumps.
|
||||
* Removal, reordering and changes to existing public fields require
|
||||
* a major version bump.
|
||||
* sizeof(AVIOContext) must not be used outside libav*.
|
||||
*
|
||||
* @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 pos; /**< position in the file of the current buffer */
|
||||
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 max_packet_size;
|
||||
int min_packet_size; /**< Try to buffer at least this amount of data
|
||||
before flushing it. */
|
||||
unsigned long checksum;
|
||||
unsigned char *checksum_ptr;
|
||||
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.
|
||||
*/
|
||||
@ -259,12 +262,6 @@ typedef struct AVIOContext {
|
||||
*/
|
||||
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
|
||||
* instead of going through a buffer, and avio_seek will always
|
||||
@ -272,37 +269,6 @@ typedef struct AVIOContext {
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
@ -325,19 +291,15 @@ typedef struct AVIOContext {
|
||||
*/
|
||||
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;
|
||||
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);
|
||||
|
||||
attribute_deprecated
|
||||
int64_t written;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Maximum reached position before a backward seek in the write buffer,
|
||||
@ -346,9 +308,14 @@ typedef struct AVIOContext {
|
||||
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;
|
||||
|
||||
/**
|
||||
@ -374,25 +341,6 @@ const char *avio_find_protocol_name(const char *url);
|
||||
*/
|
||||
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.
|
||||
*
|
||||
@ -571,9 +519,35 @@ int64_t avio_size(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);
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
@ -787,6 +761,13 @@ int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
|
||||
*/
|
||||
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
|
||||
* protocol (e.g. MMS).
|
||||
|
@ -29,10 +29,9 @@
|
||||
|
||||
#include "libavutil/version.h"
|
||||
|
||||
// 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 58
|
||||
#define LIBAVFORMAT_VERSION_MINOR 25
|
||||
#include "version_major.h"
|
||||
|
||||
#define LIBAVFORMAT_VERSION_MINOR 27
|
||||
#define LIBAVFORMAT_VERSION_MICRO 100
|
||||
|
||||
#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
|
||||
@ -45,67 +44,4 @@
|
||||
|
||||
#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 */
|
||||
|
53
ext_includes/ffmpeg/libavformat/version_major.h
Normal file
53
ext_includes/ffmpeg/libavformat/version_major.h
Normal 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 */
|
@ -27,6 +27,7 @@
|
||||
#ifndef AVUTIL_ADLER32_H
|
||||
#define AVUTIL_ADLER32_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "attributes.h"
|
||||
|
||||
@ -38,6 +39,8 @@
|
||||
* @{
|
||||
*/
|
||||
|
||||
typedef uint32_t AVAdler;
|
||||
|
||||
/**
|
||||
* Calculate the Adler32 checksum of a buffer.
|
||||
*
|
||||
@ -50,8 +53,8 @@
|
||||
* @param len size of input buffer
|
||||
* @return updated checksum
|
||||
*/
|
||||
unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf,
|
||||
unsigned int len) av_pure;
|
||||
AVAdler av_adler32_update(AVAdler adler, const uint8_t *buf,
|
||||
size_t len) av_pure;
|
||||
|
||||
/**
|
||||
* @}
|
||||
|
@ -24,7 +24,6 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @defgroup lavu_aes AES
|
||||
|
@ -25,7 +25,6 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
#define AES_CTR_KEY_SIZE (16)
|
||||
#define AES_CTR_IV_SIZE (8)
|
||||
|
@ -34,6 +34,12 @@
|
||||
# define AV_GCC_VERSION_AT_MOST(x,y) 0
|
||||
#endif
|
||||
|
||||
#ifdef __has_builtin
|
||||
# define AV_HAS_BUILTIN(x) __has_builtin(x)
|
||||
#else
|
||||
# define AV_HAS_BUILTIN(x) 0
|
||||
#endif
|
||||
|
||||
#ifndef av_always_inline
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,1)
|
||||
# define av_always_inline __attribute__((always_inline)) inline
|
||||
@ -104,7 +110,7 @@
|
||||
* scheduled for removal.
|
||||
*/
|
||||
#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) \
|
||||
_Pragma("GCC diagnostic push") \
|
||||
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \
|
||||
|
@ -27,8 +27,7 @@
|
||||
#ifndef AVUTIL_AUDIO_FIFO_H
|
||||
#define AVUTIL_AUDIO_FIFO_H
|
||||
|
||||
#include "avutil.h"
|
||||
#include "fifo.h"
|
||||
#include "attributes.h"
|
||||
#include "samplefmt.h"
|
||||
|
||||
/**
|
||||
|
@ -28,8 +28,8 @@
|
||||
#define AVUTIL_AVASSERT_H
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "avutil.h"
|
||||
#include "log.h"
|
||||
#include "macros.h"
|
||||
|
||||
/**
|
||||
* assert() equivalent, that is always enabled.
|
||||
|
@ -24,6 +24,7 @@
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @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);
|
||||
|
||||
#if FF_API_D2STR
|
||||
/**
|
||||
* Convert a number to an av_malloced string.
|
||||
* @deprecated use av_asprintf() with "%f" or a more specific format
|
||||
*/
|
||||
attribute_deprecated
|
||||
char *av_d2str(double d);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Unescape the given string until a non escaped terminating char,
|
||||
@ -274,16 +279,21 @@ char *av_strireplace(const char *str, const char *from, const char *to);
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* Thread safe dirname.
|
||||
* @param path the path, on DOS both \ and / are considered separators.
|
||||
* @return the path with the separator replaced by the string terminator or ".".
|
||||
* @note the function may change the input string.
|
||||
* @param path the string to parse, on DOS both \ and / are considered separators.
|
||||
* @return A pointer to a string that's the parent directory of path.
|
||||
* 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);
|
||||
|
||||
@ -314,6 +324,7 @@ enum AVEscapeMode {
|
||||
AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode.
|
||||
AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash 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)
|
||||
|
||||
/**
|
||||
* 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
|
||||
* string in *dst, which must be freed with av_free().
|
||||
|
@ -331,12 +331,18 @@ unsigned av_int_list_length_for_size(unsigned elsize,
|
||||
#define av_int_list_length(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.
|
||||
* The API of this function matches POSIX fopen(), errors are returned through
|
||||
* 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Return the fractional representation of the internal time base.
|
||||
|
@ -25,6 +25,7 @@
|
||||
#ifndef AVUTIL_BUFFER_H
|
||||
#define AVUTIL_BUFFER_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
@ -90,7 +91,7 @@ typedef struct AVBufferRef {
|
||||
/**
|
||||
* Size of data in bytes.
|
||||
*/
|
||||
int size;
|
||||
size_t size;
|
||||
} AVBufferRef;
|
||||
|
||||
/**
|
||||
@ -98,13 +99,13 @@ typedef struct AVBufferRef {
|
||||
*
|
||||
* @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
|
||||
* 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
|
||||
@ -127,7 +128,7 @@ AVBufferRef *av_buffer_allocz(int size);
|
||||
*
|
||||
* @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 *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
|
||||
* 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
|
||||
@ -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
|
||||
* 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()).
|
||||
* @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.
|
||||
@ -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 opaque arbitrary user data used by the allocator
|
||||
* @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
|
||||
* is freed. I.e. after av_buffer_pool_uninit() is called
|
||||
* by the caller and all the frames are returned to the pool
|
||||
* 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.
|
||||
*/
|
||||
AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
|
||||
AVBufferRef* (*alloc)(void *opaque, int size),
|
||||
AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque,
|
||||
AVBufferRef* (*alloc)(void *opaque, size_t size),
|
||||
void (*pool_free)(void *opaque));
|
||||
|
||||
/**
|
||||
@ -284,6 +302,19 @@ void av_buffer_pool_uninit(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);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
@ -23,6 +23,10 @@
|
||||
#define AVUTIL_CHANNEL_LAYOUT_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "version.h"
|
||||
#include "attributes.h"
|
||||
|
||||
/**
|
||||
* @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
|
||||
*
|
||||
@ -46,36 +155,46 @@
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
#define AV_CH_FRONT_LEFT 0x00000001
|
||||
#define AV_CH_FRONT_RIGHT 0x00000002
|
||||
#define AV_CH_FRONT_CENTER 0x00000004
|
||||
#define AV_CH_LOW_FREQUENCY 0x00000008
|
||||
#define AV_CH_BACK_LEFT 0x00000010
|
||||
#define AV_CH_BACK_RIGHT 0x00000020
|
||||
#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040
|
||||
#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080
|
||||
#define AV_CH_BACK_CENTER 0x00000100
|
||||
#define AV_CH_SIDE_LEFT 0x00000200
|
||||
#define AV_CH_SIDE_RIGHT 0x00000400
|
||||
#define AV_CH_TOP_CENTER 0x00000800
|
||||
#define AV_CH_TOP_FRONT_LEFT 0x00001000
|
||||
#define AV_CH_TOP_FRONT_CENTER 0x00002000
|
||||
#define AV_CH_TOP_FRONT_RIGHT 0x00004000
|
||||
#define AV_CH_TOP_BACK_LEFT 0x00008000
|
||||
#define AV_CH_TOP_BACK_CENTER 0x00010000
|
||||
#define AV_CH_TOP_BACK_RIGHT 0x00020000
|
||||
#define AV_CH_STEREO_LEFT 0x20000000 ///< Stereo downmix.
|
||||
#define AV_CH_STEREO_RIGHT 0x40000000 ///< See AV_CH_STEREO_LEFT.
|
||||
#define AV_CH_WIDE_LEFT 0x0000000080000000ULL
|
||||
#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL
|
||||
#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL
|
||||
#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL
|
||||
#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL
|
||||
#define AV_CH_FRONT_LEFT (1ULL << AV_CHAN_FRONT_LEFT )
|
||||
#define AV_CH_FRONT_RIGHT (1ULL << AV_CHAN_FRONT_RIGHT )
|
||||
#define AV_CH_FRONT_CENTER (1ULL << AV_CHAN_FRONT_CENTER )
|
||||
#define AV_CH_LOW_FREQUENCY (1ULL << AV_CHAN_LOW_FREQUENCY )
|
||||
#define AV_CH_BACK_LEFT (1ULL << AV_CHAN_BACK_LEFT )
|
||||
#define AV_CH_BACK_RIGHT (1ULL << AV_CHAN_BACK_RIGHT )
|
||||
#define AV_CH_FRONT_LEFT_OF_CENTER (1ULL << AV_CHAN_FRONT_LEFT_OF_CENTER )
|
||||
#define AV_CH_FRONT_RIGHT_OF_CENTER (1ULL << AV_CHAN_FRONT_RIGHT_OF_CENTER)
|
||||
#define AV_CH_BACK_CENTER (1ULL << AV_CHAN_BACK_CENTER )
|
||||
#define AV_CH_SIDE_LEFT (1ULL << AV_CHAN_SIDE_LEFT )
|
||||
#define AV_CH_SIDE_RIGHT (1ULL << AV_CHAN_SIDE_RIGHT )
|
||||
#define AV_CH_TOP_CENTER (1ULL << AV_CHAN_TOP_CENTER )
|
||||
#define AV_CH_TOP_FRONT_LEFT (1ULL << AV_CHAN_TOP_FRONT_LEFT )
|
||||
#define AV_CH_TOP_FRONT_CENTER (1ULL << AV_CHAN_TOP_FRONT_CENTER )
|
||||
#define AV_CH_TOP_FRONT_RIGHT (1ULL << AV_CHAN_TOP_FRONT_RIGHT )
|
||||
#define AV_CH_TOP_BACK_LEFT (1ULL << AV_CHAN_TOP_BACK_LEFT )
|
||||
#define AV_CH_TOP_BACK_CENTER (1ULL << AV_CHAN_TOP_BACK_CENTER )
|
||||
#define AV_CH_TOP_BACK_RIGHT (1ULL << AV_CHAN_TOP_BACK_RIGHT )
|
||||
#define AV_CH_STEREO_LEFT (1ULL << AV_CHAN_STEREO_LEFT )
|
||||
#define AV_CH_STEREO_RIGHT (1ULL << AV_CHAN_STEREO_RIGHT )
|
||||
#define AV_CH_WIDE_LEFT (1ULL << AV_CHAN_WIDE_LEFT )
|
||||
#define AV_CH_WIDE_RIGHT (1ULL << AV_CHAN_WIDE_RIGHT )
|
||||
#define AV_CH_SURROUND_DIRECT_LEFT (1ULL << AV_CHAN_SURROUND_DIRECT_LEFT )
|
||||
#define AV_CH_SURROUND_DIRECT_RIGHT (1ULL << AV_CHAN_SURROUND_DIRECT_RIGHT)
|
||||
#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
|
||||
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
|
||||
#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_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_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 {
|
||||
AV_MATRIX_ENCODING_NONE,
|
||||
@ -122,6 +242,149 @@ enum AVMatrixEncoding {
|
||||
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.
|
||||
*
|
||||
@ -138,7 +401,10 @@ enum AVMatrixEncoding {
|
||||
* AV_CH_* macros).
|
||||
*
|
||||
* 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);
|
||||
|
||||
/**
|
||||
@ -152,7 +418,9 @@ uint64_t av_get_channel_layout(const char *name);
|
||||
* @param[out] nb_channels number of channels
|
||||
*
|
||||
* @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);
|
||||
|
||||
/**
|
||||
@ -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_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);
|
||||
|
||||
struct AVBPrint;
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
@ -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
|
||||
* on error.
|
||||
*
|
||||
* @deprecated use av_channel_layout_index_from_channel()
|
||||
*/
|
||||
attribute_deprecated
|
||||
int av_get_channel_layout_channel_index(uint64_t channel_layout,
|
||||
uint64_t channel);
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* Get the name of a given channel.
|
||||
*
|
||||
* @return channel name on success, NULL on error.
|
||||
*
|
||||
* @deprecated use av_channel_name()
|
||||
*/
|
||||
attribute_deprecated
|
||||
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
|
||||
* @return channel description on success, NULL on error
|
||||
* @deprecated use av_channel_description()
|
||||
*/
|
||||
attribute_deprecated
|
||||
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
|
||||
* @return 0 if the layout exists,
|
||||
* <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,
|
||||
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);
|
||||
|
||||
/**
|
||||
* @}
|
||||
|
@ -31,11 +31,7 @@
|
||||
#endif
|
||||
|
||||
#include <errno.h>
|
||||
/* modification for MSVC by kode54 */
|
||||
#ifndef _MSC_VER
|
||||
#include <inttypes.h>
|
||||
#endif
|
||||
/* end modification */
|
||||
#include <limits.h>
|
||||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
@ -45,19 +41,11 @@
|
||||
|
||||
#include "attributes.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
|
||||
#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
|
||||
/* 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 */
|
||||
#define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
|
||||
: ((a) + (1<<(b)) - 1) >> (b))
|
||||
@ -85,23 +73,13 @@
|
||||
#define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* Unsigned Absolute value.
|
||||
* This takes the absolute value of a signed int and returns it as a unsigned.
|
||||
* This also works with INT_MIN which would otherwise not be representable
|
||||
* As with many macros, this evaluates its argument twice.
|
||||
*/
|
||||
#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 FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a))
|
||||
#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a))
|
||||
|
||||
/* misc math functions */
|
||||
|
||||
@ -110,8 +88,72 @@
|
||||
# include "intmath.h"
|
||||
#endif
|
||||
|
||||
/* Pull in unguarded fallback defines at the end of this file. */
|
||||
#include "common.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_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
|
||||
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)
|
||||
{
|
||||
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));
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* If a is nan or -inf amin will be returned.
|
||||
* If a is +inf amax will be returned.
|
||||
* @param a value to clip
|
||||
* @param amin minimum 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 (amin > amax) abort();
|
||||
#endif
|
||||
if (a < amin) return amin;
|
||||
else if (a > amax) return amax;
|
||||
else return a;
|
||||
return FFMIN(FFMAX(a, amin), amax);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 amin minimum 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 (amin > amax) abort();
|
||||
#endif
|
||||
if (a < amin) return amin;
|
||||
else if (a > amax) return amax;
|
||||
else return a;
|
||||
return FFMIN(FFMAX(a, amin), amax);
|
||||
}
|
||||
|
||||
/** 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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
#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.
|
||||
*
|
||||
@ -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.
|
||||
* Evaluated up to 7 times (4 for the currently
|
||||
* 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,
|
||||
* 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;\
|
||||
if ((val & 0xc0) == 0x80 || val >= 0xFE)\
|
||||
ERROR\
|
||||
{ERROR}\
|
||||
while (val & top) {\
|
||||
int tmp= (GET_BYTE) - 128;\
|
||||
unsigned int tmp = (GET_BYTE) - 128;\
|
||||
if(tmp>>6)\
|
||||
ERROR\
|
||||
{ERROR}\
|
||||
val= (val<<6) + tmp;\
|
||||
top <<= 5;\
|
||||
}\
|
||||
@ -412,13 +492,13 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
|
||||
* typically a goto statement.
|
||||
*/
|
||||
#define GET_UTF16(val, GET_16BIT, ERROR)\
|
||||
val = GET_16BIT;\
|
||||
val = (GET_16BIT);\
|
||||
{\
|
||||
unsigned int hi = val - 0xD800;\
|
||||
if (hi < 0x800) {\
|
||||
val = GET_16BIT - 0xDC00;\
|
||||
val = (GET_16BIT) - 0xDC00;\
|
||||
if (val > 0x3FFU || hi > 0x3FFU)\
|
||||
ERROR\
|
||||
{ERROR}\
|
||||
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 /* 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
|
||||
|
@ -23,8 +23,6 @@
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "attributes.h"
|
||||
|
||||
#define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */
|
||||
|
||||
/* lower 16 bits - CPU features */
|
||||
@ -56,6 +54,8 @@
|
||||
#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_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_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_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.
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
@ -116,6 +104,12 @@ int av_parse_cpu_caps(unsigned *flags, const char *s);
|
||||
*/
|
||||
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.
|
||||
*
|
||||
|
@ -30,7 +30,6 @@
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @defgroup lavu_crc32 CRC
|
||||
|
106
ext_includes/ffmpeg/libavutil/csp.h
Normal file
106
ext_includes/ffmpeg/libavutil/csp.h
Normal 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
107
ext_includes/ffmpeg/libavutil/detection_bbox.h
Normal 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
|
@ -32,8 +32,6 @@
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @addtogroup lavu_dict AVDictionary
|
||||
* @ingroup lavu_data
|
||||
|
@ -27,7 +27,6 @@
|
||||
#define AVUTIL_DISPLAY_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "common.h"
|
||||
|
||||
/**
|
||||
* @addtogroup lavu_video
|
||||
@ -88,7 +87,7 @@
|
||||
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).
|
||||
*
|
||||
* @param matrix an allocated transformation matrix (will be fully overwritten
|
||||
|
236
ext_includes/ffmpeg/libavutil/dovi_meta.h
Normal file
236
ext_includes/ffmpeg/libavutil/dovi_meta.h
Normal 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 */
|
@ -27,6 +27,8 @@
|
||||
#include <errno.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include "macros.h"
|
||||
|
||||
/**
|
||||
* @addtogroup lavu_error
|
||||
*
|
||||
|
@ -26,8 +26,6 @@
|
||||
#ifndef AVUTIL_EVAL_H
|
||||
#define AVUTIL_EVAL_H
|
||||
|
||||
#include "avutil.h"
|
||||
|
||||
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);
|
||||
|
||||
/**
|
||||
* 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().
|
||||
*/
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Automatically generated by version.sh, do not manually edit! */
|
||||
#ifndef AVUTIL_FFVERSION_H
|
||||
#define AVUTIL_FFVERSION_H
|
||||
#define FFMPEG_VERSION "N-92936-ged3b64402e"
|
||||
#define FFMPEG_VERSION "n5.1.2"
|
||||
#endif /* AVUTIL_FFVERSION_H */
|
||||
|
@ -24,10 +24,205 @@
|
||||
#ifndef AVUTIL_FIFO_H
|
||||
#define AVUTIL_FIFO_H
|
||||
|
||||
#include <stddef.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 {
|
||||
uint8_t *buffer;
|
||||
uint8_t *rptr, *wptr, *end;
|
||||
@ -38,7 +233,9 @@ typedef struct AVFifoBuffer {
|
||||
* Initialize an AVFifoBuffer.
|
||||
* @param size of FIFO
|
||||
* @return AVFifoBuffer or NULL in case of memory allocation failure
|
||||
* @deprecated use av_fifo_alloc2()
|
||||
*/
|
||||
attribute_deprecated
|
||||
AVFifoBuffer *av_fifo_alloc(unsigned int size);
|
||||
|
||||
/**
|
||||
@ -46,25 +243,33 @@ AVFifoBuffer *av_fifo_alloc(unsigned int size);
|
||||
* @param nmemb number of elements
|
||||
* @param size size of the single element
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* Free an AVFifoBuffer.
|
||||
* @param f AVFifoBuffer to free
|
||||
* @deprecated use the AVFifo API with av_fifo_freep2()
|
||||
*/
|
||||
attribute_deprecated
|
||||
void av_fifo_free(AVFifoBuffer *f);
|
||||
|
||||
/**
|
||||
* Free an AVFifoBuffer and reset pointer to NULL.
|
||||
* @param f AVFifoBuffer to free
|
||||
* @deprecated use the AVFifo API with av_fifo_freep2()
|
||||
*/
|
||||
attribute_deprecated
|
||||
void av_fifo_freep(AVFifoBuffer **f);
|
||||
|
||||
/**
|
||||
* Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
|
||||
* @param f AVFifoBuffer to reset
|
||||
* @deprecated use av_fifo_reset2() with the new AVFifo-API
|
||||
*/
|
||||
attribute_deprecated
|
||||
void av_fifo_reset(AVFifoBuffer *f);
|
||||
|
||||
/**
|
||||
@ -72,7 +277,9 @@ void av_fifo_reset(AVFifoBuffer *f);
|
||||
* amount of data you can read from it.
|
||||
* @param f AVFifoBuffer to read from
|
||||
* @return size
|
||||
* @deprecated use av_fifo_can_read() with the new AVFifo-API
|
||||
*/
|
||||
attribute_deprecated
|
||||
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.
|
||||
* @param f AVFifoBuffer to write into
|
||||
* @return size
|
||||
* @deprecated use av_fifo_can_write() with the new AVFifo-API
|
||||
*/
|
||||
attribute_deprecated
|
||||
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 func generic read function
|
||||
* @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));
|
||||
|
||||
/**
|
||||
@ -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 func generic read function
|
||||
* @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));
|
||||
|
||||
/**
|
||||
@ -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 func generic read function
|
||||
* @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));
|
||||
|
||||
/**
|
||||
@ -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
|
||||
* indicate no more data available to write.
|
||||
* 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));
|
||||
|
||||
/**
|
||||
@ -135,7 +366,11 @@ int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void
|
||||
* @param f AVFifoBuffer to resize
|
||||
* @param size new AVFifoBuffer size in bytes
|
||||
* @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);
|
||||
|
||||
/**
|
||||
@ -146,16 +381,24 @@ int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
|
||||
* @param f AVFifoBuffer to resize
|
||||
* @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size()
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* Read and discard the specified amount of data from an AVFifoBuffer.
|
||||
* @param f AVFifoBuffer to read from
|
||||
* @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);
|
||||
|
||||
#if FF_API_FIFO_PEEK2
|
||||
/**
|
||||
* Return a pointer to the data stored in a FIFO buffer at a certain offset.
|
||||
* 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
|
||||
* point outside to the buffer data.
|
||||
* 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)
|
||||
{
|
||||
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);
|
||||
return ptr;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* AVUTIL_FIFO_H */
|
||||
|
@ -19,9 +19,10 @@
|
||||
#ifndef AVUTIL_FILE_H
|
||||
#define AVUTIL_FILE_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "avutil.h"
|
||||
#include "attributes.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
|
260
ext_includes/ffmpeg/libavutil/film_grain_params.h
Normal file
260
ext_includes/ffmpeg/libavutil/film_grain_params.h
Normal 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 */
|
@ -30,6 +30,7 @@
|
||||
|
||||
#include "avutil.h"
|
||||
#include "buffer.h"
|
||||
#include "channel_layout.h"
|
||||
#include "dict.h"
|
||||
#include "rational.h"
|
||||
#include "samplefmt.h"
|
||||
@ -142,28 +143,11 @@ enum AVFrameSideDataType {
|
||||
*/
|
||||
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
|
||||
* 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()
|
||||
* function in libavutil/timecode.c.
|
||||
* The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
|
||||
* function in libavutil/timecode.h.
|
||||
*/
|
||||
AV_FRAME_DATA_S12M_TIMECODE,
|
||||
|
||||
@ -173,6 +157,58 @@ enum AVFrameSideDataType {
|
||||
* volume transform - application 4 of SMPTE 2094-40:2016 standard.
|
||||
*/
|
||||
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 {
|
||||
@ -195,11 +231,67 @@ enum AVActiveFormatDescription {
|
||||
typedef struct AVFrameSideData {
|
||||
enum AVFrameSideDataType type;
|
||||
uint8_t *data;
|
||||
int size;
|
||||
size_t size;
|
||||
AVDictionary *metadata;
|
||||
AVBufferRef *buf;
|
||||
} 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.
|
||||
*
|
||||
@ -234,21 +326,32 @@ typedef struct AVFrame {
|
||||
#define AV_NUM_DATA_POINTERS 8
|
||||
/**
|
||||
* 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
|
||||
* see avcodec_align_dimensions2(). Some filters and swscale can read
|
||||
* up to 16 bytes beyond the planes, if these filters are to be used,
|
||||
* then 16 extra bytes must be allocated.
|
||||
*
|
||||
* NOTE: Except for hwaccel formats, pointers not needed by the format
|
||||
* MUST be set to NULL.
|
||||
* NOTE: Pointers not needed by the format 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];
|
||||
|
||||
/**
|
||||
* For video, size in bytes of each picture line.
|
||||
* For audio, size in bytes of each plane.
|
||||
* For video, a positive or negative value, which is typically indicating
|
||||
* 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
|
||||
* 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
|
||||
* 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];
|
||||
|
||||
@ -325,15 +431,6 @@ typedef struct AVFrame {
|
||||
*/
|
||||
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)
|
||||
* This is also the Presentation time of this AVFrame calculated from
|
||||
@ -341,6 +438,14 @@ typedef struct AVFrame {
|
||||
*/
|
||||
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
|
||||
*/
|
||||
@ -360,14 +465,6 @@ typedef struct AVFrame {
|
||||
*/
|
||||
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.
|
||||
* extra_delay = repeat_pict / (2*fps)
|
||||
@ -404,16 +501,20 @@ typedef struct AVFrame {
|
||||
*/
|
||||
int sample_rate;
|
||||
|
||||
#if FF_API_OLD_CHANNEL_LAYOUT
|
||||
/**
|
||||
* Channel layout of the audio data.
|
||||
* @deprecated use ch_layout instead
|
||||
*/
|
||||
attribute_deprecated
|
||||
uint64_t channel_layout;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* AVBuffer references backing the data for this frame. If all elements of
|
||||
* this array are NULL, then this frame is not reference counted. This array
|
||||
* must be filled contiguously -- if buf[i] is non-NULL then buf[j] must
|
||||
* also be non-NULL for all j < i.
|
||||
* AVBuffer references backing the data for this frame. All the pointers in
|
||||
* data and extended_data must point inside one of the buffers in buf or
|
||||
* extended_buf. This array must be filled contiguously -- if buf[i] is
|
||||
* 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
|
||||
* always contains all the references. For planar audio with more than
|
||||
@ -528,13 +629,19 @@ typedef struct AVFrame {
|
||||
int decode_error_flags;
|
||||
#define FF_DECODE_ERROR_INVALID_BITSTREAM 1
|
||||
#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.
|
||||
* - encoding: unused
|
||||
* - decoding: Read by user.
|
||||
* @deprecated use ch_layout instead
|
||||
*/
|
||||
attribute_deprecated
|
||||
int channels;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* size of the corresponding packet containing the compressed
|
||||
@ -545,24 +652,6 @@ typedef struct AVFrame {
|
||||
*/
|
||||
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
|
||||
* AVHWFramesContext describing the frame.
|
||||
@ -608,71 +697,23 @@ typedef struct AVFrame {
|
||||
* for the target frame's private_ref field.
|
||||
*/
|
||||
AVBufferRef *private_ref;
|
||||
|
||||
/**
|
||||
* Channel layout of the audio data.
|
||||
*/
|
||||
AVChannelLayout ch_layout;
|
||||
} 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.
|
||||
* @return a static string identifying the colorspace; can be NULL.
|
||||
* @deprecated use av_color_space_name()
|
||||
*/
|
||||
attribute_deprecated
|
||||
const char *av_get_colorspace_name(enum AVColorSpace val);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Allocate an AVFrame and set its fields to default values. The resulting
|
||||
* 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:
|
||||
* - format (pixel format for video, sample format for audio)
|
||||
* - 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
|
||||
* 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,
|
||||
enum AVFrameSideDataType type,
|
||||
int size);
|
||||
size_t size);
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* If side data of the supplied type exists in the frame, free it and remove it
|
||||
* from the frame.
|
||||
* Remove and free all side data instances of the given type.
|
||||
*/
|
||||
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
|
||||
|
||||
|
@ -27,10 +27,9 @@
|
||||
#ifndef AVUTIL_HASH_H
|
||||
#define AVUTIL_HASH_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @defgroup lavu_hash Hash Functions
|
||||
* @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] 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Finalize a hash context and compute the actual hash value.
|
||||
|
285
ext_includes/ffmpeg/libavutil/hdr_dynamic_vivid_metadata.h
Normal file
285
ext_includes/ffmpeg/libavutil/hdr_dynamic_vivid_metadata.h
Normal 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 */
|
@ -23,7 +23,6 @@
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "version.h"
|
||||
/**
|
||||
* @defgroup lavu_hmac HMAC
|
||||
* @ingroup lavu_crypto
|
||||
|
@ -36,6 +36,7 @@ enum AVHWDeviceType {
|
||||
AV_HWDEVICE_TYPE_DRM,
|
||||
AV_HWDEVICE_TYPE_OPENCL,
|
||||
AV_HWDEVICE_TYPE_MEDIACODEC,
|
||||
AV_HWDEVICE_TYPE_VULKAN,
|
||||
};
|
||||
|
||||
typedef struct AVHWDeviceInternal AVHWDeviceInternal;
|
||||
@ -327,6 +328,26 @@ int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx,
|
||||
enum AVHWDeviceType type,
|
||||
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.
|
||||
@ -550,6 +571,10 @@ enum {
|
||||
* possible with the given arguments and hwframe setup, while other return
|
||||
* 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 src Source frame, to be mapped.
|
||||
* @param flags Some combination of AV_HWFRAME_MAP_* flags.
|
||||
|
@ -49,4 +49,21 @@ typedef struct AVCUDADeviceContext {
|
||||
* 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 */
|
||||
|
@ -164,6 +164,15 @@ typedef struct AVD3D11VAFramesContext {
|
||||
* This field is ignored/invalid if a user-allocated texture is provided.
|
||||
*/
|
||||
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;
|
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_D3D11VA_H */
|
||||
|
100
ext_includes/ffmpeg/libavutil/hwcontext_opencl.h
Normal file
100
ext_includes/ffmpeg/libavutil/hwcontext_opencl.h
Normal 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 */
|
@ -29,11 +29,14 @@
|
||||
* @file
|
||||
* An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
|
||||
*
|
||||
* This API currently does not support frame allocation, as the raw VideoToolbox
|
||||
* API does allocation, and FFmpeg itself never has the need to allocate frames.
|
||||
* This API supports frame allocation using a native CVPixelBufferPool
|
||||
* instead of an AVBufferPool.
|
||||
*
|
||||
* If the API user sets a custom pool, AVHWFramesContext.pool must return
|
||||
* 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
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* 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 */
|
||||
|
281
ext_includes/ffmpeg/libavutil/hwcontext_vulkan.h
Normal file
281
ext_includes/ffmpeg/libavutil/hwcontext_vulkan.h
Normal 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 */
|
@ -27,8 +27,10 @@
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include "avutil.h"
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "pixdesc.h"
|
||||
#include "pixfmt.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);
|
||||
|
||||
/**
|
||||
* 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
|
||||
* height height.
|
||||
@ -110,6 +126,24 @@ void av_image_copy_plane(uint8_t *dst, int dst_linesize,
|
||||
const uint8_t *src, int src_linesize,
|
||||
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.
|
||||
*
|
||||
|
@ -542,6 +542,21 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
|
||||
# define AV_WN64A(p, v) AV_WNA(64, p, v)
|
||||
#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
|
||||
* memory locations.
|
||||
|
@ -24,6 +24,12 @@
|
||||
|
||||
#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 {
|
||||
unsigned int state[64];
|
||||
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.
|
||||
*/
|
||||
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];
|
||||
return c->state[c->index++ & 63];
|
||||
unsigned a = c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 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){
|
||||
unsigned int a= c->state[(c->index-55) & 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;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -22,7 +22,6 @@
|
||||
#define AVUTIL_LOG_H
|
||||
|
||||
#include <stdarg.h>
|
||||
#include "avutil.h"
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
@ -107,21 +106,6 @@ typedef struct AVClass {
|
||||
*/
|
||||
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)
|
||||
* 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)
|
||||
*/
|
||||
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;
|
||||
|
||||
/**
|
||||
@ -233,6 +237,27 @@ typedef struct AVClass {
|
||||
*/
|
||||
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
|
||||
|
66
ext_includes/ffmpeg/libavutil/lzo.h
Normal file
66
ext_includes/ffmpeg/libavutil/lzo.h
Normal 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 */
|
@ -25,6 +25,36 @@
|
||||
#ifndef 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
|
||||
*
|
||||
|
@ -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
|
||||
* 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()
|
||||
*/
|
||||
|
@ -31,7 +31,6 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @defgroup lavu_md5 MD5
|
||||
@ -64,11 +63,7 @@ void av_md5_init(struct AVMD5 *ctx);
|
||||
* @param src input data to update hash with
|
||||
* @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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* 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 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @}
|
||||
|
@ -31,8 +31,8 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "error.h"
|
||||
#include "avutil.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @addtogroup lavu_mem
|
||||
@ -49,6 +49,10 @@
|
||||
* dealing with memory consistently possible on all platforms.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
#if FF_API_DECLARE_ALIGNED
|
||||
/**
|
||||
*
|
||||
* @defgroup lavu_mem_macros Alignment Macros
|
||||
* Helper macros for declaring aligned variables.
|
||||
@ -125,6 +129,7 @@
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @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_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().
|
||||
*
|
||||
* Created for symmetry with the calloc() C function.
|
||||
* @deprecated use av_calloc()
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* If `ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is
|
||||
* zero, free the memory block pointed to by `ptr`. Otherwise, expand or
|
||||
* If `ptr` is `NULL` and `size` > 0, allocate a new block. Otherwise, expand or
|
||||
* shrink that block of memory according to `size`.
|
||||
*
|
||||
* @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
|
||||
*
|
||||
* @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
|
||||
* correctly aligned.
|
||||
* correctly aligned. The returned pointer must be freed after even
|
||||
* if size is zero.
|
||||
* @see av_fast_realloc()
|
||||
* @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.
|
||||
*
|
||||
* If `ptr` is `NULL` and `nmemb` > 0, allocate a new block. If
|
||||
* `nmemb` is zero, free the memory block pointed to by `ptr`.
|
||||
* If `ptr` is `NULL` and `nmemb` > 0, allocate a new block.
|
||||
*
|
||||
* @param ptr Pointer to a memory block already allocated with
|
||||
* 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
|
||||
*
|
||||
* @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
|
||||
* correctly aligned.
|
||||
* correctly aligned. The returned pointer must be freed after even if
|
||||
* nmemb is zero.
|
||||
* @see av_reallocp_array()
|
||||
*/
|
||||
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
|
||||
* zero, free the memory block pointed to by `*ptr`.
|
||||
* If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block.
|
||||
*
|
||||
* @param[in,out] ptr Pointer to a pointer to a memory block already
|
||||
* 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
|
||||
*
|
||||
* @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);
|
||||
|
||||
@ -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
|
||||
* @return 0 on success, AVERROR(EINVAL) on overflow
|
||||
*/
|
||||
static inline 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;
|
||||
}
|
||||
int av_size_mult(size_t a, size_t b, size_t *r);
|
||||
|
||||
/**
|
||||
* Set the maximum size that may be allocated in one block.
|
||||
|
@ -27,10 +27,9 @@
|
||||
#ifndef AVUTIL_MURMUR3_H
|
||||
#define AVUTIL_MURMUR3_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @defgroup lavu_murmur3 Murmur3
|
||||
* @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] 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Finish hashing and output digest value.
|
||||
|
@ -29,11 +29,11 @@
|
||||
|
||||
#include "rational.h"
|
||||
#include "avutil.h"
|
||||
#include "channel_layout.h"
|
||||
#include "dict.h"
|
||||
#include "log.h"
|
||||
#include "pixfmt.h"
|
||||
#include "samplefmt.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @defgroup avoptions AVOptions
|
||||
@ -114,7 +114,7 @@
|
||||
* libavcodec exports generic options, while its priv_data field exports
|
||||
* 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
|
||||
* 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.
|
||||
* Assuming that the test_struct from above now also contains a
|
||||
* child_struct field:
|
||||
@ -143,23 +143,25 @@
|
||||
* return t->child_struct;
|
||||
* 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
|
||||
* 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_struct (again, proper setup as described above needs to be done on
|
||||
* child_struct right after it is created).
|
||||
*
|
||||
* 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()
|
||||
* iterates over actually existing objects, while child_class_next()
|
||||
* and child_class_iterate() are needed. The distinction is that child_next()
|
||||
* iterates over actually existing objects, while child_class_iterate()
|
||||
* iterates over all possible child classes. E.g. if an AVCodecContext
|
||||
* was initialized to use a codec which has private options, then its
|
||||
* 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.
|
||||
*
|
||||
* @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
|
||||
* get all options that may potentially exist on the struct and its children
|
||||
* (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
|
||||
* 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
|
||||
@ -236,8 +238,11 @@ enum AVOptionType{
|
||||
AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational
|
||||
AV_OPT_TYPE_DURATION,
|
||||
AV_OPT_TYPE_COLOR,
|
||||
#if FF_API_OLD_CHANNEL_LAYOUT
|
||||
AV_OPT_TYPE_CHANNEL_LAYOUT,
|
||||
#endif
|
||||
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_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_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
|
||||
|
||||
/**
|
||||
@ -647,10 +654,10 @@ void *av_opt_child_next(void *obj, void *prev);
|
||||
/**
|
||||
* 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
|
||||
*/
|
||||
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
|
||||
@ -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
|
||||
* with '+' causes it to be set without affecting the other flags;
|
||||
* 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
|
||||
* 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_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);
|
||||
#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);
|
||||
#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
|
||||
* 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 if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has
|
||||
* AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set
|
||||
* to NULL instead of an allocated empty string.
|
||||
* @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the
|
||||
* option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT
|
||||
* 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_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_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);
|
||||
#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);
|
||||
#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
|
||||
* 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.
|
||||
*
|
||||
* 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.
|
||||
* 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 src Object to copy into
|
||||
* @return 0 on success, negative on error
|
||||
|
@ -22,15 +22,10 @@
|
||||
#ifndef AVUTIL_PIXDESC_H
|
||||
#define AVUTIL_PIXDESC_H
|
||||
|
||||
/* modification for MSVC by kode54 */
|
||||
#ifndef _MSC_VER
|
||||
#include <inttypes.h>
|
||||
#endif
|
||||
/* end modification */
|
||||
|
||||
#include "attributes.h"
|
||||
#include "pixfmt.h"
|
||||
#include "version.h"
|
||||
|
||||
typedef struct AVComponentDescriptor {
|
||||
/**
|
||||
@ -60,17 +55,6 @@ typedef struct AVComponentDescriptor {
|
||||
* Number of bits in the component.
|
||||
*/
|
||||
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;
|
||||
|
||||
/**
|
||||
@ -151,24 +135,6 @@ typedef struct AVPixFmtDescriptor {
|
||||
*/
|
||||
#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
|
||||
* support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always
|
||||
|
@ -21,7 +21,6 @@
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "common.h"
|
||||
|
||||
/**
|
||||
* Sum of abs(src1[x] - src2[x])
|
||||
|
@ -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_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
|
||||
* VASurfaceID.
|
||||
*/
|
||||
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_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_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_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_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_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_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_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_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */
|
||||
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_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_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_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_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_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
|
||||
|
||||
#if FF_API_XVMC
|
||||
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_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_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
|
||||
};
|
||||
|
||||
@ -433,33 +455,43 @@ enum AVPixelFormat {
|
||||
#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_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.
|
||||
* 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 {
|
||||
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_RESERVED = 3,
|
||||
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_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_BT2020 = 9, ///< ITU-R BT2020
|
||||
AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
|
||||
AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
|
||||
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_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
|
||||
};
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
AVCOL_TRC_RESERVED0 = 0,
|
||||
@ -488,18 +520,18 @@ enum AVColorTransferCharacteristic {
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
|
||||
AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
|
||||
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 / derived in SMPTE RP 177 Annex B
|
||||
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_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_SMPTE240M = 7, ///< functionally identical to above
|
||||
AVCOL_SPC_YCGCO = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
|
||||
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, ///< 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_YCOCG = AVCOL_SPC_YCGCO,
|
||||
AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-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 {
|
||||
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
|
||||
};
|
||||
|
||||
|
@ -207,6 +207,12 @@ int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
|
||||
*/
|
||||
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);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
@ -28,10 +28,10 @@
|
||||
#ifndef AVUTIL_RIPEMD_H
|
||||
#define AVUTIL_RIPEMD_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @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 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Finish hashing and output digest value.
|
||||
|
@ -21,9 +21,6 @@
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "avutil.h"
|
||||
#include "attributes.h"
|
||||
|
||||
/**
|
||||
* @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 sample_fmt the sample format
|
||||
* @param align buffer size alignment (0 = default, 1 = no alignment)
|
||||
* @return >=0 on success or a negative error code on failure
|
||||
* @todo return minimum size in bytes required for the buffer in case
|
||||
* of success at the next bump
|
||||
* @return minimum size in bytes required for the buffer on success,
|
||||
* or a negative error code on failure
|
||||
*/
|
||||
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
|
||||
const uint8_t *buf,
|
||||
|
@ -31,7 +31,6 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @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 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Finish hashing and output digest value.
|
||||
|
@ -32,7 +32,6 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @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 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);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Finish hashing and output digest value.
|
||||
|
@ -49,9 +49,9 @@ typedef struct {
|
||||
* Adjust frame number for NTSC drop frame time code.
|
||||
*
|
||||
* @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
|
||||
* @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);
|
||||
|
||||
@ -62,14 +62,39 @@ int av_timecode_adjust_ntsc_framenum2(int framenum, int fps);
|
||||
* @param framenum frame number
|
||||
* @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,
|
||||
* you do NOT have to call av_timecode_adjust_ntsc_framenum2().
|
||||
* @note The frame number is relative to tc->start.
|
||||
* @note Color frame (CF), binary group flags (BGF) and biphase mark polarity
|
||||
* correction (PC) bits are set to zero.
|
||||
* @note Color frame (CF) and binary group flags (BGF) bits are set to zero.
|
||||
*/
|
||||
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.
|
||||
*
|
||||
@ -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);
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
@ -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);
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
|
@ -28,7 +28,6 @@
|
||||
#define AVUTIL_TREE_H
|
||||
|
||||
#include "attributes.h"
|
||||
#include "version.h"
|
||||
|
||||
/**
|
||||
* @addtogroup lavu_tree AVTree
|
||||
|
161
ext_includes/ffmpeg/libavutil/tx.h
Normal file
161
ext_includes/ffmpeg/libavutil/tx.h
Normal 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
147
ext_includes/ffmpeg/libavutil/uuid.h
Normal 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 */
|
@ -78,8 +78,8 @@
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define LIBAVUTIL_VERSION_MAJOR 56
|
||||
#define LIBAVUTIL_VERSION_MINOR 25
|
||||
#define LIBAVUTIL_VERSION_MAJOR 57
|
||||
#define LIBAVUTIL_VERSION_MINOR 28
|
||||
#define LIBAVUTIL_VERSION_MICRO 100
|
||||
|
||||
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
|
||||
@ -105,31 +105,15 @@
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef FF_API_VAAPI
|
||||
#define FF_API_VAAPI (LIBAVUTIL_VERSION_MAJOR < 57)
|
||||
#endif
|
||||
#ifndef FF_API_FRAME_QP
|
||||
#define FF_API_FRAME_QP (LIBAVUTIL_VERSION_MAJOR < 57)
|
||||
#endif
|
||||
#ifndef FF_API_PLUS1_MINUS1
|
||||
#define FF_API_PLUS1_MINUS1 (LIBAVUTIL_VERSION_MAJOR < 57)
|
||||
#endif
|
||||
#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
|
||||
|
||||
#define FF_API_D2STR (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_DECLARE_ALIGNED (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_COLORSPACE_NAME (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_AV_MALLOCZ_ARRAY (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_FIFO_PEEK2 (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_FIFO_OLD_API (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_OLD_CHANNEL_LAYOUT (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
#define FF_API_AV_FOPEN_UTF8 (LIBAVUTIL_VERSION_MAJOR < 58)
|
||||
|
||||
/**
|
||||
* @}
|
||||
|
171
ext_includes/ffmpeg/libavutil/video_enc_params.h
Normal file
171
ext_includes/ffmpeg/libavutil/video_enc_params.h
Normal 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 */
|
@ -34,11 +34,11 @@
|
||||
* Audio resampling, sample format conversion and mixing library.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* 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.
|
||||
* The latter function provides the same feature, but it allows you to set some
|
||||
* common options in the same statement.
|
||||
@ -57,13 +57,14 @@
|
||||
* av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
|
||||
* @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
|
||||
* SwrContext *swr = swr_alloc_set_opts(NULL, // we're allocating a new context
|
||||
* AV_CH_LAYOUT_STEREO, // out_ch_layout
|
||||
* SwrContext *swr = NULL;
|
||||
* 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
|
||||
* 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
|
||||
* 48000, // in_sample_rate
|
||||
* 0, // log_offset
|
||||
@ -73,7 +74,7 @@
|
||||
* 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
|
||||
* 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.
|
||||
*
|
||||
* The conversion itself is done by repeatedly calling swr_convert().
|
||||
@ -124,7 +125,13 @@
|
||||
#include "libavutil/frame.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"
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @name Option constants
|
||||
@ -199,9 +206,9 @@ const AVClass *swr_get_class(void);
|
||||
* Allocate SwrContext.
|
||||
*
|
||||
* 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
|
||||
*/
|
||||
struct SwrContext *swr_alloc(void);
|
||||
@ -227,6 +234,7 @@ int swr_init(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.
|
||||
*
|
||||
@ -246,12 +254,41 @@ int swr_is_initialized(struct SwrContext *s);
|
||||
*
|
||||
* @see swr_init(), swr_free()
|
||||
* @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,
|
||||
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,
|
||||
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);
|
||||
|
||||
#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.
|
||||
*
|
||||
@ -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
|
||||
* @return 0 on success, negative AVERROR code on failure
|
||||
*/
|
||||
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);
|
||||
int swr_build_matrix2(const AVChannelLayout *in_layout, const AVChannelLayout *out_layout,
|
||||
double center_mix_level, double surround_mix_level,
|
||||
double lfe_mix_level, double maxval,
|
||||
double rematrix_volume, double *matrix,
|
||||
ptrdiff_t stride, enum AVMatrixEncoding matrix_encoding,
|
||||
void *log_context);
|
||||
|
||||
/**
|
||||
* Set a customized remix matrix.
|
||||
|
@ -26,10 +26,11 @@
|
||||
* Libswresample version macros
|
||||
*/
|
||||
|
||||
#include "libavutil/avutil.h"
|
||||
#include "libavutil/version.h"
|
||||
|
||||
#define LIBSWRESAMPLE_VERSION_MAJOR 3
|
||||
#define LIBSWRESAMPLE_VERSION_MINOR 4
|
||||
#include "version_major.h"
|
||||
|
||||
#define LIBSWRESAMPLE_VERSION_MINOR 7
|
||||
#define LIBSWRESAMPLE_VERSION_MICRO 100
|
||||
|
||||
#define LIBSWRESAMPLE_VERSION_INT AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \
|
||||
|
31
ext_includes/ffmpeg/libswresample/version_major.h
Normal file
31
ext_includes/ffmpeg/libswresample/version_major.h
Normal 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 */
|
@ -40,20 +40,20 @@ if(MSVC)
|
||||
if(USE_FFMPEG AND NOT FFMPEG_LIBRARIES)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib ${CMAKE_CURRENT_BINARY_DIR}/avcodec.exp
|
||||
COMMAND lib
|
||||
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def)
|
||||
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-59.def)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib ${CMAKE_CURRENT_BINARY_DIR}/avformat.exp
|
||||
COMMAND lib
|
||||
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avformat.lib
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def)
|
||||
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-59.def)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib ${CMAKE_CURRENT_BINARY_DIR}/avutil.exp
|
||||
COMMAND lib
|
||||
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/avutil.lib
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def)
|
||||
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-57.def)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib ${CMAKE_CURRENT_BINARY_DIR}/swresample.exp
|
||||
COMMAND lib
|
||||
ARGS /def:${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def /machine:x86 /out:${CMAKE_CURRENT_BINARY_DIR}/swresample.lib
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def)
|
||||
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-4.def)
|
||||
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 AVUTIL_HEADERS "${VGM_SOURCE_DIR}/ext_includes/ffmpeg/libavutil/*.h")
|
||||
@ -147,20 +147,20 @@ elseif(MINGW)
|
||||
if(USE_FFMPEG AND NOT FFMPEG_LIBRARIES)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib
|
||||
COMMAND ${DLLTOOL}
|
||||
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def -l ${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib -D avcodec-vgmstream-58.dll
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avcodec-vgmstream-58.def)
|
||||
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-59.def)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib
|
||||
COMMAND ${DLLTOOL}
|
||||
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def -l ${CMAKE_CURRENT_BINARY_DIR}/avformat.lib -D avformat-vgmstream-58.dll
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avformat-vgmstream-58.def)
|
||||
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-59.def)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib
|
||||
COMMAND ${DLLTOOL}
|
||||
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def -l ${CMAKE_CURRENT_BINARY_DIR}/avutil.lib -D avutil-vgmstream-56.dll
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/avutil-vgmstream-56.def)
|
||||
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-57.def)
|
||||
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib
|
||||
COMMAND ${DLLTOOL}
|
||||
ARGS -d ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def -l ${CMAKE_CURRENT_BINARY_DIR}/swresample.lib -D swresample-vgmstream-3.dll
|
||||
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/swresample-vgmstream-3.def)
|
||||
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-4.def)
|
||||
add_custom_target(ffmpeg
|
||||
DEPENDS
|
||||
${CMAKE_CURRENT_BINARY_DIR}/avcodec.lib
|
||||
|
@ -17,17 +17,17 @@ libmpg123-0.a: libmpg123-0.def
|
||||
libg719_decode.a: libg719_decode.def
|
||||
$(DLLTOOL) -d libg719_decode.def -l libg719_decode.a
|
||||
|
||||
libavcodec.a: avcodec-vgmstream-58.dll avcodec-vgmstream-58.def
|
||||
$(DLLTOOL) -D avcodec-vgmstream-58.dll -d avcodec-vgmstream-58.def -l libavcodec.a
|
||||
libavcodec.a: avcodec-vgmstream-59.dll avcodec-vgmstream-59.def
|
||||
$(DLLTOOL) -D avcodec-vgmstream-59.dll -d avcodec-vgmstream-59.def -l libavcodec.a
|
||||
|
||||
libavformat.a: avformat-vgmstream-58.dll avformat-vgmstream-58.def
|
||||
$(DLLTOOL) -D avformat-vgmstream-58.dll -d avformat-vgmstream-58.def -l libavformat.a
|
||||
libavformat.a: avformat-vgmstream-59.dll avformat-vgmstream-59.def
|
||||
$(DLLTOOL) -D avformat-vgmstream-59.dll -d avformat-vgmstream-59.def -l libavformat.a
|
||||
|
||||
libavutil.a: avutil-vgmstream-56.dll avutil-vgmstream-56.def
|
||||
$(DLLTOOL) -D avutil-vgmstream-56.dll -d avutil-vgmstream-56.def -l libavutil.a
|
||||
libavutil.a: avutil-vgmstream-57.dll avutil-vgmstream-57.def
|
||||
$(DLLTOOL) -D avutil-vgmstream-57.dll -d avutil-vgmstream-57.def -l libavutil.a
|
||||
|
||||
libswresample.a: swresample-vgmstream-3.dll swresample-vgmstream-3.def
|
||||
$(DLLTOOL) -D swresample-vgmstream-3.dll -d swresample-vgmstream-3.def -l libswresample.a
|
||||
libswresample.a: swresample-vgmstream-4.dll swresample-vgmstream-4.def
|
||||
$(DLLTOOL) -D swresample-vgmstream-4.dll -d swresample-vgmstream-4.def -l libswresample.a
|
||||
|
||||
libatrac9.a: libatrac9.dll libatrac9.def
|
||||
$(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
|
||||
|
||||
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
|
||||
|
Binary file not shown.
@ -1,10 +1,6 @@
|
||||
EXPORTS
|
||||
av_ac3_parse_header
|
||||
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_flush
|
||||
av_bsf_free
|
||||
@ -19,35 +15,18 @@ EXPORTS
|
||||
av_bsf_list_finalize
|
||||
av_bsf_list_free
|
||||
av_bsf_list_parse_str
|
||||
av_bsf_next
|
||||
av_bsf_receive_packet
|
||||
av_bsf_send_packet
|
||||
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_encoder
|
||||
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_d3d11va_alloc_context
|
||||
av_dct_calc
|
||||
av_dct_end
|
||||
av_dct_init
|
||||
av_dirac_parse_sequence_header
|
||||
av_dup_packet
|
||||
av_dv_codec_profile
|
||||
av_dv_codec_profile2
|
||||
av_dv_frame_profile
|
||||
@ -57,22 +36,19 @@ EXPORTS
|
||||
av_fft_end
|
||||
av_fft_init
|
||||
av_fft_permute
|
||||
av_free_packet
|
||||
av_fopen_utf8
|
||||
av_get_audio_frame_duration
|
||||
av_get_audio_frame_duration2
|
||||
av_get_bits_per_sample
|
||||
av_get_codec_tag_string
|
||||
av_get_exact_bits_per_sample
|
||||
av_get_pcm_codec
|
||||
av_get_profile_name
|
||||
av_grow_packet
|
||||
av_hwaccel_next
|
||||
av_imdct_calc
|
||||
av_imdct_half
|
||||
av_init_packet
|
||||
av_jni_get_java_vm
|
||||
av_jni_set_java_vm
|
||||
av_lockmgr_register
|
||||
av_mdct_calc
|
||||
av_mdct_end
|
||||
av_mdct_init
|
||||
@ -92,7 +68,6 @@ EXPORTS
|
||||
av_packet_get_side_data
|
||||
av_packet_make_refcounted
|
||||
av_packet_make_writable
|
||||
av_packet_merge_side_data
|
||||
av_packet_move_ref
|
||||
av_packet_new_side_data
|
||||
av_packet_pack_dictionary
|
||||
@ -100,25 +75,16 @@ EXPORTS
|
||||
av_packet_rescale_ts
|
||||
av_packet_shrink_side_data
|
||||
av_packet_side_data_name
|
||||
av_packet_split_side_data
|
||||
av_packet_unpack_dictionary
|
||||
av_packet_unref
|
||||
av_parser_change
|
||||
av_parser_close
|
||||
av_parser_init
|
||||
av_parser_iterate
|
||||
av_parser_next
|
||||
av_parser_parse2
|
||||
av_picture_copy
|
||||
av_picture_crop
|
||||
av_picture_pad
|
||||
av_qsv_alloc_context
|
||||
av_rdft_calc
|
||||
av_rdft_end
|
||||
av_rdft_init
|
||||
av_register_bitstream_filter
|
||||
av_register_codec_parser
|
||||
av_register_hwaccel
|
||||
av_shrink_packet
|
||||
av_vorbis_parse_frame
|
||||
av_vorbis_parse_frame_flags
|
||||
@ -132,42 +98,33 @@ EXPORTS
|
||||
avcodec_chroma_pos_to_enum
|
||||
avcodec_close
|
||||
avcodec_configuration
|
||||
avcodec_copy_context
|
||||
avcodec_dct_alloc
|
||||
avcodec_dct_get_class
|
||||
avcodec_dct_init
|
||||
avcodec_decode_audio4
|
||||
avcodec_decode_subtitle2
|
||||
avcodec_decode_video2
|
||||
avcodec_default_execute
|
||||
avcodec_default_execute2
|
||||
avcodec_default_get_buffer2
|
||||
avcodec_default_get_encode_buffer
|
||||
avcodec_default_get_format
|
||||
avcodec_descriptor_get
|
||||
avcodec_descriptor_get_by_name
|
||||
avcodec_descriptor_next
|
||||
avcodec_encode_audio2
|
||||
avcodec_encode_subtitle
|
||||
avcodec_encode_video2
|
||||
avcodec_enum_to_chroma_pos
|
||||
avcodec_fill_audio_frame
|
||||
avcodec_find_best_pix_fmt_of_2
|
||||
avcodec_find_best_pix_fmt_of_list
|
||||
avcodec_find_best_pix_fmt2
|
||||
avcodec_find_decoder
|
||||
avcodec_find_decoder_by_name
|
||||
avcodec_find_encoder
|
||||
avcodec_find_encoder_by_name
|
||||
avcodec_flush_buffers
|
||||
avcodec_free_context
|
||||
avcodec_get_chroma_sub_sample
|
||||
avcodec_get_class
|
||||
avcodec_get_context_defaults3
|
||||
avcodec_get_frame_class
|
||||
avcodec_get_hw_config
|
||||
avcodec_get_hw_frames_parameters
|
||||
avcodec_get_name
|
||||
avcodec_get_pix_fmt_loss
|
||||
avcodec_get_subtitle_rect_class
|
||||
avcodec_get_type
|
||||
avcodec_is_open
|
||||
@ -182,38 +139,21 @@ EXPORTS
|
||||
avcodec_profile_name
|
||||
avcodec_receive_frame
|
||||
avcodec_receive_packet
|
||||
avcodec_register
|
||||
avcodec_register_all
|
||||
avcodec_send_frame
|
||||
avcodec_send_packet
|
||||
avcodec_string
|
||||
avcodec_version
|
||||
avpicture_alloc
|
||||
avpicture_fill
|
||||
avpicture_free
|
||||
avpicture_get_size
|
||||
avpicture_layout
|
||||
avpriv_ac3_channel_layout_tab
|
||||
avpriv_ac3_parse_header
|
||||
avpriv_align_put_bits
|
||||
avpriv_bprint_to_extradata
|
||||
avpriv_adts_header_parse
|
||||
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_get_raw_pix_fmt_tags
|
||||
avpriv_mpa_bitrate_tab
|
||||
avpriv_mpa_freq_tab
|
||||
avpriv_mpeg4audio_get_config
|
||||
avpriv_mpeg4audio_sample_rates
|
||||
avpriv_mpeg4audio_get_config2
|
||||
avpriv_mpegaudio_decode_header
|
||||
avpriv_pix_fmt_bps_avi
|
||||
avpriv_pix_fmt_bps_mov
|
||||
avpriv_put_string
|
||||
avpriv_packet_list_free
|
||||
avpriv_packet_list_get
|
||||
avpriv_packet_list_put
|
||||
avpriv_pix_fmt_find
|
||||
avpriv_split_xiph_headers
|
||||
avpriv_tak_parse_streaminfo
|
||||
avpriv_toupper4
|
||||
avsubtitle_free
|
BIN
ext_libs/avcodec-vgmstream-59.dll
Normal file
BIN
ext_libs/avcodec-vgmstream-59.dll
Normal file
Binary file not shown.
Binary file not shown.
@ -1,12 +1,12 @@
|
||||
EXPORTS
|
||||
av_add_index_entry
|
||||
av_append_packet
|
||||
av_apply_bitstream_filters
|
||||
av_codec_get_id
|
||||
av_codec_get_tag
|
||||
av_codec_get_tag2
|
||||
av_demuxer_iterate
|
||||
av_demuxer_open
|
||||
av_disposition_from_string
|
||||
av_disposition_to_string
|
||||
av_dump_format
|
||||
av_filename_number_test
|
||||
av_find_best_stream
|
||||
@ -14,25 +14,9 @@ EXPORTS
|
||||
av_find_input_format
|
||||
av_find_program_from_stream
|
||||
av_fmt_ctx_get_duration_estimation_method
|
||||
av_fopen_utf8
|
||||
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_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_filename2
|
||||
av_get_output_timestamp
|
||||
@ -43,16 +27,14 @@ EXPORTS
|
||||
av_guess_sample_aspect_ratio
|
||||
av_hex_dump
|
||||
av_hex_dump_log
|
||||
av_iformat_next
|
||||
av_index_search_timestamp
|
||||
av_interleaved_write_frame
|
||||
av_interleaved_write_uncoded_frame
|
||||
av_match_ext
|
||||
av_muxer_iterate
|
||||
av_new_program
|
||||
av_oformat_next
|
||||
av_pkt_dump_log2
|
||||
av_pkt_dump2
|
||||
av_pkt_dump_log2
|
||||
av_probe_input_buffer
|
||||
av_probe_input_buffer2
|
||||
av_probe_input_format
|
||||
@ -62,21 +44,15 @@ EXPORTS
|
||||
av_read_frame
|
||||
av_read_pause
|
||||
av_read_play
|
||||
av_register_all
|
||||
av_register_input_format
|
||||
av_register_output_format
|
||||
av_sdp_create
|
||||
av_seek_frame
|
||||
av_stream_add_side_data
|
||||
av_stream_get_class
|
||||
av_stream_get_codec_timebase
|
||||
av_stream_get_end_pts
|
||||
av_stream_get_parser
|
||||
av_stream_get_r_frame_rate
|
||||
av_stream_get_recommended_encoder_configuration
|
||||
av_stream_get_side_data
|
||||
av_stream_new_side_data
|
||||
av_stream_set_r_frame_rate
|
||||
av_stream_set_recommended_encoder_configuration
|
||||
av_url_split
|
||||
av_write_frame
|
||||
av_write_trailer
|
||||
@ -94,6 +70,9 @@ EXPORTS
|
||||
avformat_get_mov_video_tags
|
||||
avformat_get_riff_audio_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_license
|
||||
avformat_match_stream_specifier
|
||||
@ -126,11 +105,13 @@ EXPORTS
|
||||
avio_get_str16le
|
||||
avio_handshake
|
||||
avio_open
|
||||
avio_open2
|
||||
avio_open_dir
|
||||
avio_open_dyn_buf
|
||||
avio_open2
|
||||
avio_pause
|
||||
avio_print_string_array
|
||||
avio_printf
|
||||
avio_protocol_get_class
|
||||
avio_put_str
|
||||
avio_put_str16be
|
||||
avio_put_str16le
|
||||
@ -151,6 +132,7 @@ EXPORTS
|
||||
avio_seek_time
|
||||
avio_size
|
||||
avio_skip
|
||||
avio_vprintf
|
||||
avio_w8
|
||||
avio_wb16
|
||||
avio_wb24
|
||||
@ -162,8 +144,8 @@ EXPORTS
|
||||
avio_wl64
|
||||
avio_write
|
||||
avio_write_marker
|
||||
avpriv_io_delete
|
||||
avpriv_io_move
|
||||
avpriv_new_chapter
|
||||
avpriv_register_devices
|
||||
avpriv_set_pts_info
|
||||
avpriv_stream_set_need_parsing
|
||||
avpriv_update_cur_dts
|
BIN
ext_libs/avformat-vgmstream-59.dll
Normal file
BIN
ext_libs/avformat-vgmstream-59.dll
Normal file
Binary file not shown.
Binary file not shown.
@ -57,12 +57,14 @@ EXPORTS
|
||||
av_buffer_get_ref_count
|
||||
av_buffer_is_writable
|
||||
av_buffer_make_writable
|
||||
av_buffer_pool_buffer_get_opaque
|
||||
av_buffer_pool_get
|
||||
av_buffer_pool_init
|
||||
av_buffer_pool_init2
|
||||
av_buffer_pool_uninit
|
||||
av_buffer_realloc
|
||||
av_buffer_ref
|
||||
av_buffer_replace
|
||||
av_buffer_unref
|
||||
av_calloc
|
||||
av_camellia_alloc
|
||||
@ -74,7 +76,27 @@ EXPORTS
|
||||
av_cast5_crypt2
|
||||
av_cast5_init
|
||||
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_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_name
|
||||
av_cmp_i
|
||||
@ -91,10 +113,14 @@ EXPORTS
|
||||
av_content_light_metadata_alloc
|
||||
av_content_light_metadata_create_side_data
|
||||
av_cpu_count
|
||||
av_cpu_force_count
|
||||
av_cpu_max_align
|
||||
av_crc
|
||||
av_crc_get_table
|
||||
av_crc_init
|
||||
av_csp_luma_coeffs_from_avcsp
|
||||
av_csp_primaries_desc_from_id
|
||||
av_csp_primaries_id_from_desc
|
||||
av_d2q
|
||||
av_d2str
|
||||
av_default_get_category
|
||||
@ -103,6 +129,8 @@ EXPORTS
|
||||
av_des_crypt
|
||||
av_des_init
|
||||
av_des_mac
|
||||
av_detection_bbox_alloc
|
||||
av_detection_bbox_create_side_data
|
||||
av_dict_copy
|
||||
av_dict_count
|
||||
av_dict_free
|
||||
@ -117,12 +145,16 @@ EXPORTS
|
||||
av_display_rotation_set
|
||||
av_div_i
|
||||
av_div_q
|
||||
av_dovi_alloc
|
||||
av_dovi_metadata_alloc
|
||||
av_downmix_info_update_side_data
|
||||
av_dynamic_hdr_plus_alloc
|
||||
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_nofree
|
||||
av_dynarray2_add
|
||||
av_encryption_info_add_side_data
|
||||
av_encryption_info_alloc
|
||||
av_encryption_info_clone
|
||||
@ -133,6 +165,8 @@ EXPORTS
|
||||
av_encryption_init_info_free
|
||||
av_encryption_init_info_get_side_data
|
||||
av_escape
|
||||
av_expr_count_func
|
||||
av_expr_count_vars
|
||||
av_expr_eval
|
||||
av_expr_free
|
||||
av_expr_parse
|
||||
@ -141,21 +175,38 @@ EXPORTS
|
||||
av_fast_mallocz
|
||||
av_fast_realloc
|
||||
av_fifo_alloc
|
||||
av_fifo_alloc2
|
||||
av_fifo_alloc_array
|
||||
av_fifo_auto_grow_limit
|
||||
av_fifo_can_read
|
||||
av_fifo_can_write
|
||||
av_fifo_drain
|
||||
av_fifo_drain2
|
||||
av_fifo_elem_size
|
||||
av_fifo_free
|
||||
av_fifo_freep
|
||||
av_fifo_freep2
|
||||
av_fifo_generic_peek
|
||||
av_fifo_generic_peek_at
|
||||
av_fifo_generic_read
|
||||
av_fifo_generic_write
|
||||
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_reset
|
||||
av_fifo_reset2
|
||||
av_fifo_size
|
||||
av_fifo_space
|
||||
av_fifo_write
|
||||
av_fifo_write_from_cb
|
||||
av_file_map
|
||||
av_file_unmap
|
||||
av_film_grain_params_alloc
|
||||
av_film_grain_params_create_side_data
|
||||
av_find_best_pix_fmt_of_2
|
||||
av_find_info_tag
|
||||
av_find_nearest_q_idx
|
||||
@ -168,20 +219,8 @@ EXPORTS
|
||||
av_frame_copy
|
||||
av_frame_copy_props
|
||||
av_frame_free
|
||||
av_frame_get_best_effort_timestamp
|
||||
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_qp_table
|
||||
av_frame_get_sample_rate
|
||||
av_frame_get_side_data
|
||||
av_frame_is_writable
|
||||
av_frame_make_writable
|
||||
@ -190,23 +229,12 @@ EXPORTS
|
||||
av_frame_new_side_data_from_buf
|
||||
av_frame_ref
|
||||
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_unref
|
||||
av_free
|
||||
av_freep
|
||||
av_gcd
|
||||
av_gcd_q
|
||||
av_get_alt_sample_fmt
|
||||
av_get_bits_per_pixel
|
||||
av_get_bytes_per_sample
|
||||
@ -260,6 +288,7 @@ EXPORTS
|
||||
av_hwdevice_ctx_alloc
|
||||
av_hwdevice_ctx_create
|
||||
av_hwdevice_ctx_create_derived
|
||||
av_hwdevice_ctx_create_derived_opts
|
||||
av_hwdevice_ctx_init
|
||||
av_hwdevice_find_type_by_name
|
||||
av_hwdevice_get_hwframe_constraints
|
||||
@ -281,31 +310,35 @@ EXPORTS
|
||||
av_image_check_size2
|
||||
av_image_copy
|
||||
av_image_copy_plane
|
||||
av_image_copy_plane_uc_from
|
||||
av_image_copy_to_buffer
|
||||
av_image_copy_uc_from
|
||||
av_image_fill_arrays
|
||||
av_image_fill_black
|
||||
av_image_fill_linesizes
|
||||
av_image_fill_max_pixsteps
|
||||
av_image_fill_plane_sizes
|
||||
av_image_fill_pointers
|
||||
av_image_get_buffer_size
|
||||
av_image_get_linesize
|
||||
av_int_list_length_for_size
|
||||
av_int2i
|
||||
av_int_list_length_for_size
|
||||
av_lfg_init
|
||||
av_lfg_init_from_data
|
||||
av_log
|
||||
av_log2
|
||||
av_log2_16bit
|
||||
av_log2_i
|
||||
av_log_default_callback
|
||||
av_log_format_line
|
||||
av_log_format_line2
|
||||
av_log_get_flags
|
||||
av_log_get_level
|
||||
av_log_once
|
||||
av_log_set_callback
|
||||
av_log_set_flags
|
||||
av_log_set_level
|
||||
av_log2
|
||||
av_log2_16bit
|
||||
av_log2_i
|
||||
av_lzo1x_decode
|
||||
av_malloc
|
||||
av_malloc_array
|
||||
av_mallocz
|
||||
@ -332,7 +365,7 @@ EXPORTS
|
||||
av_murmur3_init_seeded
|
||||
av_murmur3_update
|
||||
av_nearer_q
|
||||
av_opt_child_class_next
|
||||
av_opt_child_class_iterate
|
||||
av_opt_child_next
|
||||
av_opt_copy
|
||||
av_opt_eval_double
|
||||
@ -348,6 +381,7 @@ EXPORTS
|
||||
av_opt_freep_ranges
|
||||
av_opt_get
|
||||
av_opt_get_channel_layout
|
||||
av_opt_get_chlayout
|
||||
av_opt_get_dict_val
|
||||
av_opt_get_double
|
||||
av_opt_get_image_size
|
||||
@ -367,11 +401,12 @@ EXPORTS
|
||||
av_opt_set
|
||||
av_opt_set_bin
|
||||
av_opt_set_channel_layout
|
||||
av_opt_set_chlayout
|
||||
av_opt_set_defaults
|
||||
av_opt_set_defaults2
|
||||
av_opt_set_dict
|
||||
av_opt_set_dict_val
|
||||
av_opt_set_dict2
|
||||
av_opt_set_dict_val
|
||||
av_opt_set_double
|
||||
av_opt_set_from_string
|
||||
av_opt_set_image_size
|
||||
@ -383,7 +418,6 @@ EXPORTS
|
||||
av_opt_show2
|
||||
av_parse_color
|
||||
av_parse_cpu_caps
|
||||
av_parse_cpu_flags
|
||||
av_parse_ratio
|
||||
av_parse_time
|
||||
av_parse_video_rate
|
||||
@ -424,19 +458,19 @@ EXPORTS
|
||||
av_samples_fill_arrays
|
||||
av_samples_get_buffer_size
|
||||
av_samples_set_silence
|
||||
av_set_cpu_flags_mask
|
||||
av_set_options_string
|
||||
av_sha_alloc
|
||||
av_sha_final
|
||||
av_sha_init
|
||||
av_sha_size
|
||||
av_sha_update
|
||||
av_sha512_alloc
|
||||
av_sha512_final
|
||||
av_sha512_init
|
||||
av_sha512_size
|
||||
av_sha512_update
|
||||
av_sha_alloc
|
||||
av_sha_final
|
||||
av_sha_init
|
||||
av_sha_size
|
||||
av_sha_update
|
||||
av_shr_i
|
||||
av_size_mult
|
||||
av_small_strptime
|
||||
av_spherical_alloc
|
||||
av_spherical_from_name
|
||||
@ -480,11 +514,14 @@ EXPORTS
|
||||
av_thread_message_queue_set_free_func
|
||||
av_timecode_adjust_ntsc_framenum2
|
||||
av_timecode_check_frame_rate
|
||||
av_timecode_get_smpte
|
||||
av_timecode_get_smpte_from_framenum
|
||||
av_timecode_init
|
||||
av_timecode_init_from_components
|
||||
av_timecode_init_from_string
|
||||
av_timecode_make_mpeg_tc_string
|
||||
av_timecode_make_smpte_tc_string
|
||||
av_timecode_make_smpte_tc_string2
|
||||
av_timecode_make_string
|
||||
av_timegm
|
||||
av_tree_destroy
|
||||
@ -497,11 +534,21 @@ EXPORTS
|
||||
av_twofish_crypt
|
||||
av_twofish_init
|
||||
av_twofish_size
|
||||
av_tx_init
|
||||
av_tx_uninit
|
||||
av_usleep
|
||||
av_utf8_decode
|
||||
av_util_ffversion
|
||||
av_uuid_parse
|
||||
av_uuid_parse_range
|
||||
av_uuid_unparse
|
||||
av_uuid_urn_parse
|
||||
av_vbprintf
|
||||
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_write_image_line
|
||||
av_write_image_line2
|
||||
@ -517,7 +564,6 @@ EXPORTS
|
||||
avpriv_get_gamma_from_trc
|
||||
avpriv_get_trc_function_from_trc
|
||||
avpriv_init_lls
|
||||
avpriv_open
|
||||
avpriv_report_missing_feature
|
||||
avpriv_request_sample
|
||||
avpriv_scalarproduct_float_c
|
||||
@ -526,7 +572,6 @@ EXPORTS
|
||||
avpriv_slicethread_execute
|
||||
avpriv_slicethread_free
|
||||
avpriv_solve_lls
|
||||
avpriv_tempfile
|
||||
avpriv_vga16_font
|
||||
avutil_configuration
|
||||
avutil_license
|
BIN
ext_libs/avutil-vgmstream-57.dll
Normal file
BIN
ext_libs/avutil-vgmstream-57.dll
Normal file
Binary file not shown.
@ -68,24 +68,24 @@
|
||||
</Command>
|
||||
<Outputs>libg719_decode.lib;libg719_decode.exp;%(Outputs)</Outputs>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="avcodec-vgmstream-58.def">
|
||||
<CustomBuild Include="avcodec-vgmstream-59.def">
|
||||
<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>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="avformat-vgmstream-58.def">
|
||||
<CustomBuild Include="avformat-vgmstream-59.def">
|
||||
<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>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="avutil-vgmstream-56.def">
|
||||
<CustomBuild Include="avutil-vgmstream-57.def">
|
||||
<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>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="swresample-vgmstream-3.def">
|
||||
<CustomBuild Include="swresample-vgmstream-4.def">
|
||||
<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>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="libatrac9.def">
|
||||
|
@ -1,3 +1,6 @@
|
||||
#!/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
|
||||
|
@ -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
|
||||
--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
|
||||
--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-ffplay
|
||||
--disable-ffprobe
|
||||
|
||||
# components (some aren't enabled anyway but force just in case they get autodetected)
|
||||
--disable-avdevice
|
||||
--disable-ffmpeg
|
||||
--disable-swresample
|
||||
--disable-swscale
|
||||
--disable-postproc
|
||||
--disable-avfilter
|
||||
--disable-swscale
|
||||
--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-vdpau
|
||||
--disable-dxva2
|
||||
--disable-amf
|
||||
--disable-cuda
|
||||
--disable-cuvid
|
||||
--disable-d3d11va
|
||||
--disable-dxva2
|
||||
--disable-ffnvcodec
|
||||
--disable-nvenc
|
||||
--disable-nvdec
|
||||
--disable-hwaccels
|
||||
--disable-sdl2
|
||||
--disable-iconv
|
||||
--disable-everything
|
||||
--enable-hwaccels
|
||||
--disable-vdpau
|
||||
|
||||
# this can't be disabled, for av_get_random_seed though shouldn't be needed (maybe indirectly by asf?)
|
||||
# Windows XP doesn't support bcrypt though, see "ffmpeg-revert-bcrypt-random.patch" if XP support is really needed
|
||||
# (--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-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-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
|
||||
--disable-parser=mpeg4video,h263
|
||||
--disable-decoder=mpeg2video,h263,h264,mpeg1video,mpeg2video,mpeg4,hevc,vp9
|
||||
--disable-cuvid
|
||||
--disable-version3
|
||||
|
||||
# decoders take frames and decodes (handles codecs)
|
||||
# (swap libopus with opus if needed)
|
||||
# - ac3,eac3: PS2/PS3 games
|
||||
# - wmapro,wmav1,wmav2,xma1,xma2: Windows/X360 games
|
||||
# - 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
|
||||
|
Binary file not shown.
@ -1,7 +1,9 @@
|
||||
EXPORTS
|
||||
swr_alloc
|
||||
swr_alloc_set_opts
|
||||
swr_alloc_set_opts2
|
||||
swr_build_matrix
|
||||
swr_build_matrix2
|
||||
swr_close
|
||||
swr_config_frame
|
||||
swr_convert
|
BIN
ext_libs/swresample-vgmstream-4.dll
Normal file
BIN
ext_libs/swresample-vgmstream-4.dll
Normal file
Binary file not shown.
Loading…
Reference in New Issue
Block a user