parent
6f5a7b4ff4
commit
d1aaa2fcfb
@ -0,0 +1,27 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>AvailableLibraries</key> |
||||
<array> |
||||
<dict> |
||||
<key>BinaryPath</key> |
||||
<string>libavcodec.framework/libavcodec</string> |
||||
<key>LibraryIdentifier</key> |
||||
<string>ios-arm64</string> |
||||
<key>LibraryPath</key> |
||||
<string>libavcodec.framework</string> |
||||
<key>SupportedArchitectures</key> |
||||
<array> |
||||
<string>arm64</string> |
||||
</array> |
||||
<key>SupportedPlatform</key> |
||||
<string>ios</string> |
||||
</dict> |
||||
</array> |
||||
<key>CFBundlePackageType</key> |
||||
<string>XFWK</string> |
||||
<key>XCFrameworkFormatVersion</key> |
||||
<string>1.0</string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,36 @@ |
||||
/*
|
||||
* AC-3 parser prototypes |
||||
* Copyright (c) 2003 Fabrice Bellard |
||||
* Copyright (c) 2003 Michael Niedermayer |
||||
* |
||||
* 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_AC3_PARSER_H |
||||
#define AVCODEC_AC3_PARSER_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* Extract the bitstream ID and the frame size from AC-3 data. |
||||
*/ |
||||
int av_ac3_parse_header(const uint8_t *buf, size_t size, |
||||
uint8_t *bitstream_id, uint16_t *frame_size); |
||||
|
||||
|
||||
#endif /* AVCODEC_AC3_PARSER_H */ |
||||
@ -0,0 +1,37 @@ |
||||
/*
|
||||
* 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_ADTS_PARSER_H |
||||
#define AVCODEC_ADTS_PARSER_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#define AV_AAC_ADTS_HEADER_SIZE 7 |
||||
|
||||
/**
|
||||
* Extract the number of samples and frames from AAC data. |
||||
* @param[in] buf pointer to AAC data buffer |
||||
* @param[out] samples Pointer to where number of samples is written |
||||
* @param[out] frames Pointer to where number of frames is written |
||||
* @return Returns 0 on success, error code on failure. |
||||
*/ |
||||
int av_adts_header_parse(const uint8_t *buf, uint32_t *samples, |
||||
uint8_t *frames); |
||||
|
||||
#endif /* AVCODEC_ADTS_PARSER_H */ |
||||
@ -0,0 +1,108 @@ |
||||
/*
|
||||
* simple math operations |
||||
* Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al |
||||
* |
||||
* 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_ARM_MATHOPS_H |
||||
#define AVCODEC_ARM_MATHOPS_H |
||||
|
||||
#include <stdint.h> |
||||
#include "config.h" |
||||
#include "libavutil/common.h" |
||||
|
||||
#if HAVE_INLINE_ASM |
||||
|
||||
#if HAVE_ARMV6_INLINE |
||||
#define MULH MULH |
||||
static inline av_const int MULH(int a, int b) |
||||
{ |
||||
int r; |
||||
__asm__ ("smmul %0, %1, %2" : "=r"(r) : "r"(a), "r"(b)); |
||||
return r; |
||||
} |
||||
|
||||
#define FASTDIV FASTDIV |
||||
static av_always_inline av_const int FASTDIV(int a, int b) |
||||
{ |
||||
int r; |
||||
__asm__ ("cmp %2, #2 \n\t" |
||||
"ldr %0, [%3, %2, lsl #2] \n\t" |
||||
"ite le \n\t" |
||||
"lsrle %0, %1, #1 \n\t" |
||||
"smmulgt %0, %0, %1 \n\t" |
||||
: "=&r"(r) : "r"(a), "r"(b), "r"(ff_inverse) : "cc"); |
||||
return r; |
||||
} |
||||
|
||||
#else /* HAVE_ARMV6_INLINE */ |
||||
|
||||
#define FASTDIV FASTDIV |
||||
static av_always_inline av_const int FASTDIV(int a, int b) |
||||
{ |
||||
int r, t; |
||||
__asm__ ("umull %1, %0, %2, %3" |
||||
: "=&r"(r), "=&r"(t) : "r"(a), "r"(ff_inverse[b])); |
||||
return r; |
||||
} |
||||
#endif |
||||
|
||||
#define MLS64(d, a, b) MAC64(d, -(a), b) |
||||
|
||||
#if HAVE_ARMV5TE_INLINE |
||||
|
||||
/* signed 16x16 -> 32 multiply add accumulate */ |
||||
# define MAC16(rt, ra, rb) \ |
||||
__asm__ ("smlabb %0, %1, %2, %0" : "+r"(rt) : "r"(ra), "r"(rb)); |
||||
|
||||
/* signed 16x16 -> 32 multiply */ |
||||
# define MUL16 MUL16 |
||||
static inline av_const int MUL16(int ra, int rb) |
||||
{ |
||||
int rt; |
||||
__asm__ ("smulbb %0, %1, %2" : "=r"(rt) : "r"(ra), "r"(rb)); |
||||
return rt; |
||||
} |
||||
|
||||
#endif |
||||
|
||||
#define mid_pred mid_pred |
||||
static inline av_const int mid_pred(int a, int b, int c) |
||||
{ |
||||
int m; |
||||
__asm__ ( |
||||
"mov %0, %2 \n\t" |
||||
"cmp %1, %2 \n\t" |
||||
"itt gt \n\t" |
||||
"movgt %0, %1 \n\t" |
||||
"movgt %1, %2 \n\t" |
||||
"cmp %1, %3 \n\t" |
||||
"it le \n\t" |
||||
"movle %1, %3 \n\t" |
||||
"cmp %0, %1 \n\t" |
||||
"it gt \n\t" |
||||
"movgt %0, %1 \n\t" |
||||
: "=&r"(m), "+r"(a) |
||||
: "r"(b), "r"(c) |
||||
: "cc"); |
||||
return m; |
||||
} |
||||
|
||||
#endif /* HAVE_INLINE_ASM */ |
||||
|
||||
#endif /* AVCODEC_ARM_MATHOPS_H */ |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,88 @@ |
||||
/*
|
||||
* 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_AVDCT_H |
||||
#define AVCODEC_AVDCT_H |
||||
|
||||
#include "libavutil/opt.h" |
||||
|
||||
/**
|
||||
* AVDCT context. |
||||
* @note function pointers can be NULL if the specific features have been |
||||
* disabled at build time. |
||||
*/ |
||||
typedef struct AVDCT { |
||||
const AVClass *av_class; |
||||
|
||||
void (*idct)(int16_t *block /* align 16 */); |
||||
|
||||
/**
|
||||
* IDCT input permutation. |
||||
* Several optimized IDCTs need a permutated input (relative to the |
||||
* normal order of the reference IDCT). |
||||
* This permutation must be performed before the idct_put/add. |
||||
* Note, normally this can be merged with the zigzag/alternate scan<br> |
||||
* An example to avoid confusion: |
||||
* - (->decode coeffs -> zigzag reorder -> dequant -> reference IDCT -> ...) |
||||
* - (x -> reference DCT -> reference IDCT -> x) |
||||
* - (x -> reference DCT -> simple_mmx_perm = idct_permutation |
||||
* -> simple_idct_mmx -> x) |
||||
* - (-> decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant |
||||
* -> simple_idct_mmx -> ...) |
||||
*/ |
||||
uint8_t idct_permutation[64]; |
||||
|
||||
void (*fdct)(int16_t *block /* align 16 */); |
||||
|
||||
|
||||
/**
|
||||
* DCT algorithm. |
||||
* must use AVOptions to set this field. |
||||
*/ |
||||
int dct_algo; |
||||
|
||||
/**
|
||||
* IDCT algorithm. |
||||
* must use AVOptions to set this field. |
||||
*/ |
||||
int idct_algo; |
||||
|
||||
void (*get_pixels)(int16_t *block /* align 16 */, |
||||
const uint8_t *pixels /* align 8 */, |
||||
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; |
||||
|
||||
/**
|
||||
* Allocates a AVDCT context. |
||||
* This needs to be initialized with avcodec_dct_init() after optionally |
||||
* configuring it with AVOptions. |
||||
* |
||||
* To free it use av_free() |
||||
*/ |
||||
AVDCT *avcodec_dct_alloc(void); |
||||
int avcodec_dct_init(AVDCT *); |
||||
|
||||
const AVClass *avcodec_dct_get_class(void); |
||||
|
||||
#endif /* AVCODEC_AVDCT_H */ |
||||
@ -0,0 +1,118 @@ |
||||
/*
|
||||
* 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_AVFFT_H |
||||
#define AVCODEC_AVFFT_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_fft |
||||
* FFT functions |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavc_fft FFT functions |
||||
* @ingroup lavc_misc |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
typedef float FFTSample; |
||||
|
||||
typedef struct FFTComplex { |
||||
FFTSample re, im; |
||||
} FFTComplex; |
||||
|
||||
typedef struct FFTContext FFTContext; |
||||
|
||||
/**
|
||||
* Set up a complex FFT. |
||||
* @param nbits log2 of the length of the input array |
||||
* @param inverse if 0 perform the forward transform, if 1 perform the inverse |
||||
*/ |
||||
FFTContext *av_fft_init(int nbits, int inverse); |
||||
|
||||
/**
|
||||
* Do the permutation needed BEFORE calling ff_fft_calc(). |
||||
*/ |
||||
void av_fft_permute(FFTContext *s, FFTComplex *z); |
||||
|
||||
/**
|
||||
* Do a complex FFT with the parameters defined in av_fft_init(). The |
||||
* input data must be permuted before. No 1.0/sqrt(n) normalization is done. |
||||
*/ |
||||
void av_fft_calc(FFTContext *s, FFTComplex *z); |
||||
|
||||
void av_fft_end(FFTContext *s); |
||||
|
||||
FFTContext *av_mdct_init(int nbits, int inverse, double scale); |
||||
void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input); |
||||
void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input); |
||||
void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input); |
||||
void av_mdct_end(FFTContext *s); |
||||
|
||||
/* Real Discrete Fourier Transform */ |
||||
|
||||
enum RDFTransformType { |
||||
DFT_R2C, |
||||
IDFT_C2R, |
||||
IDFT_R2C, |
||||
DFT_C2R, |
||||
}; |
||||
|
||||
typedef struct RDFTContext RDFTContext; |
||||
|
||||
/**
|
||||
* Set up a real FFT. |
||||
* @param nbits log2 of the length of the input array |
||||
* @param trans the type of transform |
||||
*/ |
||||
RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans); |
||||
void av_rdft_calc(RDFTContext *s, FFTSample *data); |
||||
void av_rdft_end(RDFTContext *s); |
||||
|
||||
/* Discrete Cosine Transform */ |
||||
|
||||
typedef struct DCTContext DCTContext; |
||||
|
||||
enum DCTTransformType { |
||||
DCT_II = 0, |
||||
DCT_III, |
||||
DCT_I, |
||||
DST_I, |
||||
}; |
||||
|
||||
/**
|
||||
* Set up DCT. |
||||
* |
||||
* @param nbits size of the input array: |
||||
* (1 << nbits) for DCT-II, DCT-III and DST-I |
||||
* (1 << nbits) + 1 for DCT-I |
||||
* @param type the type of transform |
||||
* |
||||
* @note the first element of the input of DST-I is ignored |
||||
*/ |
||||
DCTContext *av_dct_init(int nbits, enum DCTTransformType type); |
||||
void av_dct_calc(DCTContext *s, FFTSample *data); |
||||
void av_dct_end (DCTContext *s); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVCODEC_AVFFT_H */ |
||||
@ -0,0 +1,332 @@ |
||||
/*
|
||||
* 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. |
||||
* |
||||
* @param ctx a AVBSFContext previously allocated with av_bsf_alloc() |
||||
*/ |
||||
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 ctx an initialized AVBSFContext |
||||
* @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 ctx an initialized AVBSFContext |
||||
* @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
|
||||
@ -0,0 +1,375 @@ |
||||
/*
|
||||
* 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) |
||||
/**
|
||||
* 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) |
||||
/**
|
||||
* 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) |
||||
|
||||
/**
|
||||
* 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 encoder can reorder user opaque values from input AVFrames and return |
||||
* them with corresponding output packets. |
||||
* @see AV_CODEC_FLAG_COPY_OPAQUE |
||||
*/ |
||||
#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) |
||||
|
||||
/**
|
||||
* The encoder is able to output reconstructed frame data, i.e. raw frames that |
||||
* would be produced by decoding the encoded bitstream. |
||||
* |
||||
* Reconstructed frame output is enabled by the AV_CODEC_FLAG_RECON_FRAME flag. |
||||
*/ |
||||
#define AV_CODEC_CAP_ENCODER_RECON_FRAME (1 << 22) |
||||
|
||||
/**
|
||||
* AVProfile. |
||||
*/ |
||||
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 */ |
||||
@ -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
|
||||
@ -0,0 +1,661 @@ |
||||
/*
|
||||
* 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" |
||||
|
||||
#include "version_major.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, |
||||
#if FF_API_AYUV_CODECID |
||||
AV_CODEC_ID_AYUV, |
||||
#endif |
||||
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, |
||||
AV_CODEC_ID_RADIANCE_HDR, |
||||
AV_CODEC_ID_WBMP, |
||||
AV_CODEC_ID_MEDIA100, |
||||
AV_CODEC_ID_VQC, |
||||
|
||||
/* 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, |
||||
AV_CODEC_ID_ADPCM_XMD, |
||||
|
||||
/* 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, |
||||
AV_CODEC_ID_WADY_DPCM, |
||||
AV_CODEC_ID_CBD2_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, |
||||
AV_CODEC_ID_BONK, |
||||
AV_CODEC_ID_MISC4, |
||||
AV_CODEC_ID_APAC, |
||||
AV_CODEC_ID_FTR, |
||||
AV_CODEC_ID_WAVARC, |
||||
AV_CODEC_ID_RKA, |
||||
|
||||
/* subtitle codecs */ |
||||
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
|
||||
/**
|
||||
* Dummy null video codec, useful mainly for development and debugging. |
||||
* Null encoder/decoder discard all input and never return any output. |
||||
*/ |
||||
AV_CODEC_ID_VNULL, |
||||
/**
|
||||
* Dummy null audio codec, useful mainly for development and debugging. |
||||
* Null encoder/decoder discard all input and never return any output. |
||||
*/ |
||||
AV_CODEC_ID_ANULL, |
||||
}; |
||||
|
||||
/**
|
||||
* 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
|
||||
@ -0,0 +1,247 @@ |
||||
/*
|
||||
* 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
|
||||
@ -0,0 +1,112 @@ |
||||
/*
|
||||
* Direct3D11 HW acceleration |
||||
* |
||||
* copyright (c) 2009 Laurent Aimar |
||||
* copyright (c) 2015 Steve Lhomme |
||||
* |
||||
* 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_D3D11VA_H |
||||
#define AVCODEC_D3D11VA_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_codec_hwaccel_d3d11va |
||||
* Public libavcodec D3D11VA header. |
||||
*/ |
||||
|
||||
#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602 |
||||
#undef _WIN32_WINNT |
||||
#define _WIN32_WINNT 0x0602 |
||||
#endif |
||||
|
||||
#include <stdint.h> |
||||
#include <d3d11.h> |
||||
|
||||
/**
|
||||
* @defgroup lavc_codec_hwaccel_d3d11va Direct3D11 |
||||
* @ingroup lavc_codec_hwaccel |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for Direct3D11 and old UVD/UVD+ ATI video cards
|
||||
#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO 2 ///< Work around for Direct3D11 and old Intel GPUs with ClearVideo interface
|
||||
|
||||
/**
|
||||
* This structure is used to provides the necessary configurations and data |
||||
* to the Direct3D11 FFmpeg HWAccel implementation. |
||||
* |
||||
* The application must make it available as AVCodecContext.hwaccel_context. |
||||
* |
||||
* Use av_d3d11va_alloc_context() exclusively to allocate an AVD3D11VAContext. |
||||
*/ |
||||
typedef struct AVD3D11VAContext { |
||||
/**
|
||||
* D3D11 decoder object |
||||
*/ |
||||
ID3D11VideoDecoder *decoder; |
||||
|
||||
/**
|
||||
* D3D11 VideoContext |
||||
*/ |
||||
ID3D11VideoContext *video_context; |
||||
|
||||
/**
|
||||
* D3D11 configuration used to create the decoder |
||||
*/ |
||||
D3D11_VIDEO_DECODER_CONFIG *cfg; |
||||
|
||||
/**
|
||||
* The number of surface in the surface array |
||||
*/ |
||||
unsigned surface_count; |
||||
|
||||
/**
|
||||
* The array of Direct3D surfaces used to create the decoder |
||||
*/ |
||||
ID3D11VideoDecoderOutputView **surface; |
||||
|
||||
/**
|
||||
* A bit field configuring the workarounds needed for using the decoder |
||||
*/ |
||||
uint64_t workaround; |
||||
|
||||
/**
|
||||
* Private to the FFmpeg AVHWAccel implementation |
||||
*/ |
||||
unsigned report_id; |
||||
|
||||
/**
|
||||
* Mutex to access video_context |
||||
*/ |
||||
HANDLE context_mutex; |
||||
} AVD3D11VAContext; |
||||
|
||||
/**
|
||||
* Allocate an AVD3D11VAContext. |
||||
* |
||||
* @return Newly-allocated AVD3D11VAContext or NULL on failure. |
||||
*/ |
||||
AVD3D11VAContext *av_d3d11va_alloc_context(void); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVCODEC_D3D11VA_H */ |
||||
@ -0,0 +1,192 @@ |
||||
/*
|
||||
* |
||||
* 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 |
||||
|
||||
/**
|
||||
* Verify checksums embedded in the bitstream (could be of either encoded or |
||||
* decoded data, depending on the format) and print an error message on mismatch. |
||||
* If AV_EF_EXPLODE is also set, a mismatching checksum will result in the |
||||
* decoder/demuxer returning an error. |
||||
*/ |
||||
#define AV_EF_CRCCHECK (1<<0) |
||||
#define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations
|
||||
#define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length
|
||||
#define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection
|
||||
|
||||
#define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue
|
||||
#define AV_EF_CAREFUL (1<<16) ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
|
||||
#define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors
|
||||
#define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder/muxer should not do as an error
|
||||
|
||||
#define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
|
||||
#define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
|
||||
#define FF_COMPLIANCE_NORMAL 0 |
||||
#define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
|
||||
#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
|
||||
|
||||
/**
|
||||
* @ingroup lavc_decoding |
||||
*/ |
||||
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
|
||||
@ -0,0 +1,131 @@ |
||||
/*
|
||||
* Copyright (C) 2007 Marco Gerards <marco@gnu.org> |
||||
* Copyright (C) 2009 David Conrad |
||||
* Copyright (C) 2011 Jordi Ortiz |
||||
* |
||||
* 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_DIRAC_H |
||||
#define AVCODEC_DIRAC_H |
||||
|
||||
/**
|
||||
* @file |
||||
* Interface to Dirac Decoder/Encoder |
||||
* @author Marco Gerards <marco@gnu.org> |
||||
* @author David Conrad |
||||
* @author Jordi Ortiz |
||||
*/ |
||||
|
||||
#include "avcodec.h" |
||||
|
||||
/**
|
||||
* The spec limits the number of wavelet decompositions to 4 for both |
||||
* level 1 (VC-2) and 128 (long-gop default). |
||||
* 5 decompositions is the maximum before >16-bit buffers are needed. |
||||
* Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting |
||||
* the others to 4 decompositions (or 3 for the fidelity filter). |
||||
* |
||||
* We use this instead of MAX_DECOMPOSITIONS to save some memory. |
||||
*/ |
||||
#define MAX_DWT_LEVELS 5 |
||||
|
||||
/**
|
||||
* Parse code values: |
||||
* |
||||
* Dirac Specification -> |
||||
* 9.6.1 Table 9.1 |
||||
* |
||||
* VC-2 Specification -> |
||||
* 10.4.1 Table 10.1 |
||||
*/ |
||||
|
||||
enum DiracParseCodes { |
||||
DIRAC_PCODE_SEQ_HEADER = 0x00, |
||||
DIRAC_PCODE_END_SEQ = 0x10, |
||||
DIRAC_PCODE_AUX = 0x20, |
||||
DIRAC_PCODE_PAD = 0x30, |
||||
DIRAC_PCODE_PICTURE_CODED = 0x08, |
||||
DIRAC_PCODE_PICTURE_RAW = 0x48, |
||||
DIRAC_PCODE_PICTURE_LOW_DEL = 0xC8, |
||||
DIRAC_PCODE_PICTURE_HQ = 0xE8, |
||||
DIRAC_PCODE_INTER_NOREF_CO1 = 0x0A, |
||||
DIRAC_PCODE_INTER_NOREF_CO2 = 0x09, |
||||
DIRAC_PCODE_INTER_REF_CO1 = 0x0D, |
||||
DIRAC_PCODE_INTER_REF_CO2 = 0x0E, |
||||
DIRAC_PCODE_INTRA_REF_CO = 0x0C, |
||||
DIRAC_PCODE_INTRA_REF_RAW = 0x4C, |
||||
DIRAC_PCODE_INTRA_REF_PICT = 0xCC, |
||||
DIRAC_PCODE_MAGIC = 0x42424344, |
||||
}; |
||||
|
||||
typedef struct DiracVersionInfo { |
||||
int major; |
||||
int minor; |
||||
} DiracVersionInfo; |
||||
|
||||
typedef struct AVDiracSeqHeader { |
||||
unsigned width; |
||||
unsigned height; |
||||
uint8_t chroma_format; ///< 0: 444 1: 422 2: 420
|
||||
|
||||
uint8_t interlaced; |
||||
uint8_t top_field_first; |
||||
|
||||
uint8_t frame_rate_index; ///< index into dirac_frame_rate[]
|
||||
uint8_t aspect_ratio_index; ///< index into dirac_aspect_ratio[]
|
||||
|
||||
uint16_t clean_width; |
||||
uint16_t clean_height; |
||||
uint16_t clean_left_offset; |
||||
uint16_t clean_right_offset; |
||||
|
||||
uint8_t pixel_range_index; ///< index into dirac_pixel_range_presets[]
|
||||
uint8_t color_spec_index; ///< index into dirac_color_spec_presets[]
|
||||
|
||||
int profile; |
||||
int level; |
||||
|
||||
AVRational framerate; |
||||
AVRational sample_aspect_ratio; |
||||
|
||||
enum AVPixelFormat pix_fmt; |
||||
enum AVColorRange color_range; |
||||
enum AVColorPrimaries color_primaries; |
||||
enum AVColorTransferCharacteristic color_trc; |
||||
enum AVColorSpace colorspace; |
||||
|
||||
DiracVersionInfo version; |
||||
int bit_depth; |
||||
} AVDiracSeqHeader; |
||||
|
||||
/**
|
||||
* Parse a Dirac sequence header. |
||||
* |
||||
* @param dsh this function will allocate and fill an AVDiracSeqHeader struct |
||||
* and write it into this pointer. The caller must free it with |
||||
* av_free(). |
||||
* @param buf the data buffer |
||||
* @param buf_size the size of the data buffer in bytes |
||||
* @param log_ctx if non-NULL, this function will log errors here |
||||
* @return 0 on success, a negative AVERROR code on failure |
||||
*/ |
||||
int av_dirac_parse_sequence_header(AVDiracSeqHeader **dsh, |
||||
const uint8_t *buf, size_t buf_size, |
||||
void *log_ctx); |
||||
|
||||
#endif /* AVCODEC_DIRAC_H */ |
||||
@ -0,0 +1,82 @@ |
||||
/*
|
||||
* 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_DV_PROFILE_H |
||||
#define AVCODEC_DV_PROFILE_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "libavutil/pixfmt.h" |
||||
#include "libavutil/rational.h" |
||||
|
||||
/* minimum number of bytes to read from a DV stream in order to
|
||||
* determine the profile */ |
||||
#define DV_PROFILE_BYTES (6 * 80) /* 6 DIF blocks */ |
||||
|
||||
|
||||
/*
|
||||
* AVDVProfile is used to express the differences between various |
||||
* DV flavors. For now it's primarily used for differentiating |
||||
* 525/60 and 625/50, but the plans are to use it for various |
||||
* DV specs as well (e.g. SMPTE314M vs. IEC 61834). |
||||
*/ |
||||
typedef struct AVDVProfile { |
||||
int dsf; /* value of the dsf in the DV header */ |
||||
int video_stype; /* stype for VAUX source pack */ |
||||
int frame_size; /* total size of one frame in bytes */ |
||||
int difseg_size; /* number of DIF segments per DIF channel */ |
||||
int n_difchan; /* number of DIF channels per frame */ |
||||
AVRational time_base; /* 1/framerate */ |
||||
int ltc_divisor; /* FPS from the LTS standpoint */ |
||||
int height; /* picture height in pixels */ |
||||
int width; /* picture width in pixels */ |
||||
AVRational sar[2]; /* sample aspect ratios for 4:3 and 16:9 */ |
||||
enum AVPixelFormat pix_fmt; /* picture pixel format */ |
||||
int bpm; /* blocks per macroblock */ |
||||
const uint8_t *block_sizes; /* AC block sizes, in bits */ |
||||
int audio_stride; /* size of audio_shuffle table */ |
||||
int audio_min_samples[3]; /* min amount of audio samples */ |
||||
/* for 48kHz, 44.1kHz and 32kHz */ |
||||
int audio_samples_dist[5]; /* how many samples are supposed to be */ |
||||
/* in each frame in a 5 frames window */ |
||||
const uint8_t (*audio_shuffle)[9]; /* PCM shuffling table */ |
||||
} AVDVProfile; |
||||
|
||||
/**
|
||||
* Get a DV profile for the provided compressed frame. |
||||
* |
||||
* @param sys the profile used for the previous frame, may be NULL |
||||
* @param frame the compressed data buffer |
||||
* @param buf_size size of the buffer in bytes |
||||
* @return the DV profile for the supplied data or NULL on failure |
||||
*/ |
||||
const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys, |
||||
const uint8_t *frame, unsigned buf_size); |
||||
|
||||
/**
|
||||
* Get a DV profile for the provided stream parameters. |
||||
*/ |
||||
const AVDVProfile *av_dv_codec_profile(int width, int height, enum AVPixelFormat pix_fmt); |
||||
|
||||
/**
|
||||
* Get a DV profile for the provided stream parameters. |
||||
* The frame rate is used as a best-effort parameter. |
||||
*/ |
||||
const AVDVProfile *av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate); |
||||
|
||||
#endif /* AVCODEC_DV_PROFILE_H */ |
||||
@ -0,0 +1,93 @@ |
||||
/*
|
||||
* DXVA2 HW acceleration |
||||
* |
||||
* copyright (c) 2009 Laurent Aimar |
||||
* |
||||
* 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_DXVA2_H |
||||
#define AVCODEC_DXVA2_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_codec_hwaccel_dxva2 |
||||
* Public libavcodec DXVA2 header. |
||||
*/ |
||||
|
||||
#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602 |
||||
#undef _WIN32_WINNT |
||||
#define _WIN32_WINNT 0x0602 |
||||
#endif |
||||
|
||||
#include <stdint.h> |
||||
#include <d3d9.h> |
||||
#include <dxva2api.h> |
||||
|
||||
/**
|
||||
* @defgroup lavc_codec_hwaccel_dxva2 DXVA2 |
||||
* @ingroup lavc_codec_hwaccel |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards
|
||||
#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO 2 ///< Work around for DXVA2 and old Intel GPUs with ClearVideo interface
|
||||
|
||||
/**
|
||||
* This structure is used to provides the necessary configurations and data |
||||
* to the DXVA2 FFmpeg HWAccel implementation. |
||||
* |
||||
* The application must make it available as AVCodecContext.hwaccel_context. |
||||
*/ |
||||
struct dxva_context { |
||||
/**
|
||||
* DXVA2 decoder object |
||||
*/ |
||||
IDirectXVideoDecoder *decoder; |
||||
|
||||
/**
|
||||
* DXVA2 configuration used to create the decoder |
||||
*/ |
||||
const DXVA2_ConfigPictureDecode *cfg; |
||||
|
||||
/**
|
||||
* The number of surface in the surface array |
||||
*/ |
||||
unsigned surface_count; |
||||
|
||||
/**
|
||||
* The array of Direct3D surfaces used to create the decoder |
||||
*/ |
||||
LPDIRECT3DSURFACE9 *surface; |
||||
|
||||
/**
|
||||
* A bit field configuring the workarounds needed for using the decoder |
||||
*/ |
||||
uint64_t workaround; |
||||
|
||||
/**
|
||||
* Private to the FFmpeg AVHWAccel implementation |
||||
*/ |
||||
unsigned report_id; |
||||
}; |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVCODEC_DXVA2_H */ |
||||
@ -0,0 +1,46 @@ |
||||
/*
|
||||
* JNI public API functions |
||||
* |
||||
* Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.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 AVCODEC_JNI_H |
||||
#define AVCODEC_JNI_H |
||||
|
||||
/*
|
||||
* Manually set a Java virtual machine which will be used to retrieve the JNI |
||||
* environment. Once a Java VM is set it cannot be changed afterwards, meaning |
||||
* you can call multiple times av_jni_set_java_vm with the same Java VM pointer |
||||
* however it will error out if you try to set a different Java VM. |
||||
* |
||||
* @param vm Java virtual machine |
||||
* @param log_ctx context used for logging, can be NULL |
||||
* @return 0 on success, < 0 otherwise |
||||
*/ |
||||
int av_jni_set_java_vm(void *vm, void *log_ctx); |
||||
|
||||
/*
|
||||
* Get the Java virtual machine which has been set with av_jni_set_java_vm. |
||||
* |
||||
* @param vm Java virtual machine |
||||
* @return a pointer to the Java virtual machine |
||||
*/ |
||||
void *av_jni_get_java_vm(void *log_ctx); |
||||
|
||||
#endif /* AVCODEC_JNI_H */ |
||||
@ -0,0 +1,255 @@ |
||||
/*
|
||||
* simple math operations |
||||
* Copyright (c) 2001, 2002 Fabrice Bellard |
||||
* Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al |
||||
* |
||||
* 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_MATHOPS_H |
||||
#define AVCODEC_MATHOPS_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "libavutil/attributes_internal.h" |
||||
#include "libavutil/common.h" |
||||
#include "config.h" |
||||
|
||||
#define MAX_NEG_CROP 1024 |
||||
|
||||
extern const uint32_t ff_inverse[257]; |
||||
extern const uint8_t ff_log2_run[41]; |
||||
extern const uint8_t ff_sqrt_tab[256]; |
||||
extern const uint8_t attribute_visibility_hidden ff_crop_tab[256 + 2 * MAX_NEG_CROP]; |
||||
extern const uint8_t ff_zigzag_direct[64]; |
||||
extern const uint8_t ff_zigzag_scan[16+1]; |
||||
|
||||
#if ARCH_ARM |
||||
# include "arm/mathops.h" |
||||
#elif ARCH_AVR32 |
||||
# include "avr32/mathops.h" |
||||
#elif ARCH_MIPS |
||||
# include "mips/mathops.h" |
||||
#elif ARCH_PPC |
||||
# include "ppc/mathops.h" |
||||
#elif ARCH_X86 |
||||
# include "x86/mathops.h" |
||||
#endif |
||||
|
||||
/* generic implementation */ |
||||
|
||||
#ifndef MUL64 |
||||
# define MUL64(a,b) ((int64_t)(a) * (int64_t)(b)) |
||||
#endif |
||||
|
||||
#ifndef MULL |
||||
# define MULL(a,b,s) (MUL64(a, b) >> (s)) |
||||
#endif |
||||
|
||||
#ifndef MULH |
||||
static av_always_inline int MULH(int a, int b){ |
||||
return MUL64(a, b) >> 32; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef UMULH |
||||
static av_always_inline unsigned UMULH(unsigned a, unsigned b){ |
||||
return ((uint64_t)(a) * (uint64_t)(b))>>32; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef MAC64 |
||||
# define MAC64(d, a, b) ((d) += MUL64(a, b)) |
||||
#endif |
||||
|
||||
#ifndef MLS64 |
||||
# define MLS64(d, a, b) ((d) -= MUL64(a, b)) |
||||
#endif |
||||
|
||||
/* signed 16x16 -> 32 multiply add accumulate */ |
||||
#ifndef MAC16 |
||||
# define MAC16(rt, ra, rb) rt += (ra) * (rb) |
||||
#endif |
||||
|
||||
/* signed 16x16 -> 32 multiply */ |
||||
#ifndef MUL16 |
||||
# define MUL16(ra, rb) ((ra) * (rb)) |
||||
#endif |
||||
|
||||
#ifndef MLS16 |
||||
# define MLS16(rt, ra, rb) ((rt) -= (ra) * (rb)) |
||||
#endif |
||||
|
||||
/* median of 3 */ |
||||
#ifndef mid_pred |
||||
#define mid_pred mid_pred |
||||
static inline av_const int mid_pred(int a, int b, int c) |
||||
{ |
||||
if(a>b){ |
||||
if(c>b){ |
||||
if(c>a) b=a; |
||||
else b=c; |
||||
} |
||||
}else{ |
||||
if(b>c){ |
||||
if(c>a) b=c; |
||||
else b=a; |
||||
} |
||||
} |
||||
return b; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef median4 |
||||
#define median4 median4 |
||||
static inline av_const int median4(int a, int b, int c, int d) |
||||
{ |
||||
if (a < b) { |
||||
if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2; |
||||
else return (FFMIN(b, c) + FFMAX(a, d)) / 2; |
||||
} else { |
||||
if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2; |
||||
else return (FFMIN(a, c) + FFMAX(b, d)) / 2; |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
#define FF_SIGNBIT(x) ((x) >> CHAR_BIT * sizeof(x) - 1) |
||||
|
||||
#ifndef sign_extend |
||||
static inline av_const int sign_extend(int val, unsigned bits) |
||||
{ |
||||
unsigned shift = 8 * sizeof(int) - bits; |
||||
union { unsigned u; int s; } v = { (unsigned) val << shift }; |
||||
return v.s >> shift; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef sign_extend64 |
||||
static inline av_const int64_t sign_extend64(int64_t val, unsigned bits) |
||||
{ |
||||
unsigned shift = 8 * sizeof(int64_t) - bits; |
||||
union { uint64_t u; int64_t s; } v = { (uint64_t) val << shift }; |
||||
return v.s >> shift; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef zero_extend |
||||
static inline av_const unsigned zero_extend(unsigned val, unsigned bits) |
||||
{ |
||||
return (val << ((8 * sizeof(int)) - bits)) >> ((8 * sizeof(int)) - bits); |
||||
} |
||||
#endif |
||||
|
||||
#ifndef COPY3_IF_LT |
||||
#define COPY3_IF_LT(x, y, a, b, c, d)\ |
||||
if ((y) < (x)) {\
|
||||
(x) = (y);\
|
||||
(a) = (b);\
|
||||
(c) = (d);\
|
||||
} |
||||
#endif |
||||
|
||||
#ifndef MASK_ABS |
||||
#define MASK_ABS(mask, level) do { \ |
||||
mask = level >> 31; \
|
||||
level = (level ^ mask) - mask; \
|
||||
} while (0) |
||||
#endif |
||||
|
||||
#ifndef NEG_SSR32 |
||||
# define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s))) |
||||
#endif |
||||
|
||||
#ifndef NEG_USR32 |
||||
# define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s))) |
||||
#endif |
||||
|
||||
#if HAVE_BIGENDIAN |
||||
# ifndef PACK_2U8 |
||||
# define PACK_2U8(a,b) (((a) << 8) | (b)) |
||||
# endif |
||||
# ifndef PACK_4U8 |
||||
# define PACK_4U8(a,b,c,d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d)) |
||||
# endif |
||||
# ifndef PACK_2U16 |
||||
# define PACK_2U16(a,b) (((a) << 16) | (b)) |
||||
# endif |
||||
#else |
||||
# ifndef PACK_2U8 |
||||
# define PACK_2U8(a,b) (((b) << 8) | (a)) |
||||
# endif |
||||
# ifndef PACK_4U2 |
||||
# define PACK_4U8(a,b,c,d) (((d) << 24) | ((c) << 16) | ((b) << 8) | (a)) |
||||
# endif |
||||
# ifndef PACK_2U16 |
||||
# define PACK_2U16(a,b) (((b) << 16) | (a)) |
||||
# endif |
||||
#endif |
||||
|
||||
#ifndef PACK_2S8 |
||||
# define PACK_2S8(a,b) PACK_2U8((a)&255, (b)&255) |
||||
#endif |
||||
#ifndef PACK_4S8 |
||||
# define PACK_4S8(a,b,c,d) PACK_4U8((a)&255, (b)&255, (c)&255, (d)&255) |
||||
#endif |
||||
#ifndef PACK_2S16 |
||||
# define PACK_2S16(a,b) PACK_2U16((a)&0xffff, (b)&0xffff) |
||||
#endif |
||||
|
||||
#ifndef FASTDIV |
||||
# define FASTDIV(a,b) ((uint32_t)((((uint64_t)a) * ff_inverse[b]) >> 32)) |
||||
#endif /* FASTDIV */ |
||||
|
||||
#ifndef ff_sqrt |
||||
#define ff_sqrt ff_sqrt |
||||
static inline av_const unsigned int ff_sqrt(unsigned int a) |
||||
{ |
||||
unsigned int b; |
||||
|
||||
if (a < 255) return (ff_sqrt_tab[a + 1] - 1) >> 4; |
||||
else if (a < (1 << 12)) b = ff_sqrt_tab[a >> 4] >> 2; |
||||
#if !CONFIG_SMALL |
||||
else if (a < (1 << 14)) b = ff_sqrt_tab[a >> 6] >> 1; |
||||
else if (a < (1 << 16)) b = ff_sqrt_tab[a >> 8] ; |
||||
#endif |
||||
else { |
||||
int s = av_log2_16bit(a >> 16) >> 1; |
||||
unsigned int c = a >> (s + 2); |
||||
b = ff_sqrt_tab[c >> (s + 8)]; |
||||
b = FASTDIV(c,b) + (b << s); |
||||
} |
||||
|
||||
return b - (a < b * b); |
||||
} |
||||
#endif |
||||
|
||||
static inline av_const float ff_sqrf(float a) |
||||
{ |
||||
return a*a; |
||||
} |
||||
|
||||
static inline int8_t ff_u8_to_s8(uint8_t a) |
||||
{ |
||||
union { |
||||
uint8_t u8; |
||||
int8_t s8; |
||||
} b; |
||||
b.u8 = a; |
||||
return b.s8; |
||||
} |
||||
|
||||
#endif /* AVCODEC_MATHOPS_H */ |
||||
@ -0,0 +1,103 @@ |
||||
/*
|
||||
* Android MediaCodec public API |
||||
* |
||||
* Copyright (c) 2016 Matthieu Bouron <matthieu.bouron stupeflix.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 AVCODEC_MEDIACODEC_H |
||||
#define AVCODEC_MEDIACODEC_H |
||||
|
||||
#include "libavcodec/avcodec.h" |
||||
|
||||
/**
|
||||
* This structure holds a reference to a android/view/Surface object that will |
||||
* be used as output by the decoder. |
||||
* |
||||
*/ |
||||
typedef struct AVMediaCodecContext { |
||||
|
||||
/**
|
||||
* android/view/Surface object reference. |
||||
*/ |
||||
void *surface; |
||||
|
||||
} AVMediaCodecContext; |
||||
|
||||
/**
|
||||
* Allocate and initialize a MediaCodec context. |
||||
* |
||||
* When decoding with MediaCodec is finished, the caller must free the |
||||
* MediaCodec context with av_mediacodec_default_free. |
||||
* |
||||
* @return a pointer to a newly allocated AVMediaCodecContext on success, NULL otherwise |
||||
*/ |
||||
AVMediaCodecContext *av_mediacodec_alloc_context(void); |
||||
|
||||
/**
|
||||
* Convenience function that sets up the MediaCodec context. |
||||
* |
||||
* @param avctx codec context |
||||
* @param ctx MediaCodec context to initialize |
||||
* @param surface reference to an android/view/Surface |
||||
* @return 0 on success, < 0 otherwise |
||||
*/ |
||||
int av_mediacodec_default_init(AVCodecContext *avctx, AVMediaCodecContext *ctx, void *surface); |
||||
|
||||
/**
|
||||
* This function must be called to free the MediaCodec context initialized with |
||||
* av_mediacodec_default_init(). |
||||
* |
||||
* @param avctx codec context |
||||
*/ |
||||
void av_mediacodec_default_free(AVCodecContext *avctx); |
||||
|
||||
/**
|
||||
* Opaque structure representing a MediaCodec buffer to render. |
||||
*/ |
||||
typedef struct MediaCodecBuffer AVMediaCodecBuffer; |
||||
|
||||
/**
|
||||
* Release a MediaCodec buffer and render it to the surface that is associated |
||||
* with the decoder. This function should only be called once on a given |
||||
* buffer, once released the underlying buffer returns to the codec, thus |
||||
* subsequent calls to this function will have no effect. |
||||
* |
||||
* @param buffer the buffer to render |
||||
* @param render 1 to release and render the buffer to the surface or 0 to |
||||
* discard the buffer |
||||
* @return 0 on success, < 0 otherwise |
||||
*/ |
||||
int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render); |
||||
|
||||
/**
|
||||
* Release a MediaCodec buffer and render it at the given time to the surface |
||||
* that is associated with the decoder. The timestamp must be within one second |
||||
* of the current `java/lang/System#nanoTime()` (which is implemented using |
||||
* `CLOCK_MONOTONIC` on Android). See the Android MediaCodec documentation |
||||
* of [`android/media/MediaCodec#releaseOutputBuffer(int,long)`][0] for more details. |
||||
* |
||||
* @param buffer the buffer to render |
||||
* @param time timestamp in nanoseconds of when to render the buffer |
||||
* @return 0 on success, < 0 otherwise |
||||
* |
||||
* [0]: https://developer.android.com/reference/android/media/MediaCodec#releaseOutputBuffer(int,%20long)
|
||||
*/ |
||||
int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time); |
||||
|
||||
#endif /* AVCODEC_MEDIACODEC_H */ |
||||
@ -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=main/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
|
||||
@ -0,0 +1,109 @@ |
||||
/*
|
||||
* Intel MediaSDK QSV 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_QSV_H |
||||
#define AVCODEC_QSV_H |
||||
|
||||
#include <mfxvideo.h> |
||||
|
||||
#include "libavutil/buffer.h" |
||||
|
||||
/**
|
||||
* This struct is used for communicating QSV parameters between libavcodec and |
||||
* the caller. It is managed by the caller and must be assigned to |
||||
* AVCodecContext.hwaccel_context. |
||||
* - decoding: hwaccel_context must be set on return from the get_format() |
||||
* callback |
||||
* - encoding: hwaccel_context must be set before avcodec_open2() |
||||
*/ |
||||
typedef struct AVQSVContext { |
||||
/**
|
||||
* If non-NULL, the session to use for encoding or decoding. |
||||
* Otherwise, libavcodec will try to create an internal session. |
||||
*/ |
||||
mfxSession session; |
||||
|
||||
/**
|
||||
* The IO pattern to use. |
||||
*/ |
||||
int iopattern; |
||||
|
||||
/**
|
||||
* Extra buffers to pass to encoder or decoder initialization. |
||||
*/ |
||||
mfxExtBuffer **ext_buffers; |
||||
int nb_ext_buffers; |
||||
|
||||
/**
|
||||
* Encoding only. If this field is set to non-zero by the caller, libavcodec |
||||
* will create an mfxExtOpaqueSurfaceAlloc extended buffer and pass it to |
||||
* the encoder initialization. This only makes sense if iopattern is also |
||||
* set to MFX_IOPATTERN_IN_OPAQUE_MEMORY. |
||||
* |
||||
* The number of allocated opaque surfaces will be the sum of the number |
||||
* required by the encoder and the user-provided value nb_opaque_surfaces. |
||||
* The array of the opaque surfaces will be exported to the caller through |
||||
* the opaque_surfaces field. |
||||
* |
||||
* The caller must set this field to zero for oneVPL (MFX_VERSION >= 2.0) |
||||
*/ |
||||
int opaque_alloc; |
||||
|
||||
/**
|
||||
* Encoding only, and only if opaque_alloc is set to non-zero. Before |
||||
* calling avcodec_open2(), the caller should set this field to the number |
||||
* of extra opaque surfaces to allocate beyond what is required by the |
||||
* encoder. |
||||
* |
||||
* On return from avcodec_open2(), this field will be set by libavcodec to |
||||
* the total number of allocated opaque surfaces. |
||||
*/ |
||||
int nb_opaque_surfaces; |
||||
|
||||
/**
|
||||
* Encoding only, and only if opaque_alloc is set to non-zero. On return |
||||
* from avcodec_open2(), this field will be used by libavcodec to export the |
||||
* array of the allocated opaque surfaces to the caller, so they can be |
||||
* passed to other parts of the pipeline. |
||||
* |
||||
* The buffer reference exported here is owned and managed by libavcodec, |
||||
* the callers should make their own reference with av_buffer_ref() and free |
||||
* it with av_buffer_unref() when it is no longer needed. |
||||
* |
||||
* The buffer data is an nb_opaque_surfaces-sized array of mfxFrameSurface1. |
||||
*/ |
||||
AVBufferRef *opaque_surfaces; |
||||
|
||||
/**
|
||||
* Encoding only, and only if opaque_alloc is set to non-zero. On return |
||||
* from avcodec_open2(), this field will be set to the surface type used in |
||||
* the opaque allocation request. |
||||
*/ |
||||
int opaque_alloc_type; |
||||
} AVQSVContext; |
||||
|
||||
/**
|
||||
* Allocate a new context. |
||||
* |
||||
* It must be freed by the caller with av_free(). |
||||
*/ |
||||
AVQSVContext *av_qsv_alloc_context(void); |
||||
|
||||
#endif /* AVCODEC_QSV_H */ |
||||
@ -0,0 +1,157 @@ |
||||
/*
|
||||
* The Video Decode and Presentation API for UNIX (VDPAU) is used for |
||||
* hardware-accelerated decoding of MPEG-1/2, H.264 and VC-1. |
||||
* |
||||
* Copyright (C) 2008 NVIDIA |
||||
* |
||||
* 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_VDPAU_H |
||||
#define AVCODEC_VDPAU_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_codec_hwaccel_vdpau |
||||
* Public libavcodec VDPAU header. |
||||
*/ |
||||
|
||||
|
||||
/**
|
||||
* @defgroup lavc_codec_hwaccel_vdpau VDPAU Decoder and Renderer |
||||
* @ingroup lavc_codec_hwaccel |
||||
* |
||||
* VDPAU hardware acceleration has two modules |
||||
* - VDPAU decoding |
||||
* - VDPAU presentation |
||||
* |
||||
* The VDPAU decoding module parses all headers using FFmpeg |
||||
* parsing mechanisms and uses VDPAU for the actual decoding. |
||||
* |
||||
* As per the current implementation, the actual decoding |
||||
* and rendering (API calls) are done as part of the VDPAU |
||||
* presentation (vo_vdpau.c) module. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#include <vdpau/vdpau.h> |
||||
|
||||
#include "libavutil/avconfig.h" |
||||
#include "libavutil/attributes.h" |
||||
|
||||
#include "avcodec.h" |
||||
|
||||
struct AVCodecContext; |
||||
struct AVFrame; |
||||
|
||||
typedef int (*AVVDPAU_Render2)(struct AVCodecContext *, struct AVFrame *, |
||||
const VdpPictureInfo *, uint32_t, |
||||
const VdpBitstreamBuffer *); |
||||
|
||||
/**
|
||||
* This structure is used to share data between the libavcodec library and |
||||
* the client video application. |
||||
* The user shall allocate the structure via the av_alloc_vdpau_hwaccel |
||||
* function and make it available as |
||||
* AVCodecContext.hwaccel_context. Members can be set by the user once |
||||
* during initialization or through each AVCodecContext.get_buffer() |
||||
* function call. In any case, they must be valid prior to calling |
||||
* decoding functions. |
||||
* |
||||
* The size of this structure is not a part of the public ABI and must not |
||||
* be used outside of libavcodec. Use av_vdpau_alloc_context() to allocate an |
||||
* AVVDPAUContext. |
||||
*/ |
||||
typedef struct AVVDPAUContext { |
||||
/**
|
||||
* VDPAU decoder handle |
||||
* |
||||
* Set by user. |
||||
*/ |
||||
VdpDecoder decoder; |
||||
|
||||
/**
|
||||
* VDPAU decoder render callback |
||||
* |
||||
* Set by the user. |
||||
*/ |
||||
VdpDecoderRender *render; |
||||
|
||||
AVVDPAU_Render2 render2; |
||||
} AVVDPAUContext; |
||||
|
||||
/**
|
||||
* @brief allocation function for AVVDPAUContext |
||||
* |
||||
* Allows extending the struct without breaking API/ABI |
||||
*/ |
||||
AVVDPAUContext *av_alloc_vdpaucontext(void); |
||||
|
||||
AVVDPAU_Render2 av_vdpau_hwaccel_get_render2(const AVVDPAUContext *); |
||||
void av_vdpau_hwaccel_set_render2(AVVDPAUContext *, AVVDPAU_Render2); |
||||
|
||||
/**
|
||||
* Associate a VDPAU device with a codec context for hardware acceleration. |
||||
* This function is meant to be called from the get_format() codec callback, |
||||
* or earlier. It can also be called after avcodec_flush_buffers() to change |
||||
* the underlying VDPAU device mid-stream (e.g. to recover from non-transparent |
||||
* display preemption). |
||||
* |
||||
* @note get_format() must return AV_PIX_FMT_VDPAU if this function completes |
||||
* successfully. |
||||
* |
||||
* @param avctx decoding context whose get_format() callback is invoked |
||||
* @param device VDPAU device handle to use for hardware acceleration |
||||
* @param get_proc_address VDPAU device driver |
||||
* @param flags zero of more OR'd AV_HWACCEL_FLAG_* flags |
||||
* |
||||
* @return 0 on success, an AVERROR code on failure. |
||||
*/ |
||||
int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device, |
||||
VdpGetProcAddress *get_proc_address, unsigned flags); |
||||
|
||||
/**
|
||||
* Gets the parameters to create an adequate VDPAU video surface for the codec |
||||
* context using VDPAU hardware decoding acceleration. |
||||
* |
||||
* @note Behavior is undefined if the context was not successfully bound to a |
||||
* VDPAU device using av_vdpau_bind_context(). |
||||
* |
||||
* @param avctx the codec context being used for decoding the stream |
||||
* @param type storage space for the VDPAU video surface chroma type |
||||
* (or NULL to ignore) |
||||
* @param width storage space for the VDPAU video surface pixel width |
||||
* (or NULL to ignore) |
||||
* @param height storage space for the VDPAU video surface pixel height |
||||
* (or NULL to ignore) |
||||
* |
||||
* @return 0 on success, a negative AVERROR code on failure. |
||||
*/ |
||||
int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type, |
||||
uint32_t *width, uint32_t *height); |
||||
|
||||
/**
|
||||
* Allocate an AVVDPAUContext. |
||||
* |
||||
* @return Newly-allocated AVVDPAUContext or NULL on failure. |
||||
*/ |
||||
AVVDPAUContext *av_vdpau_alloc_context(void); |
||||
|
||||
/** @} */ |
||||
|
||||
#endif /* AVCODEC_VDPAU_H */ |
||||
@ -0,0 +1,45 @@ |
||||
/*
|
||||
* 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_H |
||||
#define AVCODEC_VERSION_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup libavc |
||||
* Libavcodec version macros. |
||||
*/ |
||||
|
||||
#include "libavutil/version.h" |
||||
|
||||
#include "version_major.h" |
||||
|
||||
#define LIBAVCODEC_VERSION_MINOR 3 |
||||
#define LIBAVCODEC_VERSION_MICRO 100 |
||||
|
||||
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ |
||||
LIBAVCODEC_VERSION_MINOR, \
|
||||
LIBAVCODEC_VERSION_MICRO) |
||||
#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \ |
||||
LIBAVCODEC_VERSION_MINOR, \
|
||||
LIBAVCODEC_VERSION_MICRO) |
||||
#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT |
||||
|
||||
#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) |
||||
|
||||
#endif /* AVCODEC_VERSION_H */ |
||||
@ -0,0 +1,52 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_VERSION_MAJOR_H |
||||
#define AVCODEC_VERSION_MAJOR_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup libavc |
||||
* Libavcodec version macros. |
||||
*/ |
||||
|
||||
#define LIBAVCODEC_VERSION_MAJOR 60 |
||||
|
||||
/**
|
||||
* FF_API_* defines may be placed below to indicate public API that will be |
||||
* dropped at a future version bump. The defines themselves are not part of |
||||
* the public API and may change, break or disappear at any time. |
||||
* |
||||
* @note, when bumping the major version it is recommended to manually |
||||
* disable each FF_API_* in its own commit instead of disabling them all |
||||
* at once through the bump. This improves the git bisect-ability of the change. |
||||
*/ |
||||
|
||||
#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_IDCT_NONE (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_SVTAV1_OPTS (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_AYUV_CODECID (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_VT_OUTPUT_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_AVCODEC_CHROMA_POS (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_VT_HWACCEL_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
#define FF_API_AVCTX_FRAME_NUMBER (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
|
||||
// reminder to remove CrystalHD decoders on next major bump
|
||||
#define FF_CODEC_CRYSTAL_HD (LIBAVCODEC_VERSION_MAJOR < 61) |
||||
|
||||
#endif /* AVCODEC_VERSION_MAJOR_H */ |
||||
@ -0,0 +1,150 @@ |
||||
/*
|
||||
* Videotoolbox hardware acceleration |
||||
* |
||||
* copyright (c) 2012 Sebastien Zwickert |
||||
* |
||||
* 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_VIDEOTOOLBOX_H |
||||
#define AVCODEC_VIDEOTOOLBOX_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_codec_hwaccel_videotoolbox |
||||
* Public libavcodec Videotoolbox header. |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavc_codec_hwaccel_videotoolbox VideoToolbox Decoder |
||||
* @ingroup lavc_codec_hwaccel |
||||
* |
||||
* Hardware accelerated decoding using VideoToolbox on Apple Platforms |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#define Picture QuickdrawPicture |
||||
#include <VideoToolbox/VideoToolbox.h> |
||||
#undef Picture |
||||
|
||||
#include "libavcodec/avcodec.h" |
||||
|
||||
#include "libavutil/attributes.h" |
||||
|
||||
/**
|
||||
* This struct holds all the information that needs to be passed |
||||
* between the caller and libavcodec for initializing Videotoolbox decoding. |
||||
* Its size is not a part of the public ABI, it must be allocated with |
||||
* av_videotoolbox_alloc_context() and freed with av_free(). |
||||
*/ |
||||
typedef struct AVVideotoolboxContext { |
||||
/**
|
||||
* Videotoolbox decompression session object. |
||||
*/ |
||||
VTDecompressionSessionRef session; |
||||
|
||||
#if FF_API_VT_OUTPUT_CALLBACK |
||||
/**
|
||||
* The output callback that must be passed to the session. |
||||
* Set by av_videottoolbox_default_init() |
||||
*/ |
||||
attribute_deprecated |
||||
VTDecompressionOutputCallback output_callback; |
||||
#endif |
||||
|
||||
/**
|
||||
* CVPixelBuffer Format Type that Videotoolbox will use for decoded frames. |
||||
* set by the caller. If this is set to 0, then no specific format is |
||||
* requested from the decoder, and its native format is output. |
||||
*/ |
||||
OSType cv_pix_fmt_type; |
||||
|
||||
/**
|
||||
* CoreMedia Format Description that Videotoolbox will use to create the decompression session. |
||||
*/ |
||||
CMVideoFormatDescriptionRef cm_fmt_desc; |
||||
|
||||
/**
|
||||
* CoreMedia codec type that Videotoolbox will use to create the decompression session. |
||||
*/ |
||||
int cm_codec_type; |
||||
} AVVideotoolboxContext; |
||||
|
||||
#if FF_API_VT_HWACCEL_CONTEXT |
||||
|
||||
/**
|
||||
* Allocate and initialize a Videotoolbox context. |
||||
* |
||||
* This function should be called from the get_format() callback when the caller |
||||
* selects the AV_PIX_FMT_VIDETOOLBOX format. The caller must then create |
||||
* the decoder object (using the output callback provided by libavcodec) that |
||||
* will be used for Videotoolbox-accelerated decoding. |
||||
* |
||||
* When decoding with Videotoolbox is finished, the caller must destroy the decoder |
||||
* object and free the Videotoolbox context using av_free(). |
||||
* |
||||
* @return the newly allocated context or NULL on failure |
||||
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead. |
||||
*/ |
||||
attribute_deprecated |
||||
AVVideotoolboxContext *av_videotoolbox_alloc_context(void); |
||||
|
||||
/**
|
||||
* This is a convenience function that creates and sets up the Videotoolbox context using |
||||
* an internal implementation. |
||||
* |
||||
* @param avctx the corresponding codec context |
||||
* |
||||
* @return >= 0 on success, a negative AVERROR code on failure |
||||
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead. |
||||
*/ |
||||
attribute_deprecated |
||||
int av_videotoolbox_default_init(AVCodecContext *avctx); |
||||
|
||||
/**
|
||||
* This is a convenience function that creates and sets up the Videotoolbox context using |
||||
* an internal implementation. |
||||
* |
||||
* @param avctx the corresponding codec context |
||||
* @param vtctx the Videotoolbox context to use |
||||
* |
||||
* @return >= 0 on success, a negative AVERROR code on failure |
||||
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead. |
||||
*/ |
||||
attribute_deprecated |
||||
int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *vtctx); |
||||
|
||||
/**
|
||||
* This function must be called to free the Videotoolbox context initialized with |
||||
* av_videotoolbox_default_init(). |
||||
* |
||||
* @param avctx the corresponding codec context |
||||
* @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead. |
||||
*/ |
||||
attribute_deprecated |
||||
void av_videotoolbox_default_free(AVCodecContext *avctx); |
||||
|
||||
#endif /* FF_API_VT_HWACCEL_CONTEXT */ |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVCODEC_VIDEOTOOLBOX_H */ |
||||
@ -0,0 +1,74 @@ |
||||
/*
|
||||
* 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 |
||||
* A public API for Vorbis parsing |
||||
* |
||||
* Determines the duration for each packet. |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_VORBIS_PARSER_H |
||||
#define AVCODEC_VORBIS_PARSER_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
typedef struct AVVorbisParseContext AVVorbisParseContext; |
||||
|
||||
/**
|
||||
* Allocate and initialize the Vorbis parser using headers in the extradata. |
||||
*/ |
||||
AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata, |
||||
int extradata_size); |
||||
|
||||
/**
|
||||
* Free the parser and everything associated with it. |
||||
*/ |
||||
void av_vorbis_parse_free(AVVorbisParseContext **s); |
||||
|
||||
#define VORBIS_FLAG_HEADER 0x00000001 |
||||
#define VORBIS_FLAG_COMMENT 0x00000002 |
||||
#define VORBIS_FLAG_SETUP 0x00000004 |
||||
|
||||
/**
|
||||
* Get the duration for a Vorbis packet. |
||||
* |
||||
* If @p flags is @c NULL, |
||||
* special frames are considered invalid. |
||||
* |
||||
* @param s Vorbis parser context |
||||
* @param buf buffer containing a Vorbis frame |
||||
* @param buf_size size of the buffer |
||||
* @param flags flags for special frames |
||||
*/ |
||||
int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf, |
||||
int buf_size, int *flags); |
||||
|
||||
/**
|
||||
* Get the duration for a Vorbis packet. |
||||
* |
||||
* @param s Vorbis parser context |
||||
* @param buf buffer containing a Vorbis frame |
||||
* @param buf_size size of the buffer |
||||
*/ |
||||
int av_vorbis_parse_frame(AVVorbisParseContext *s, const uint8_t *buf, |
||||
int buf_size); |
||||
|
||||
void av_vorbis_parse_reset(AVVorbisParseContext *s); |
||||
|
||||
#endif /* AVCODEC_VORBIS_PARSER_H */ |
||||
@ -0,0 +1,133 @@ |
||||
/*
|
||||
* simple math operations |
||||
* Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al |
||||
* |
||||
* 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_X86_MATHOPS_H |
||||
#define AVCODEC_X86_MATHOPS_H |
||||
|
||||
#include "config.h" |
||||
|
||||
#include "libavutil/common.h" |
||||
#include "libavutil/x86/asm.h" |
||||
|
||||
#if HAVE_INLINE_ASM |
||||
|
||||
#if ARCH_X86_32 |
||||
|
||||
#define MULL MULL |
||||
static av_always_inline av_const int MULL(int a, int b, unsigned shift) |
||||
{ |
||||
int rt, dummy; |
||||
__asm__ ( |
||||
"imull %3 \n\t" |
||||
"shrdl %4, %%edx, %%eax \n\t" |
||||
:"=a"(rt), "=d"(dummy) |
||||
:"a"(a), "rm"(b), "ci"((uint8_t)shift) |
||||
); |
||||
return rt; |
||||
} |
||||
|
||||
#define MULH MULH |
||||
static av_always_inline av_const int MULH(int a, int b) |
||||
{ |
||||
int rt, dummy; |
||||
__asm__ ( |
||||
"imull %3" |
||||
:"=d"(rt), "=a"(dummy) |
||||
:"a"(a), "rm"(b) |
||||
); |
||||
return rt; |
||||
} |
||||
|
||||
#define MUL64 MUL64 |
||||
static av_always_inline av_const int64_t MUL64(int a, int b) |
||||
{ |
||||
int64_t rt; |
||||
__asm__ ( |
||||
"imull %2" |
||||
:"=A"(rt) |
||||
:"a"(a), "rm"(b) |
||||
); |
||||
return rt; |
||||
} |
||||
|
||||
#endif /* ARCH_X86_32 */ |
||||
|
||||
#if HAVE_I686 |
||||
/* median of 3 */ |
||||
#define mid_pred mid_pred |
||||
static inline av_const int mid_pred(int a, int b, int c) |
||||
{ |
||||
int i=b; |
||||
__asm__ ( |
||||
"cmp %2, %1 \n\t" |
||||
"cmovg %1, %0 \n\t" |
||||
"cmovg %2, %1 \n\t" |
||||
"cmp %3, %1 \n\t" |
||||
"cmovl %3, %1 \n\t" |
||||
"cmp %1, %0 \n\t" |
||||
"cmovg %1, %0 \n\t" |
||||
:"+&r"(i), "+&r"(a) |
||||
:"r"(b), "r"(c) |
||||
); |
||||
return i; |
||||
} |
||||
|
||||
#if HAVE_6REGS |
||||
#define COPY3_IF_LT(x, y, a, b, c, d)\ |
||||
__asm__ volatile(\
|
||||
"cmpl %0, %3 \n\t"\
|
||||
"cmovl %3, %0 \n\t"\
|
||||
"cmovl %4, %1 \n\t"\
|
||||
"cmovl %5, %2 \n\t"\
|
||||
: "+&r" (x), "+&r" (a), "+r" (c)\
|
||||
: "r" (y), "r" (b), "r" (d)\
|
||||
); |
||||
#endif /* HAVE_6REGS */ |
||||
|
||||
#endif /* HAVE_I686 */ |
||||
|
||||
#define MASK_ABS(mask, level) \ |
||||
__asm__ ("cdq \n\t" \
|
||||
"xorl %1, %0 \n\t" \
|
||||
"subl %1, %0 \n\t" \
|
||||
: "+a"(level), "=&d"(mask)) |
||||
|
||||
// avoid +32 for shift optimization (gcc should do that ...)
|
||||
#define NEG_SSR32 NEG_SSR32 |
||||
static inline int32_t NEG_SSR32( int32_t a, int8_t s){ |
||||
__asm__ ("sarl %1, %0\n\t" |
||||
: "+r" (a) |
||||
: "ic" ((uint8_t)(-s)) |
||||
); |
||||
return a; |
||||
} |
||||
|
||||
#define NEG_USR32 NEG_USR32 |
||||
static inline uint32_t NEG_USR32(uint32_t a, int8_t s){ |
||||
__asm__ ("shrl %1, %0\n\t" |
||||
: "+r" (a) |
||||
: "ic" ((uint8_t)(-s)) |
||||
); |
||||
return a; |
||||
} |
||||
|
||||
#endif /* HAVE_INLINE_ASM */ |
||||
#endif /* AVCODEC_X86_MATHOPS_H */ |
||||
@ -0,0 +1,171 @@ |
||||
/*
|
||||
* Copyright (C) 2003 Ivan Kalvachev |
||||
* |
||||
* 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_XVMC_H |
||||
#define AVCODEC_XVMC_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_codec_hwaccel_xvmc |
||||
* 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 "avcodec.h" |
||||
|
||||
/**
|
||||
* @defgroup lavc_codec_hwaccel_xvmc XvMC |
||||
* @ingroup lavc_codec_hwaccel |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#define AV_XVMC_ID 0x1DC711C0 /**< special value to ensure that regular pixel routines haven't corrupted the struct |
||||
the number is 1337 speak for the letters IDCT MCo (motion compensation) */ |
||||
|
||||
struct attribute_deprecated xvmc_pix_fmt { |
||||
/** The field contains the special constant value AV_XVMC_ID.
|
||||
It is used as a test that the application correctly uses the API, |
||||
and that there is no corruption caused by pixel routines. |
||||
- application - set during initialization |
||||
- libavcodec - unchanged |
||||
*/ |
||||
int xvmc_id; |
||||
|
||||
/** Pointer to the block array allocated by XvMCCreateBlocks().
|
||||
The array has to be freed by XvMCDestroyBlocks(). |
||||
Each group of 64 values represents one data block of differential |
||||
pixel information (in MoCo mode) or coefficients for IDCT. |
||||
- application - set the pointer during initialization |
||||
- libavcodec - fills coefficients/pixel data into the array |
||||
*/ |
||||
short* data_blocks; |
||||
|
||||
/** Pointer to the macroblock description array allocated by
|
||||
XvMCCreateMacroBlocks() and freed by XvMCDestroyMacroBlocks(). |
||||
- application - set the pointer during initialization |
||||
- libavcodec - fills description data into the array |
||||
*/ |
||||
XvMCMacroBlock* mv_blocks; |
||||
|
||||
/** Number of macroblock descriptions that can be stored in the mv_blocks
|
||||
array. |
||||
- application - set during initialization |
||||
- libavcodec - unchanged |
||||
*/ |
||||
int allocated_mv_blocks; |
||||
|
||||
/** Number of blocks that can be stored at once in the data_blocks array.
|
||||
- application - set during initialization |
||||
- libavcodec - unchanged |
||||
*/ |
||||
int allocated_data_blocks; |
||||
|
||||
/** Indicate that the hardware would interpret data_blocks as IDCT
|
||||
coefficients and perform IDCT on them. |
||||
- application - set during initialization |
||||
- libavcodec - unchanged |
||||
*/ |
||||
int idct; |
||||
|
||||
/** In MoCo mode it indicates that intra macroblocks are assumed to be in
|
||||
unsigned format; same as the XVMC_INTRA_UNSIGNED flag. |
||||
- application - set during initialization |
||||
- libavcodec - unchanged |
||||
*/ |
||||
int unsigned_intra; |
||||
|
||||
/** Pointer to the surface allocated by XvMCCreateSurface().
|
||||
It has to be freed by XvMCDestroySurface() on application exit. |
||||
It identifies the frame and its state on the video hardware. |
||||
- application - set during initialization |
||||
- libavcodec - unchanged |
||||
*/ |
||||
XvMCSurface* p_surface; |
||||
|
||||
/** Set by the decoder before calling ff_draw_horiz_band(),
|
||||
needed by the XvMCRenderSurface function. */ |
||||
//@{
|
||||
/** Pointer to the surface used as past reference
|
||||
- application - unchanged |
||||
- libavcodec - set |
||||
*/ |
||||
XvMCSurface* p_past_surface; |
||||
|
||||
/** Pointer to the surface used as future reference
|
||||
- application - unchanged |
||||
- libavcodec - set |
||||
*/ |
||||
XvMCSurface* p_future_surface; |
||||
|
||||
/** top/bottom field or frame
|
||||
- application - unchanged |
||||
- libavcodec - set |
||||
*/ |
||||
unsigned int picture_structure; |
||||
|
||||
/** XVMC_SECOND_FIELD - 1st or 2nd field in the sequence
|
||||
- application - unchanged |
||||
- libavcodec - set |
||||
*/ |
||||
unsigned int flags; |
||||
//}@
|
||||
|
||||
/** Number of macroblock descriptions in the mv_blocks array
|
||||
that have already been passed to the hardware. |
||||
- application - zeroes it on get_buffer(). |
||||
A successful ff_draw_horiz_band() may increment it |
||||
with filled_mb_block_num or zero both. |
||||
- libavcodec - unchanged |
||||
*/ |
||||
int start_mv_blocks_num; |
||||
|
||||
/** Number of new macroblock descriptions in the mv_blocks array (after
|
||||
start_mv_blocks_num) that are filled by libavcodec and have to be |
||||
passed to the hardware. |
||||
- application - zeroes it on get_buffer() or after successful |
||||
ff_draw_horiz_band(). |
||||
- libavcodec - increment with one of each stored MB |
||||
*/ |
||||
int filled_mv_blocks_num; |
||||
|
||||
/** Number of the next free data block; one data block consists of
|
||||
64 short values in the data_blocks array. |
||||
All blocks before this one have already been claimed by placing their |
||||
position into the corresponding block description structure field, |
||||
that are part of the mv_blocks array. |
||||
- application - zeroes it on get_buffer(). |
||||
A successful ff_draw_horiz_band() may zero it together |
||||
with start_mb_blocks_num. |
||||
- libavcodec - each decoded macroblock increases it by the number |
||||
of coded blocks it contains. |
||||
*/ |
||||
int next_free_data_block_num; |
||||
}; |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVCODEC_XVMC_H */ |
||||
@ -0,0 +1,32 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>CFBundleDevelopmentRegion</key> |
||||
<string>en</string> |
||||
<key>CFBundleExecutable</key> |
||||
<string>libavcodec</string> |
||||
<key>CFBundleIdentifier</key> |
||||
<string>com.arthenica.ffmpegkit.Libavcodec</string> |
||||
<key>CFBundleInfoDictionaryVersion</key> |
||||
<string>6.0</string> |
||||
<key>CFBundleName</key> |
||||
<string>libavcodec</string> |
||||
<key>CFBundlePackageType</key> |
||||
<string>FMWK</string> |
||||
<key>CFBundleShortVersionString</key> |
||||
<string>60.3.100</string> |
||||
<key>CFBundleVersion</key> |
||||
<string>60.3.100</string> |
||||
<key>CFBundleSignature</key> |
||||
<string>????</string> |
||||
<key>MinimumOSVersion</key> |
||||
<string>12.1</string> |
||||
<key>CFBundleSupportedPlatforms</key> |
||||
<array> |
||||
<string>iPhoneOS</string> |
||||
</array> |
||||
<key>NSPrincipalClass</key> |
||||
<string></string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,165 @@ |
||||
GNU LESSER GENERAL PUBLIC LICENSE |
||||
Version 3, 29 June 2007 |
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
|
||||
This version of the GNU Lesser General Public License incorporates |
||||
the terms and conditions of version 3 of the GNU General Public |
||||
License, supplemented by the additional permissions listed below. |
||||
|
||||
0. Additional Definitions. |
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser |
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU |
||||
General Public License. |
||||
|
||||
"The Library" refers to a covered work governed by this License, |
||||
other than an Application or a Combined Work as defined below. |
||||
|
||||
An "Application" is any work that makes use of an interface provided |
||||
by the Library, but which is not otherwise based on the Library. |
||||
Defining a subclass of a class defined by the Library is deemed a mode |
||||
of using an interface provided by the Library. |
||||
|
||||
A "Combined Work" is a work produced by combining or linking an |
||||
Application with the Library. The particular version of the Library |
||||
with which the Combined Work was made is also called the "Linked |
||||
Version". |
||||
|
||||
The "Minimal Corresponding Source" for a Combined Work means the |
||||
Corresponding Source for the Combined Work, excluding any source code |
||||
for portions of the Combined Work that, considered in isolation, are |
||||
based on the Application, and not on the Linked Version. |
||||
|
||||
The "Corresponding Application Code" for a Combined Work means the |
||||
object code and/or source code for the Application, including any data |
||||
and utility programs needed for reproducing the Combined Work from the |
||||
Application, but excluding the System Libraries of the Combined Work. |
||||
|
||||
1. Exception to Section 3 of the GNU GPL. |
||||
|
||||
You may convey a covered work under sections 3 and 4 of this License |
||||
without being bound by section 3 of the GNU GPL. |
||||
|
||||
2. Conveying Modified Versions. |
||||
|
||||
If you modify a copy of the Library, and, in your modifications, a |
||||
facility refers to a function or data to be supplied by an Application |
||||
that uses the facility (other than as an argument passed when the |
||||
facility is invoked), then you may convey a copy of the modified |
||||
version: |
||||
|
||||
a) under this License, provided that you make a good faith effort to |
||||
ensure that, in the event an Application does not supply the |
||||
function or data, the facility still operates, and performs |
||||
whatever part of its purpose remains meaningful, or |
||||
|
||||
b) under the GNU GPL, with none of the additional permissions of |
||||
this License applicable to that copy. |
||||
|
||||
3. Object Code Incorporating Material from Library Header Files. |
||||
|
||||
The object code form of an Application may incorporate material from |
||||
a header file that is part of the Library. You may convey such object |
||||
code under terms of your choice, provided that, if the incorporated |
||||
material is not limited to numerical parameters, data structure |
||||
layouts and accessors, or small macros, inline functions and templates |
||||
(ten or fewer lines in length), you do both of the following: |
||||
|
||||
a) Give prominent notice with each copy of the object code that the |
||||
Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
4. Combined Works. |
||||
|
||||
You may convey a Combined Work under terms of your choice that, |
||||
taken together, effectively do not restrict modification of the |
||||
portions of the Library contained in the Combined Work and reverse |
||||
engineering for debugging such modifications, if you also do each of |
||||
the following: |
||||
|
||||
a) Give prominent notice with each copy of the Combined Work that |
||||
the Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
c) For a Combined Work that displays copyright notices during |
||||
execution, include the copyright notice for the Library among |
||||
these notices, as well as a reference directing the user to the |
||||
copies of the GNU GPL and this license document. |
||||
|
||||
d) Do one of the following: |
||||
|
||||
0) Convey the Minimal Corresponding Source under the terms of this |
||||
License, and the Corresponding Application Code in a form |
||||
suitable for, and under terms that permit, the user to |
||||
recombine or relink the Application with a modified version of |
||||
the Linked Version to produce a modified Combined Work, in the |
||||
manner specified by section 6 of the GNU GPL for conveying |
||||
Corresponding Source. |
||||
|
||||
1) Use a suitable shared library mechanism for linking with the |
||||
Library. A suitable mechanism is one that (a) uses at run time |
||||
a copy of the Library already present on the user's computer |
||||
system, and (b) will operate properly with a modified version |
||||
of the Library that is interface-compatible with the Linked |
||||
Version. |
||||
|
||||
e) Provide Installation Information, but only if you would otherwise |
||||
be required to provide such information under section 6 of the |
||||
GNU GPL, and only to the extent that such information is |
||||
necessary to install and execute a modified version of the |
||||
Combined Work produced by recombining or relinking the |
||||
Application with a modified version of the Linked Version. (If |
||||
you use option 4d0, the Installation Information must accompany |
||||
the Minimal Corresponding Source and Corresponding Application |
||||
Code. If you use option 4d1, you must provide the Installation |
||||
Information in the manner specified by section 6 of the GNU GPL |
||||
for conveying Corresponding Source.) |
||||
|
||||
5. Combined Libraries. |
||||
|
||||
You may place library facilities that are a work based on the |
||||
Library side by side in a single library together with other library |
||||
facilities that are not Applications and are not covered by this |
||||
License, and convey such a combined library under terms of your |
||||
choice, if you do both of the following: |
||||
|
||||
a) Accompany the combined library with a copy of the same work based |
||||
on the Library, uncombined with any other library facilities, |
||||
conveyed under the terms of this License. |
||||
|
||||
b) Give prominent notice with the combined library that part of it |
||||
is a work based on the Library, and explaining where to find the |
||||
accompanying uncombined form of the same work. |
||||
|
||||
6. Revised Versions of the GNU Lesser General Public License. |
||||
|
||||
The Free Software Foundation may publish revised and/or new versions |
||||
of the GNU Lesser General Public License from time to time. Such new |
||||
versions will be similar in spirit to the present version, but may |
||||
differ in detail to address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the |
||||
Library as you received it specifies that a certain numbered version |
||||
of the GNU Lesser General Public License "or any later version" |
||||
applies to it, you have the option of following the terms and |
||||
conditions either of that published version or of any later version |
||||
published by the Free Software Foundation. If the Library as you |
||||
received it does not specify a version number of the GNU Lesser |
||||
General Public License, you may choose any version of the GNU Lesser |
||||
General Public License ever published by the Free Software Foundation. |
||||
|
||||
If the Library as you received it specifies that a proxy can decide |
||||
whether future versions of the GNU Lesser General Public License shall |
||||
apply, that proxy's public statement of acceptance of any version is |
||||
permanent authorization for you to choose that version for the |
||||
Library. |
||||
Binary file not shown.
@ -0,0 +1,27 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>AvailableLibraries</key> |
||||
<array> |
||||
<dict> |
||||
<key>BinaryPath</key> |
||||
<string>libavdevice.framework/libavdevice</string> |
||||
<key>LibraryIdentifier</key> |
||||
<string>ios-arm64</string> |
||||
<key>LibraryPath</key> |
||||
<string>libavdevice.framework</string> |
||||
<key>SupportedArchitectures</key> |
||||
<array> |
||||
<string>arm64</string> |
||||
</array> |
||||
<key>SupportedPlatform</key> |
||||
<string>ios</string> |
||||
</dict> |
||||
</array> |
||||
<key>CFBundlePackageType</key> |
||||
<string>XFWK</string> |
||||
<key>XCFrameworkFormatVersion</key> |
||||
<string>1.0</string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,397 @@ |
||||
/*
|
||||
* 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 AVDEVICE_AVDEVICE_H |
||||
#define AVDEVICE_AVDEVICE_H |
||||
|
||||
#include "version_major.h" |
||||
#ifndef HAVE_AV_CONFIG_H |
||||
/* When included as part of the ffmpeg build, only include the major version
|
||||
* to avoid unnecessary rebuilds. When included externally, keep including |
||||
* the full version information. */ |
||||
#include "version.h" |
||||
#endif |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavd |
||||
* Main libavdevice API header |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavd libavdevice |
||||
* Special devices muxing/demuxing library. |
||||
* |
||||
* Libavdevice is a complementary library to @ref libavf "libavformat". It |
||||
* provides various "special" platform-specific muxers and demuxers, e.g. for |
||||
* grabbing devices, audio capture and playback etc. As a consequence, the |
||||
* (de)muxers in libavdevice are of the AVFMT_NOFILE type (they use their own |
||||
* I/O functions). The filename passed to avformat_open_input() often does not |
||||
* refer to an actually existing file, but has some special device-specific |
||||
* meaning - e.g. for xcbgrab it is the display name. |
||||
* |
||||
* To use libavdevice, simply call avdevice_register_all() to register all |
||||
* compiled muxers and demuxers. They all use standard libavformat API. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#include "libavutil/log.h" |
||||
#include "libavutil/opt.h" |
||||
#include "libavutil/dict.h" |
||||
#include "libavformat/avformat.h" |
||||
|
||||
/**
|
||||
* Return the LIBAVDEVICE_VERSION_INT constant. |
||||
*/ |
||||
unsigned avdevice_version(void); |
||||
|
||||
/**
|
||||
* Return the libavdevice build-time configuration. |
||||
*/ |
||||
const char *avdevice_configuration(void); |
||||
|
||||
/**
|
||||
* Return the libavdevice license. |
||||
*/ |
||||
const char *avdevice_license(void); |
||||
|
||||
/**
|
||||
* Initialize libavdevice and register all the input and output devices. |
||||
*/ |
||||
void avdevice_register_all(void); |
||||
|
||||
/**
|
||||
* Audio input devices iterator. |
||||
* |
||||
* If d is NULL, returns the first registered input audio/video device, |
||||
* if d is non-NULL, returns the next registered input audio/video device after d |
||||
* or NULL if d is the last one. |
||||
*/ |
||||
const AVInputFormat *av_input_audio_device_next(const AVInputFormat *d); |
||||
|
||||
/**
|
||||
* Video input devices iterator. |
||||
* |
||||
* If d is NULL, returns the first registered input audio/video device, |
||||
* if d is non-NULL, returns the next registered input audio/video device after d |
||||
* or NULL if d is the last one. |
||||
*/ |
||||
const AVInputFormat *av_input_video_device_next(const AVInputFormat *d); |
||||
|
||||
/**
|
||||
* Audio output devices iterator. |
||||
* |
||||
* If d is NULL, returns the first registered output audio/video device, |
||||
* if d is non-NULL, returns the next registered output audio/video device after d |
||||
* or NULL if d is the last one. |
||||
*/ |
||||
const AVOutputFormat *av_output_audio_device_next(const AVOutputFormat *d); |
||||
|
||||
/**
|
||||
* Video output devices iterator. |
||||
* |
||||
* If d is NULL, returns the first registered output audio/video device, |
||||
* if d is non-NULL, returns the next registered output audio/video device after d |
||||
* or NULL if d is the last one. |
||||
*/ |
||||
const AVOutputFormat *av_output_video_device_next(const AVOutputFormat *d); |
||||
|
||||
typedef struct AVDeviceRect { |
||||
int x; /**< x coordinate of top left corner */ |
||||
int y; /**< y coordinate of top left corner */ |
||||
int width; /**< width */ |
||||
int height; /**< height */ |
||||
} AVDeviceRect; |
||||
|
||||
/**
|
||||
* Message types used by avdevice_app_to_dev_control_message(). |
||||
*/ |
||||
enum AVAppToDevMessageType { |
||||
/**
|
||||
* Dummy message. |
||||
*/ |
||||
AV_APP_TO_DEV_NONE = MKBETAG('N','O','N','E'), |
||||
|
||||
/**
|
||||
* Window size change message. |
||||
* |
||||
* Message is sent to the device every time the application changes the size |
||||
* of the window device renders to. |
||||
* Message should also be sent right after window is created. |
||||
* |
||||
* data: AVDeviceRect: new window size. |
||||
*/ |
||||
AV_APP_TO_DEV_WINDOW_SIZE = MKBETAG('G','E','O','M'), |
||||
|
||||
/**
|
||||
* Repaint request message. |
||||
* |
||||
* Message is sent to the device when window has to be repainted. |
||||
* |
||||
* data: AVDeviceRect: area required to be repainted. |
||||
* NULL: whole area is required to be repainted. |
||||
*/ |
||||
AV_APP_TO_DEV_WINDOW_REPAINT = MKBETAG('R','E','P','A'), |
||||
|
||||
/**
|
||||
* Request pause/play. |
||||
* |
||||
* Application requests pause/unpause playback. |
||||
* Mostly usable with devices that have internal buffer. |
||||
* By default devices are not paused. |
||||
* |
||||
* data: NULL |
||||
*/ |
||||
AV_APP_TO_DEV_PAUSE = MKBETAG('P', 'A', 'U', ' '), |
||||
AV_APP_TO_DEV_PLAY = MKBETAG('P', 'L', 'A', 'Y'), |
||||
AV_APP_TO_DEV_TOGGLE_PAUSE = MKBETAG('P', 'A', 'U', 'T'), |
||||
|
||||
/**
|
||||
* Volume control message. |
||||
* |
||||
* Set volume level. It may be device-dependent if volume |
||||
* is changed per stream or system wide. Per stream volume |
||||
* change is expected when possible. |
||||
* |
||||
* data: double: new volume with range of 0.0 - 1.0. |
||||
*/ |
||||
AV_APP_TO_DEV_SET_VOLUME = MKBETAG('S', 'V', 'O', 'L'), |
||||
|
||||
/**
|
||||
* Mute control messages. |
||||
* |
||||
* Change mute state. It may be device-dependent if mute status |
||||
* is changed per stream or system wide. Per stream mute status |
||||
* change is expected when possible. |
||||
* |
||||
* data: NULL. |
||||
*/ |
||||
AV_APP_TO_DEV_MUTE = MKBETAG(' ', 'M', 'U', 'T'), |
||||
AV_APP_TO_DEV_UNMUTE = MKBETAG('U', 'M', 'U', 'T'), |
||||
AV_APP_TO_DEV_TOGGLE_MUTE = MKBETAG('T', 'M', 'U', 'T'), |
||||
|
||||
/**
|
||||
* Get volume/mute messages. |
||||
* |
||||
* Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or |
||||
* AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively. |
||||
* |
||||
* data: NULL. |
||||
*/ |
||||
AV_APP_TO_DEV_GET_VOLUME = MKBETAG('G', 'V', 'O', 'L'), |
||||
AV_APP_TO_DEV_GET_MUTE = MKBETAG('G', 'M', 'U', 'T'), |
||||
}; |
||||
|
||||
/**
|
||||
* Message types used by avdevice_dev_to_app_control_message(). |
||||
*/ |
||||
enum AVDevToAppMessageType { |
||||
/**
|
||||
* Dummy message. |
||||
*/ |
||||
AV_DEV_TO_APP_NONE = MKBETAG('N','O','N','E'), |
||||
|
||||
/**
|
||||
* Create window buffer message. |
||||
* |
||||
* Device requests to create a window buffer. Exact meaning is device- |
||||
* and application-dependent. Message is sent before rendering first |
||||
* frame and all one-shot initializations should be done here. |
||||
* Application is allowed to ignore preferred window buffer size. |
||||
* |
||||
* @note: Application is obligated to inform about window buffer size |
||||
* with AV_APP_TO_DEV_WINDOW_SIZE message. |
||||
* |
||||
* data: AVDeviceRect: preferred size of the window buffer. |
||||
* NULL: no preferred size of the window buffer. |
||||
*/ |
||||
AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = MKBETAG('B','C','R','E'), |
||||
|
||||
/**
|
||||
* Prepare window buffer message. |
||||
* |
||||
* Device requests to prepare a window buffer for rendering. |
||||
* Exact meaning is device- and application-dependent. |
||||
* Message is sent before rendering of each frame. |
||||
* |
||||
* data: NULL. |
||||
*/ |
||||
AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = MKBETAG('B','P','R','E'), |
||||
|
||||
/**
|
||||
* Display window buffer message. |
||||
* |
||||
* Device requests to display a window buffer. |
||||
* Message is sent when new frame is ready to be displayed. |
||||
* Usually buffers need to be swapped in handler of this message. |
||||
* |
||||
* data: NULL. |
||||
*/ |
||||
AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = MKBETAG('B','D','I','S'), |
||||
|
||||
/**
|
||||
* Destroy window buffer message. |
||||
* |
||||
* Device requests to destroy a window buffer. |
||||
* Message is sent when device is about to be destroyed and window |
||||
* buffer is not required anymore. |
||||
* |
||||
* data: NULL. |
||||
*/ |
||||
AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = MKBETAG('B','D','E','S'), |
||||
|
||||
/**
|
||||
* Buffer fullness status messages. |
||||
* |
||||
* Device signals buffer overflow/underflow. |
||||
* |
||||
* data: NULL. |
||||
*/ |
||||
AV_DEV_TO_APP_BUFFER_OVERFLOW = MKBETAG('B','O','F','L'), |
||||
AV_DEV_TO_APP_BUFFER_UNDERFLOW = MKBETAG('B','U','F','L'), |
||||
|
||||
/**
|
||||
* Buffer readable/writable. |
||||
* |
||||
* Device informs that buffer is readable/writable. |
||||
* When possible, device informs how many bytes can be read/write. |
||||
* |
||||
* @warning Device may not inform when number of bytes than can be read/write changes. |
||||
* |
||||
* data: int64_t: amount of bytes available to read/write. |
||||
* NULL: amount of bytes available to read/write is not known. |
||||
*/ |
||||
AV_DEV_TO_APP_BUFFER_READABLE = MKBETAG('B','R','D',' '), |
||||
AV_DEV_TO_APP_BUFFER_WRITABLE = MKBETAG('B','W','R',' '), |
||||
|
||||
/**
|
||||
* Mute state change message. |
||||
* |
||||
* Device informs that mute state has changed. |
||||
* |
||||
* data: int: 0 for not muted state, non-zero for muted state. |
||||
*/ |
||||
AV_DEV_TO_APP_MUTE_STATE_CHANGED = MKBETAG('C','M','U','T'), |
||||
|
||||
/**
|
||||
* Volume level change message. |
||||
* |
||||
* Device informs that volume level has changed. |
||||
* |
||||
* data: double: new volume with range of 0.0 - 1.0. |
||||
*/ |
||||
AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = MKBETAG('C','V','O','L'), |
||||
}; |
||||
|
||||
/**
|
||||
* Send control message from application to device. |
||||
* |
||||
* @param s device context. |
||||
* @param type message type. |
||||
* @param data message data. Exact type depends on message type. |
||||
* @param data_size size of message data. |
||||
* @return >= 0 on success, negative on error. |
||||
* AVERROR(ENOSYS) when device doesn't implement handler of the message. |
||||
*/ |
||||
int avdevice_app_to_dev_control_message(struct AVFormatContext *s, |
||||
enum AVAppToDevMessageType type, |
||||
void *data, size_t data_size); |
||||
|
||||
/**
|
||||
* Send control message from device to application. |
||||
* |
||||
* @param s device context. |
||||
* @param type message type. |
||||
* @param data message data. Can be NULL. |
||||
* @param data_size size of message data. |
||||
* @return >= 0 on success, negative on error. |
||||
* AVERROR(ENOSYS) when application doesn't implement handler of the message. |
||||
*/ |
||||
int avdevice_dev_to_app_control_message(struct AVFormatContext *s, |
||||
enum AVDevToAppMessageType type, |
||||
void *data, size_t data_size); |
||||
|
||||
/**
|
||||
* Structure describes basic parameters of the device. |
||||
*/ |
||||
typedef struct AVDeviceInfo { |
||||
char *device_name; /**< device name, format depends on device */ |
||||
char *device_description; /**< human friendly name */ |
||||
enum AVMediaType *media_types; /**< array indicating what media types(s), if any, a device can provide. If null, cannot provide any */ |
||||
int nb_media_types; /**< length of media_types array, 0 if device cannot provide any media types */ |
||||
} AVDeviceInfo; |
||||
|
||||
/**
|
||||
* List of devices. |
||||
*/ |
||||
typedef struct AVDeviceInfoList { |
||||
AVDeviceInfo **devices; /**< list of autodetected devices */ |
||||
int nb_devices; /**< number of autodetected devices */ |
||||
int default_device; /**< index of default device or -1 if no default */ |
||||
} AVDeviceInfoList; |
||||
|
||||
/**
|
||||
* List devices. |
||||
* |
||||
* Returns available device names and their parameters. |
||||
* |
||||
* @note: Some devices may accept system-dependent device names that cannot be |
||||
* autodetected. The list returned by this function cannot be assumed to |
||||
* be always completed. |
||||
* |
||||
* @param s device context. |
||||
* @param[out] device_list list of autodetected devices. |
||||
* @return count of autodetected devices, negative on error. |
||||
*/ |
||||
int avdevice_list_devices(struct AVFormatContext *s, AVDeviceInfoList **device_list); |
||||
|
||||
/**
|
||||
* Convenient function to free result of avdevice_list_devices(). |
||||
* |
||||
* @param device_list device list to be freed. |
||||
*/ |
||||
void avdevice_free_list_devices(AVDeviceInfoList **device_list); |
||||
|
||||
/**
|
||||
* List devices. |
||||
* |
||||
* Returns available device names and their parameters. |
||||
* These are convinient wrappers for avdevice_list_devices(). |
||||
* Device context is allocated and deallocated internally. |
||||
* |
||||
* @param device device format. May be NULL if device name is set. |
||||
* @param device_name device name. May be NULL if device format is set. |
||||
* @param device_options An AVDictionary filled with device-private options. May be NULL. |
||||
* The same options must be passed later to avformat_write_header() for output |
||||
* devices or avformat_open_input() for input devices, or at any other place |
||||
* that affects device-private options. |
||||
* @param[out] device_list list of autodetected devices |
||||
* @return count of autodetected devices, negative on error. |
||||
* @note device argument takes precedence over device_name when both are set. |
||||
*/ |
||||
int avdevice_list_input_sources(const AVInputFormat *device, const char *device_name, |
||||
AVDictionary *device_options, AVDeviceInfoList **device_list); |
||||
int avdevice_list_output_sinks(const AVOutputFormat *device, const char *device_name, |
||||
AVDictionary *device_options, AVDeviceInfoList **device_list); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVDEVICE_AVDEVICE_H */ |
||||
@ -0,0 +1,45 @@ |
||||
/*
|
||||
* 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 AVDEVICE_VERSION_H |
||||
#define AVDEVICE_VERSION_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavd |
||||
* Libavdevice version macros |
||||
*/ |
||||
|
||||
#include "libavutil/version.h" |
||||
|
||||
#include "version_major.h" |
||||
|
||||
#define LIBAVDEVICE_VERSION_MINOR 1 |
||||
#define LIBAVDEVICE_VERSION_MICRO 100 |
||||
|
||||
#define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \ |
||||
LIBAVDEVICE_VERSION_MINOR, \
|
||||
LIBAVDEVICE_VERSION_MICRO) |
||||
#define LIBAVDEVICE_VERSION AV_VERSION(LIBAVDEVICE_VERSION_MAJOR, \ |
||||
LIBAVDEVICE_VERSION_MINOR, \
|
||||
LIBAVDEVICE_VERSION_MICRO) |
||||
#define LIBAVDEVICE_BUILD LIBAVDEVICE_VERSION_INT |
||||
|
||||
#define LIBAVDEVICE_IDENT "Lavd" AV_STRINGIFY(LIBAVDEVICE_VERSION) |
||||
|
||||
#endif /* AVDEVICE_VERSION_H */ |
||||
@ -0,0 +1,36 @@ |
||||
/*
|
||||
* 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 AVDEVICE_VERSION_MAJOR_H |
||||
#define AVDEVICE_VERSION_MAJOR_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavd |
||||
* Libavdevice version macros |
||||
*/ |
||||
|
||||
#define LIBAVDEVICE_VERSION_MAJOR 60 |
||||
|
||||
/**
|
||||
* FF_API_* defines may be placed below to indicate public API that will be |
||||
* dropped at a future version bump. The defines themselves are not part of |
||||
* the public API and may change, break or disappear at any time. |
||||
*/ |
||||
|
||||
#endif /* AVDEVICE_VERSION_MAJOR_H */ |
||||
@ -0,0 +1,32 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>CFBundleDevelopmentRegion</key> |
||||
<string>en</string> |
||||
<key>CFBundleExecutable</key> |
||||
<string>libavdevice</string> |
||||
<key>CFBundleIdentifier</key> |
||||
<string>com.arthenica.ffmpegkit.Libavdevice</string> |
||||
<key>CFBundleInfoDictionaryVersion</key> |
||||
<string>6.0</string> |
||||
<key>CFBundleName</key> |
||||
<string>libavdevice</string> |
||||
<key>CFBundlePackageType</key> |
||||
<string>FMWK</string> |
||||
<key>CFBundleShortVersionString</key> |
||||
<string>60.1.100</string> |
||||
<key>CFBundleVersion</key> |
||||
<string>60.1.100</string> |
||||
<key>CFBundleSignature</key> |
||||
<string>????</string> |
||||
<key>MinimumOSVersion</key> |
||||
<string>12.1</string> |
||||
<key>CFBundleSupportedPlatforms</key> |
||||
<array> |
||||
<string>iPhoneOS</string> |
||||
</array> |
||||
<key>NSPrincipalClass</key> |
||||
<string></string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,165 @@ |
||||
GNU LESSER GENERAL PUBLIC LICENSE |
||||
Version 3, 29 June 2007 |
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
|
||||
This version of the GNU Lesser General Public License incorporates |
||||
the terms and conditions of version 3 of the GNU General Public |
||||
License, supplemented by the additional permissions listed below. |
||||
|
||||
0. Additional Definitions. |
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser |
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU |
||||
General Public License. |
||||
|
||||
"The Library" refers to a covered work governed by this License, |
||||
other than an Application or a Combined Work as defined below. |
||||
|
||||
An "Application" is any work that makes use of an interface provided |
||||
by the Library, but which is not otherwise based on the Library. |
||||
Defining a subclass of a class defined by the Library is deemed a mode |
||||
of using an interface provided by the Library. |
||||
|
||||
A "Combined Work" is a work produced by combining or linking an |
||||
Application with the Library. The particular version of the Library |
||||
with which the Combined Work was made is also called the "Linked |
||||
Version". |
||||
|
||||
The "Minimal Corresponding Source" for a Combined Work means the |
||||
Corresponding Source for the Combined Work, excluding any source code |
||||
for portions of the Combined Work that, considered in isolation, are |
||||
based on the Application, and not on the Linked Version. |
||||
|
||||
The "Corresponding Application Code" for a Combined Work means the |
||||
object code and/or source code for the Application, including any data |
||||
and utility programs needed for reproducing the Combined Work from the |
||||
Application, but excluding the System Libraries of the Combined Work. |
||||
|
||||
1. Exception to Section 3 of the GNU GPL. |
||||
|
||||
You may convey a covered work under sections 3 and 4 of this License |
||||
without being bound by section 3 of the GNU GPL. |
||||
|
||||
2. Conveying Modified Versions. |
||||
|
||||
If you modify a copy of the Library, and, in your modifications, a |
||||
facility refers to a function or data to be supplied by an Application |
||||
that uses the facility (other than as an argument passed when the |
||||
facility is invoked), then you may convey a copy of the modified |
||||
version: |
||||
|
||||
a) under this License, provided that you make a good faith effort to |
||||
ensure that, in the event an Application does not supply the |
||||
function or data, the facility still operates, and performs |
||||
whatever part of its purpose remains meaningful, or |
||||
|
||||
b) under the GNU GPL, with none of the additional permissions of |
||||
this License applicable to that copy. |
||||
|
||||
3. Object Code Incorporating Material from Library Header Files. |
||||
|
||||
The object code form of an Application may incorporate material from |
||||
a header file that is part of the Library. You may convey such object |
||||
code under terms of your choice, provided that, if the incorporated |
||||
material is not limited to numerical parameters, data structure |
||||
layouts and accessors, or small macros, inline functions and templates |
||||
(ten or fewer lines in length), you do both of the following: |
||||
|
||||
a) Give prominent notice with each copy of the object code that the |
||||
Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
4. Combined Works. |
||||
|
||||
You may convey a Combined Work under terms of your choice that, |
||||
taken together, effectively do not restrict modification of the |
||||
portions of the Library contained in the Combined Work and reverse |
||||
engineering for debugging such modifications, if you also do each of |
||||
the following: |
||||
|
||||
a) Give prominent notice with each copy of the Combined Work that |
||||
the Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
c) For a Combined Work that displays copyright notices during |
||||
execution, include the copyright notice for the Library among |
||||
these notices, as well as a reference directing the user to the |
||||
copies of the GNU GPL and this license document. |
||||
|
||||
d) Do one of the following: |
||||
|
||||
0) Convey the Minimal Corresponding Source under the terms of this |
||||
License, and the Corresponding Application Code in a form |
||||
suitable for, and under terms that permit, the user to |
||||
recombine or relink the Application with a modified version of |
||||
the Linked Version to produce a modified Combined Work, in the |
||||
manner specified by section 6 of the GNU GPL for conveying |
||||
Corresponding Source. |
||||
|
||||
1) Use a suitable shared library mechanism for linking with the |
||||
Library. A suitable mechanism is one that (a) uses at run time |
||||
a copy of the Library already present on the user's computer |
||||
system, and (b) will operate properly with a modified version |
||||
of the Library that is interface-compatible with the Linked |
||||
Version. |
||||
|
||||
e) Provide Installation Information, but only if you would otherwise |
||||
be required to provide such information under section 6 of the |
||||
GNU GPL, and only to the extent that such information is |
||||
necessary to install and execute a modified version of the |
||||
Combined Work produced by recombining or relinking the |
||||
Application with a modified version of the Linked Version. (If |
||||
you use option 4d0, the Installation Information must accompany |
||||
the Minimal Corresponding Source and Corresponding Application |
||||
Code. If you use option 4d1, you must provide the Installation |
||||
Information in the manner specified by section 6 of the GNU GPL |
||||
for conveying Corresponding Source.) |
||||
|
||||
5. Combined Libraries. |
||||
|
||||
You may place library facilities that are a work based on the |
||||
Library side by side in a single library together with other library |
||||
facilities that are not Applications and are not covered by this |
||||
License, and convey such a combined library under terms of your |
||||
choice, if you do both of the following: |
||||
|
||||
a) Accompany the combined library with a copy of the same work based |
||||
on the Library, uncombined with any other library facilities, |
||||
conveyed under the terms of this License. |
||||
|
||||
b) Give prominent notice with the combined library that part of it |
||||
is a work based on the Library, and explaining where to find the |
||||
accompanying uncombined form of the same work. |
||||
|
||||
6. Revised Versions of the GNU Lesser General Public License. |
||||
|
||||
The Free Software Foundation may publish revised and/or new versions |
||||
of the GNU Lesser General Public License from time to time. Such new |
||||
versions will be similar in spirit to the present version, but may |
||||
differ in detail to address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the |
||||
Library as you received it specifies that a certain numbered version |
||||
of the GNU Lesser General Public License "or any later version" |
||||
applies to it, you have the option of following the terms and |
||||
conditions either of that published version or of any later version |
||||
published by the Free Software Foundation. If the Library as you |
||||
received it does not specify a version number of the GNU Lesser |
||||
General Public License, you may choose any version of the GNU Lesser |
||||
General Public License ever published by the Free Software Foundation. |
||||
|
||||
If the Library as you received it specifies that a proxy can decide |
||||
whether future versions of the GNU Lesser General Public License shall |
||||
apply, that proxy's public statement of acceptance of any version is |
||||
permanent authorization for you to choose that version for the |
||||
Library. |
||||
Binary file not shown.
@ -0,0 +1,27 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>AvailableLibraries</key> |
||||
<array> |
||||
<dict> |
||||
<key>BinaryPath</key> |
||||
<string>libavfilter.framework/libavfilter</string> |
||||
<key>LibraryIdentifier</key> |
||||
<string>ios-arm64</string> |
||||
<key>LibraryPath</key> |
||||
<string>libavfilter.framework</string> |
||||
<key>SupportedArchitectures</key> |
||||
<array> |
||||
<string>arm64</string> |
||||
</array> |
||||
<key>SupportedPlatform</key> |
||||
<string>ios</string> |
||||
</dict> |
||||
</array> |
||||
<key>CFBundlePackageType</key> |
||||
<string>XFWK</string> |
||||
<key>XCFrameworkFormatVersion</key> |
||||
<string>1.0</string> |
||||
</dict> |
||||
</plist> |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,173 @@ |
||||
/*
|
||||
* 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 AVFILTER_BUFFERSINK_H |
||||
#define AVFILTER_BUFFERSINK_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavfi_buffersink |
||||
* memory buffer sink API for audio and video |
||||
*/ |
||||
|
||||
#include "avfilter.h" |
||||
|
||||
/**
|
||||
* @defgroup lavfi_buffersink Buffer sink API |
||||
* @ingroup lavfi |
||||
* @{ |
||||
* |
||||
* The buffersink and abuffersink filters are there to connect filter graphs |
||||
* to applications. They have a single input, connected to the graph, and no |
||||
* output. Frames must be extracted using av_buffersink_get_frame() or |
||||
* av_buffersink_get_samples(). |
||||
* |
||||
* The format negotiated by the graph during configuration can be obtained |
||||
* using the accessor functions: |
||||
* - av_buffersink_get_time_base(), |
||||
* - av_buffersink_get_format(), |
||||
* - av_buffersink_get_frame_rate(), |
||||
* - av_buffersink_get_w(), |
||||
* - av_buffersink_get_h(), |
||||
* - av_buffersink_get_sample_aspect_ratio(), |
||||
* - av_buffersink_get_channels(), |
||||
* - av_buffersink_get_ch_layout(), |
||||
* - av_buffersink_get_sample_rate(). |
||||
* |
||||
* The layout returned by av_buffersink_get_ch_layout() must de uninitialized |
||||
* by the caller. |
||||
* |
||||
* The format can be constrained by setting options, using av_opt_set() and |
||||
* related functions with the AV_OPT_SEARCH_CHILDREN flag. |
||||
* - pix_fmts (int list), |
||||
* - sample_fmts (int list), |
||||
* - sample_rates (int list), |
||||
* - ch_layouts (string), |
||||
* - channel_counts (int list), |
||||
* - all_channel_counts (bool). |
||||
* Most of these options are of type binary, and should be set using |
||||
* av_opt_set_int_list() or av_opt_set_bin(). If they are not set, all |
||||
* corresponding formats are accepted. |
||||
* |
||||
* As a special case, if ch_layouts is not set, all valid channel layouts are |
||||
* accepted except for UNSPEC layouts, unless all_channel_counts is set. |
||||
*/ |
||||
|
||||
/**
|
||||
* Get a frame with filtered data from sink and put it in frame. |
||||
* |
||||
* @param ctx pointer to a buffersink or abuffersink filter context. |
||||
* @param frame pointer to an allocated frame that will be filled with data. |
||||
* The data must be freed using av_frame_unref() / av_frame_free() |
||||
* @param flags a combination of AV_BUFFERSINK_FLAG_* flags |
||||
* |
||||
* @return >= 0 in for success, a negative AVERROR code for failure. |
||||
*/ |
||||
int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags); |
||||
|
||||
/**
|
||||
* Tell av_buffersink_get_buffer_ref() to read video/samples buffer |
||||
* reference, but not remove it from the buffer. This is useful if you |
||||
* need only to read a video/samples buffer, without to fetch it. |
||||
*/ |
||||
#define AV_BUFFERSINK_FLAG_PEEK 1 |
||||
|
||||
/**
|
||||
* Tell av_buffersink_get_buffer_ref() not to request a frame from its input. |
||||
* If a frame is already buffered, it is read (and removed from the buffer), |
||||
* but if no frame is present, return AVERROR(EAGAIN). |
||||
*/ |
||||
#define AV_BUFFERSINK_FLAG_NO_REQUEST 2 |
||||
|
||||
/**
|
||||
* Set the frame size for an audio buffer sink. |
||||
* |
||||
* All calls to av_buffersink_get_buffer_ref will return a buffer with |
||||
* exactly the specified number of samples, or AVERROR(EAGAIN) if there is |
||||
* not enough. The last buffer at EOF will be padded with 0. |
||||
*/ |
||||
void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size); |
||||
|
||||
/**
|
||||
* @defgroup lavfi_buffersink_accessors Buffer sink accessors |
||||
* Get the properties of the stream |
||||
* @{ |
||||
*/ |
||||
|
||||
enum AVMediaType av_buffersink_get_type (const AVFilterContext *ctx); |
||||
AVRational av_buffersink_get_time_base (const AVFilterContext *ctx); |
||||
int av_buffersink_get_format (const AVFilterContext *ctx); |
||||
|
||||
AVRational av_buffersink_get_frame_rate (const AVFilterContext *ctx); |
||||
int av_buffersink_get_w (const AVFilterContext *ctx); |
||||
int av_buffersink_get_h (const AVFilterContext *ctx); |
||||
AVRational av_buffersink_get_sample_aspect_ratio (const AVFilterContext *ctx); |
||||
|
||||
int av_buffersink_get_channels (const AVFilterContext *ctx); |
||||
#if FF_API_OLD_CHANNEL_LAYOUT |
||||
attribute_deprecated |
||||
uint64_t av_buffersink_get_channel_layout (const AVFilterContext *ctx); |
||||
#endif |
||||
int av_buffersink_get_ch_layout (const AVFilterContext *ctx, |
||||
AVChannelLayout *ch_layout); |
||||
int av_buffersink_get_sample_rate (const AVFilterContext *ctx); |
||||
|
||||
AVBufferRef * av_buffersink_get_hw_frames_ctx (const AVFilterContext *ctx); |
||||
|
||||
/** @} */ |
||||
|
||||
/**
|
||||
* Get a frame with filtered data from sink and put it in frame. |
||||
* |
||||
* @param ctx pointer to a context of a buffersink or abuffersink AVFilter. |
||||
* @param frame pointer to an allocated frame that will be filled with data. |
||||
* The data must be freed using av_frame_unref() / av_frame_free() |
||||
* |
||||
* @return |
||||
* - >= 0 if a frame was successfully returned. |
||||
* - AVERROR(EAGAIN) if no frames are available at this point; more |
||||
* input frames must be added to the filtergraph to get more output. |
||||
* - AVERROR_EOF if there will be no more output frames on this sink. |
||||
* - A different negative AVERROR code in other failure cases. |
||||
*/ |
||||
int av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame); |
||||
|
||||
/**
|
||||
* Same as av_buffersink_get_frame(), but with the ability to specify the number |
||||
* of samples read. This function is less efficient than |
||||
* av_buffersink_get_frame(), because it copies the data around. |
||||
* |
||||
* @param ctx pointer to a context of the abuffersink AVFilter. |
||||
* @param frame pointer to an allocated frame that will be filled with data. |
||||
* The data must be freed using av_frame_unref() / av_frame_free() |
||||
* frame will contain exactly nb_samples audio samples, except at |
||||
* the end of stream, when it can contain less than nb_samples. |
||||
* |
||||
* @return The return codes have the same meaning as for |
||||
* av_buffersink_get_frame(). |
||||
* |
||||
* @warning do not mix this function with av_buffersink_get_frame(). Use only one or |
||||
* the other with a single sink, not both. |
||||
*/ |
||||
int av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVFILTER_BUFFERSINK_H */ |
||||
@ -0,0 +1,218 @@ |
||||
/*
|
||||
* 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 AVFILTER_BUFFERSRC_H |
||||
#define AVFILTER_BUFFERSRC_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavfi_buffersrc |
||||
* Memory buffer source API. |
||||
*/ |
||||
|
||||
#include "avfilter.h" |
||||
|
||||
/**
|
||||
* @defgroup lavfi_buffersrc Buffer source API |
||||
* @ingroup lavfi |
||||
* @{ |
||||
*/ |
||||
|
||||
enum { |
||||
|
||||
/**
|
||||
* Do not check for format changes. |
||||
*/ |
||||
AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT = 1, |
||||
|
||||
/**
|
||||
* Immediately push the frame to the output. |
||||
*/ |
||||
AV_BUFFERSRC_FLAG_PUSH = 4, |
||||
|
||||
/**
|
||||
* Keep a reference to the frame. |
||||
* If the frame if reference-counted, create a new reference; otherwise |
||||
* copy the frame data. |
||||
*/ |
||||
AV_BUFFERSRC_FLAG_KEEP_REF = 8, |
||||
|
||||
}; |
||||
|
||||
/**
|
||||
* Get the number of failed requests. |
||||
* |
||||
* A failed request is when the request_frame method is called while no |
||||
* frame is present in the buffer. |
||||
* The number is reset when a frame is added. |
||||
*/ |
||||
unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src); |
||||
|
||||
/**
|
||||
* This structure contains the parameters describing the frames that will be |
||||
* passed to this filter. |
||||
* |
||||
* It should be allocated with av_buffersrc_parameters_alloc() and freed with |
||||
* av_free(). All the allocated fields in it remain owned by the caller. |
||||
*/ |
||||
typedef struct AVBufferSrcParameters { |
||||
/**
|
||||
* video: the pixel format, value corresponds to enum AVPixelFormat |
||||
* audio: the sample format, value corresponds to enum AVSampleFormat |
||||
*/ |
||||
int format; |
||||
/**
|
||||
* The timebase to be used for the timestamps on the input frames. |
||||
*/ |
||||
AVRational time_base; |
||||
|
||||
/**
|
||||
* Video only, the display dimensions of the input frames. |
||||
*/ |
||||
int width, height; |
||||
|
||||
/**
|
||||
* Video only, the sample (pixel) aspect ratio. |
||||
*/ |
||||
AVRational sample_aspect_ratio; |
||||
|
||||
/**
|
||||
* Video only, the frame rate of the input video. This field must only be |
||||
* set to a non-zero value if input stream has a known constant framerate |
||||
* and should be left at its initial value if the framerate is variable or |
||||
* unknown. |
||||
*/ |
||||
AVRational frame_rate; |
||||
|
||||
/**
|
||||
* Video with a hwaccel pixel format only. This should be a reference to an |
||||
* AVHWFramesContext instance describing the input frames. |
||||
*/ |
||||
AVBufferRef *hw_frames_ctx; |
||||
|
||||
/**
|
||||
* Audio only, the audio sampling rate in samples per second. |
||||
*/ |
||||
int sample_rate; |
||||
|
||||
#if FF_API_OLD_CHANNEL_LAYOUT |
||||
/**
|
||||
* Audio only, the audio channel layout |
||||
* @deprecated use ch_layout |
||||
*/ |
||||
attribute_deprecated |
||||
uint64_t channel_layout; |
||||
#endif |
||||
|
||||
/**
|
||||
* Audio only, the audio channel layout |
||||
*/ |
||||
AVChannelLayout ch_layout; |
||||
} AVBufferSrcParameters; |
||||
|
||||
/**
|
||||
* Allocate a new AVBufferSrcParameters instance. It should be freed by the |
||||
* caller with av_free(). |
||||
*/ |
||||
AVBufferSrcParameters *av_buffersrc_parameters_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize the buffersrc or abuffersrc filter with the provided parameters. |
||||
* This function may be called multiple times, the later calls override the |
||||
* previous ones. Some of the parameters may also be set through AVOptions, then |
||||
* whatever method is used last takes precedence. |
||||
* |
||||
* @param ctx an instance of the buffersrc or abuffersrc filter |
||||
* @param param the stream parameters. The frames later passed to this filter |
||||
* must conform to those parameters. All the allocated fields in |
||||
* param remain owned by the caller, libavfilter will make internal |
||||
* copies or references when necessary. |
||||
* @return 0 on success, a negative AVERROR code on failure. |
||||
*/ |
||||
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param); |
||||
|
||||
/**
|
||||
* Add a frame to the buffer source. |
||||
* |
||||
* @param ctx an instance of the buffersrc filter |
||||
* @param frame frame to be added. If the frame is reference counted, this |
||||
* function will make a new reference to it. Otherwise the frame data will be |
||||
* copied. |
||||
* |
||||
* @return 0 on success, a negative AVERROR on error |
||||
* |
||||
* This function is equivalent to av_buffersrc_add_frame_flags() with the |
||||
* AV_BUFFERSRC_FLAG_KEEP_REF flag. |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame); |
||||
|
||||
/**
|
||||
* Add a frame to the buffer source. |
||||
* |
||||
* @param ctx an instance of the buffersrc filter |
||||
* @param frame frame to be added. If the frame is reference counted, this |
||||
* function will take ownership of the reference(s) and reset the frame. |
||||
* Otherwise the frame data will be copied. If this function returns an error, |
||||
* the input frame is not touched. |
||||
* |
||||
* @return 0 on success, a negative AVERROR on error. |
||||
* |
||||
* @note the difference between this function and av_buffersrc_write_frame() is |
||||
* that av_buffersrc_write_frame() creates a new reference to the input frame, |
||||
* while this function takes ownership of the reference passed to it. |
||||
* |
||||
* This function is equivalent to av_buffersrc_add_frame_flags() without the |
||||
* AV_BUFFERSRC_FLAG_KEEP_REF flag. |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame); |
||||
|
||||
/**
|
||||
* Add a frame to the buffer source. |
||||
* |
||||
* By default, if the frame is reference-counted, this function will take |
||||
* ownership of the reference(s) and reset the frame. This can be controlled |
||||
* using the flags. |
||||
* |
||||
* If this function returns an error, the input frame is not touched. |
||||
* |
||||
* @param buffer_src pointer to a buffer source context |
||||
* @param frame a frame, or NULL to mark EOF |
||||
* @param flags a combination of AV_BUFFERSRC_FLAG_* |
||||
* @return >= 0 in case of success, a negative AVERROR code |
||||
* in case of failure |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_buffersrc_add_frame_flags(AVFilterContext *buffer_src, |
||||
AVFrame *frame, int flags); |
||||
|
||||
/**
|
||||
* Close the buffer source after EOF. |
||||
* |
||||
* This is similar to passing NULL to av_buffersrc_add_frame_flags() |
||||
* except it takes the timestamp of the EOF, i.e. the timestamp of the end |
||||
* of the last frame. |
||||
*/ |
||||
int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVFILTER_BUFFERSRC_H */ |
||||
@ -0,0 +1,48 @@ |
||||
/*
|
||||
* 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 AVFILTER_VERSION_H |
||||
#define AVFILTER_VERSION_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavfi |
||||
* Libavfilter version macros |
||||
*/ |
||||
|
||||
#include "libavutil/version.h" |
||||
|
||||
#include "version_major.h" |
||||
|
||||
#define LIBAVFILTER_VERSION_MINOR 3 |
||||
#define LIBAVFILTER_VERSION_MICRO 100 |
||||
|
||||
|
||||
#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ |
||||
LIBAVFILTER_VERSION_MINOR, \
|
||||
LIBAVFILTER_VERSION_MICRO) |
||||
#define LIBAVFILTER_VERSION AV_VERSION(LIBAVFILTER_VERSION_MAJOR, \ |
||||
LIBAVFILTER_VERSION_MINOR, \
|
||||
LIBAVFILTER_VERSION_MICRO) |
||||
#define LIBAVFILTER_BUILD LIBAVFILTER_VERSION_INT |
||||
|
||||
#define LIBAVFILTER_IDENT "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION) |
||||
|
||||
#endif /* AVFILTER_VERSION_H */ |
||||
@ -0,0 +1,38 @@ |
||||
/*
|
||||
* 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 AVFILTER_VERSION_MAJOR_H |
||||
#define AVFILTER_VERSION_MAJOR_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavfi |
||||
* Libavfilter version macros |
||||
*/ |
||||
|
||||
#define LIBAVFILTER_VERSION_MAJOR 9 |
||||
|
||||
/**
|
||||
* 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. |
||||
*/ |
||||
|
||||
#endif /* AVFILTER_VERSION_MAJOR_H */ |
||||
@ -0,0 +1,32 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>CFBundleDevelopmentRegion</key> |
||||
<string>en</string> |
||||
<key>CFBundleExecutable</key> |
||||
<string>libavfilter</string> |
||||
<key>CFBundleIdentifier</key> |
||||
<string>com.arthenica.ffmpegkit.Libavfilter</string> |
||||
<key>CFBundleInfoDictionaryVersion</key> |
||||
<string>6.0</string> |
||||
<key>CFBundleName</key> |
||||
<string>libavfilter</string> |
||||
<key>CFBundlePackageType</key> |
||||
<string>FMWK</string> |
||||
<key>CFBundleShortVersionString</key> |
||||
<string>9.3.100</string> |
||||
<key>CFBundleVersion</key> |
||||
<string>9.3.100</string> |
||||
<key>CFBundleSignature</key> |
||||
<string>????</string> |
||||
<key>MinimumOSVersion</key> |
||||
<string>12.1</string> |
||||
<key>CFBundleSupportedPlatforms</key> |
||||
<array> |
||||
<string>iPhoneOS</string> |
||||
</array> |
||||
<key>NSPrincipalClass</key> |
||||
<string></string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,165 @@ |
||||
GNU LESSER GENERAL PUBLIC LICENSE |
||||
Version 3, 29 June 2007 |
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
|
||||
This version of the GNU Lesser General Public License incorporates |
||||
the terms and conditions of version 3 of the GNU General Public |
||||
License, supplemented by the additional permissions listed below. |
||||
|
||||
0. Additional Definitions. |
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser |
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU |
||||
General Public License. |
||||
|
||||
"The Library" refers to a covered work governed by this License, |
||||
other than an Application or a Combined Work as defined below. |
||||
|
||||
An "Application" is any work that makes use of an interface provided |
||||
by the Library, but which is not otherwise based on the Library. |
||||
Defining a subclass of a class defined by the Library is deemed a mode |
||||
of using an interface provided by the Library. |
||||
|
||||
A "Combined Work" is a work produced by combining or linking an |
||||
Application with the Library. The particular version of the Library |
||||
with which the Combined Work was made is also called the "Linked |
||||
Version". |
||||
|
||||
The "Minimal Corresponding Source" for a Combined Work means the |
||||
Corresponding Source for the Combined Work, excluding any source code |
||||
for portions of the Combined Work that, considered in isolation, are |
||||
based on the Application, and not on the Linked Version. |
||||
|
||||
The "Corresponding Application Code" for a Combined Work means the |
||||
object code and/or source code for the Application, including any data |
||||
and utility programs needed for reproducing the Combined Work from the |
||||
Application, but excluding the System Libraries of the Combined Work. |
||||
|
||||
1. Exception to Section 3 of the GNU GPL. |
||||
|
||||
You may convey a covered work under sections 3 and 4 of this License |
||||
without being bound by section 3 of the GNU GPL. |
||||
|
||||
2. Conveying Modified Versions. |
||||
|
||||
If you modify a copy of the Library, and, in your modifications, a |
||||
facility refers to a function or data to be supplied by an Application |
||||
that uses the facility (other than as an argument passed when the |
||||
facility is invoked), then you may convey a copy of the modified |
||||
version: |
||||
|
||||
a) under this License, provided that you make a good faith effort to |
||||
ensure that, in the event an Application does not supply the |
||||
function or data, the facility still operates, and performs |
||||
whatever part of its purpose remains meaningful, or |
||||
|
||||
b) under the GNU GPL, with none of the additional permissions of |
||||
this License applicable to that copy. |
||||
|
||||
3. Object Code Incorporating Material from Library Header Files. |
||||
|
||||
The object code form of an Application may incorporate material from |
||||
a header file that is part of the Library. You may convey such object |
||||
code under terms of your choice, provided that, if the incorporated |
||||
material is not limited to numerical parameters, data structure |
||||
layouts and accessors, or small macros, inline functions and templates |
||||
(ten or fewer lines in length), you do both of the following: |
||||
|
||||
a) Give prominent notice with each copy of the object code that the |
||||
Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
4. Combined Works. |
||||
|
||||
You may convey a Combined Work under terms of your choice that, |
||||
taken together, effectively do not restrict modification of the |
||||
portions of the Library contained in the Combined Work and reverse |
||||
engineering for debugging such modifications, if you also do each of |
||||
the following: |
||||
|
||||
a) Give prominent notice with each copy of the Combined Work that |
||||
the Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
c) For a Combined Work that displays copyright notices during |
||||
execution, include the copyright notice for the Library among |
||||
these notices, as well as a reference directing the user to the |
||||
copies of the GNU GPL and this license document. |
||||
|
||||
d) Do one of the following: |
||||
|
||||
0) Convey the Minimal Corresponding Source under the terms of this |
||||
License, and the Corresponding Application Code in a form |
||||
suitable for, and under terms that permit, the user to |
||||
recombine or relink the Application with a modified version of |
||||
the Linked Version to produce a modified Combined Work, in the |
||||
manner specified by section 6 of the GNU GPL for conveying |
||||
Corresponding Source. |
||||
|
||||
1) Use a suitable shared library mechanism for linking with the |
||||
Library. A suitable mechanism is one that (a) uses at run time |
||||
a copy of the Library already present on the user's computer |
||||
system, and (b) will operate properly with a modified version |
||||
of the Library that is interface-compatible with the Linked |
||||
Version. |
||||
|
||||
e) Provide Installation Information, but only if you would otherwise |
||||
be required to provide such information under section 6 of the |
||||
GNU GPL, and only to the extent that such information is |
||||
necessary to install and execute a modified version of the |
||||
Combined Work produced by recombining or relinking the |
||||
Application with a modified version of the Linked Version. (If |
||||
you use option 4d0, the Installation Information must accompany |
||||
the Minimal Corresponding Source and Corresponding Application |
||||
Code. If you use option 4d1, you must provide the Installation |
||||
Information in the manner specified by section 6 of the GNU GPL |
||||
for conveying Corresponding Source.) |
||||
|
||||
5. Combined Libraries. |
||||
|
||||
You may place library facilities that are a work based on the |
||||
Library side by side in a single library together with other library |
||||
facilities that are not Applications and are not covered by this |
||||
License, and convey such a combined library under terms of your |
||||
choice, if you do both of the following: |
||||
|
||||
a) Accompany the combined library with a copy of the same work based |
||||
on the Library, uncombined with any other library facilities, |
||||
conveyed under the terms of this License. |
||||
|
||||
b) Give prominent notice with the combined library that part of it |
||||
is a work based on the Library, and explaining where to find the |
||||
accompanying uncombined form of the same work. |
||||
|
||||
6. Revised Versions of the GNU Lesser General Public License. |
||||
|
||||
The Free Software Foundation may publish revised and/or new versions |
||||
of the GNU Lesser General Public License from time to time. Such new |
||||
versions will be similar in spirit to the present version, but may |
||||
differ in detail to address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the |
||||
Library as you received it specifies that a certain numbered version |
||||
of the GNU Lesser General Public License "or any later version" |
||||
applies to it, you have the option of following the terms and |
||||
conditions either of that published version or of any later version |
||||
published by the Free Software Foundation. If the Library as you |
||||
received it does not specify a version number of the GNU Lesser |
||||
General Public License, you may choose any version of the GNU Lesser |
||||
General Public License ever published by the Free Software Foundation. |
||||
|
||||
If the Library as you received it specifies that a proxy can decide |
||||
whether future versions of the GNU Lesser General Public License shall |
||||
apply, that proxy's public statement of acceptance of any version is |
||||
permanent authorization for you to choose that version for the |
||||
Library. |
||||
Binary file not shown.
@ -0,0 +1,27 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>AvailableLibraries</key> |
||||
<array> |
||||
<dict> |
||||
<key>BinaryPath</key> |
||||
<string>libavformat.framework/libavformat</string> |
||||
<key>LibraryIdentifier</key> |
||||
<string>ios-arm64</string> |
||||
<key>LibraryPath</key> |
||||
<string>libavformat.framework</string> |
||||
<key>SupportedArchitectures</key> |
||||
<array> |
||||
<string>arm64</string> |
||||
</array> |
||||
<key>SupportedPlatform</key> |
||||
<string>ios</string> |
||||
</dict> |
||||
</array> |
||||
<key>CFBundlePackageType</key> |
||||
<string>XFWK</string> |
||||
<key>XCFrameworkFormatVersion</key> |
||||
<string>1.0</string> |
||||
</dict> |
||||
</plist> |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,837 @@ |
||||
/*
|
||||
* copyright (c) 2001 Fabrice Bellard |
||||
* |
||||
* 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_AVIO_H |
||||
#define AVFORMAT_AVIO_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavf_io |
||||
* Buffered I/O operations |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdio.h> |
||||
|
||||
#include "libavutil/attributes.h" |
||||
#include "libavutil/dict.h" |
||||
#include "libavutil/log.h" |
||||
|
||||
#include "libavformat/version_major.h" |
||||
|
||||
/**
|
||||
* Seeking works like for a local file. |
||||
*/ |
||||
#define AVIO_SEEKABLE_NORMAL (1 << 0) |
||||
|
||||
/**
|
||||
* Seeking by timestamp with avio_seek_time() is possible. |
||||
*/ |
||||
#define AVIO_SEEKABLE_TIME (1 << 1) |
||||
|
||||
/**
|
||||
* Callback for checking whether to abort blocking functions. |
||||
* AVERROR_EXIT is returned in this case by the interrupted |
||||
* function. During blocking operations, callback is called with |
||||
* opaque as parameter. If the callback returns 1, the |
||||
* blocking operation will be aborted. |
||||
* |
||||
* No members can be added to this struct without a major bump, if |
||||
* new elements have been added after this struct in AVFormatContext |
||||
* or AVIOContext. |
||||
*/ |
||||
typedef struct AVIOInterruptCB { |
||||
int (*callback)(void*); |
||||
void *opaque; |
||||
} AVIOInterruptCB; |
||||
|
||||
/**
|
||||
* Directory entry types. |
||||
*/ |
||||
enum AVIODirEntryType { |
||||
AVIO_ENTRY_UNKNOWN, |
||||
AVIO_ENTRY_BLOCK_DEVICE, |
||||
AVIO_ENTRY_CHARACTER_DEVICE, |
||||
AVIO_ENTRY_DIRECTORY, |
||||
AVIO_ENTRY_NAMED_PIPE, |
||||
AVIO_ENTRY_SYMBOLIC_LINK, |
||||
AVIO_ENTRY_SOCKET, |
||||
AVIO_ENTRY_FILE, |
||||
AVIO_ENTRY_SERVER, |
||||
AVIO_ENTRY_SHARE, |
||||
AVIO_ENTRY_WORKGROUP, |
||||
}; |
||||
|
||||
/**
|
||||
* Describes single entry of the directory. |
||||
* |
||||
* Only name and type fields are guaranteed be set. |
||||
* Rest of fields are protocol or/and platform dependent and might be unknown. |
||||
*/ |
||||
typedef struct AVIODirEntry { |
||||
char *name; /**< Filename */ |
||||
int type; /**< Type of the entry */ |
||||
int utf8; /**< Set to 1 when name is encoded with UTF-8, 0 otherwise.
|
||||
Name can be encoded with UTF-8 even though 0 is set. */ |
||||
int64_t size; /**< File size in bytes, -1 if unknown. */ |
||||
int64_t modification_timestamp; /**< Time of last modification in microseconds since unix
|
||||
epoch, -1 if unknown. */ |
||||
int64_t access_timestamp; /**< Time of last access in microseconds since unix epoch,
|
||||
-1 if unknown. */ |
||||
int64_t status_change_timestamp; /**< Time of last status change in microseconds since unix
|
||||
epoch, -1 if unknown. */ |
||||
int64_t user_id; /**< User ID of owner, -1 if unknown. */ |
||||
int64_t group_id; /**< Group ID of owner, -1 if unknown. */ |
||||
int64_t filemode; /**< Unix file mode, -1 if unknown. */ |
||||
} AVIODirEntry; |
||||
|
||||
#if FF_API_AVIODIRCONTEXT |
||||
typedef struct AVIODirContext { |
||||
struct URLContext *url_context; |
||||
} AVIODirContext; |
||||
#else |
||||
typedef struct AVIODirContext AVIODirContext; |
||||
#endif |
||||
|
||||
/**
|
||||
* Different data types that can be returned via the AVIO |
||||
* write_data_type callback. |
||||
*/ |
||||
enum AVIODataMarkerType { |
||||
/**
|
||||
* Header data; this needs to be present for the stream to be decodeable. |
||||
*/ |
||||
AVIO_DATA_MARKER_HEADER, |
||||
/**
|
||||
* A point in the output bytestream where a decoder can start decoding |
||||
* (i.e. a keyframe). A demuxer/decoder given the data flagged with |
||||
* AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT, |
||||
* should give decodeable results. |
||||
*/ |
||||
AVIO_DATA_MARKER_SYNC_POINT, |
||||
/**
|
||||
* A point in the output bytestream where a demuxer can start parsing |
||||
* (for non self synchronizing bytestream formats). That is, any |
||||
* non-keyframe packet start point. |
||||
*/ |
||||
AVIO_DATA_MARKER_BOUNDARY_POINT, |
||||
/**
|
||||
* This is any, unlabelled data. It can either be a muxer not marking |
||||
* any positions at all, it can be an actual boundary/sync point |
||||
* that the muxer chooses not to mark, or a later part of a packet/fragment |
||||
* that is cut into multiple write callbacks due to limited IO buffer size. |
||||
*/ |
||||
AVIO_DATA_MARKER_UNKNOWN, |
||||
/**
|
||||
* Trailer data, which doesn't contain actual content, but only for |
||||
* finalizing the output file. |
||||
*/ |
||||
AVIO_DATA_MARKER_TRAILER, |
||||
/**
|
||||
* A point in the output bytestream where the underlying AVIOContext might |
||||
* flush the buffer depending on latency or buffering requirements. Typically |
||||
* means the end of a packet. |
||||
*/ |
||||
AVIO_DATA_MARKER_FLUSH_POINT, |
||||
}; |
||||
|
||||
/**
|
||||
* Bytestream IO Context. |
||||
* 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 |
||||
* directly, they should only be set by the client application |
||||
* when implementing custom I/O. Normally these are set to the |
||||
* function pointers specified in avio_alloc_context() |
||||
*/ |
||||
typedef struct AVIOContext { |
||||
/**
|
||||
* A class for private options. |
||||
* |
||||
* If this AVIOContext is created by avio_open2(), av_class is set and |
||||
* passes the options down to protocols. |
||||
* |
||||
* If this AVIOContext is manually allocated, then av_class may be set by |
||||
* the caller. |
||||
* |
||||
* warning -- this field can be NULL, be sure to not pass this AVIOContext |
||||
* to any av_opt_* functions in that case. |
||||
*/ |
||||
const AVClass *av_class; |
||||
|
||||
/*
|
||||
* The following shows the relationship between buffer, buf_ptr, |
||||
* buf_ptr_max, buf_end, buf_size, and pos, when reading and when writing |
||||
* (since AVIOContext is used for both): |
||||
* |
||||
********************************************************************************** |
||||
* READING |
||||
********************************************************************************** |
||||
* |
||||
* | buffer_size | |
||||
* |---------------------------------------| |
||||
* | | |
||||
* |
||||
* buffer buf_ptr buf_end |
||||
* +---------------+-----------------------+ |
||||
* |/ / / / / / / /|/ / / / / / /| | |
||||
* read buffer: |/ / consumed / | to be read /| | |
||||
* |/ / / / / / / /|/ / / / / / /| | |
||||
* +---------------+-----------------------+ |
||||
* |
||||
* pos |
||||
* +-------------------------------------------+-----------------+ |
||||
* input file: | | | |
||||
* +-------------------------------------------+-----------------+ |
||||
* |
||||
* |
||||
********************************************************************************** |
||||
* WRITING |
||||
********************************************************************************** |
||||
* |
||||
* | buffer_size | |
||||
* |--------------------------------------| |
||||
* | | |
||||
* |
||||
* buf_ptr_max |
||||
* buffer (buf_ptr) buf_end |
||||
* +-----------------------+--------------+ |
||||
* |/ / / / / / / / / / / /| | |
||||
* write buffer: | / / to be flushed / / | | |
||||
* |/ / / / / / / / / / / /| | |
||||
* +-----------------------+--------------+ |
||||
* buf_ptr can be in this |
||||
* due to a backward seek |
||||
* |
||||
* pos |
||||
* +-------------+----------------------------------------------+ |
||||
* output file: | | | |
||||
* +-------------+----------------------------------------------+ |
||||
* |
||||
*/ |
||||
unsigned char *buffer; /**< Start of the buffer. */ |
||||
int buffer_size; /**< Maximum buffer size */ |
||||
unsigned char *buf_ptr; /**< Current position in the buffer */ |
||||
unsigned char *buf_end; /**< End of the data, may be less than
|
||||
buffer+buffer_size if the read function returned |
||||
less data than requested, e.g. for streams where |
||||
no more data has been received yet. */ |
||||
void *opaque; /**< A private pointer, passed to the read/write/seek/...
|
||||
functions. */ |
||||
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size); |
||||
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size); |
||||
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); |
||||
/**
|
||||
* Pause or resume playback for network streaming protocols - e.g. MMS. |
||||
*/ |
||||
int (*read_pause)(void *opaque, int pause); |
||||
/**
|
||||
* Seek to a given timestamp in stream with the specified stream_index. |
||||
* Needed for some network streaming protocols which don't support seeking |
||||
* to byte position. |
||||
*/ |
||||
int64_t (*read_seek)(void *opaque, int stream_index, |
||||
int64_t timestamp, int flags); |
||||
/**
|
||||
* A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable. |
||||
*/ |
||||
int seekable; |
||||
|
||||
/**
|
||||
* avio_read and avio_write should if possible be satisfied directly |
||||
* instead of going through a buffer, and avio_seek will always |
||||
* call the underlying seek function directly. |
||||
*/ |
||||
int direct; |
||||
|
||||
/**
|
||||
* ',' separated list of allowed protocols. |
||||
*/ |
||||
const char *protocol_whitelist; |
||||
|
||||
/**
|
||||
* ',' separated list of disallowed protocols. |
||||
*/ |
||||
const char *protocol_blacklist; |
||||
|
||||
/**
|
||||
* A callback that is used instead of write_packet. |
||||
*/ |
||||
int (*write_data_type)(void *opaque, uint8_t *buf, int buf_size, |
||||
enum AVIODataMarkerType type, int64_t time); |
||||
/**
|
||||
* If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT, |
||||
* but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly |
||||
* small chunks of data returned from the callback). |
||||
*/ |
||||
int ignore_boundary_point; |
||||
|
||||
/**
|
||||
* Maximum reached position before a backward seek in the write buffer, |
||||
* used keeping track of already written data for a later flush. |
||||
*/ |
||||
unsigned char *buf_ptr_max; |
||||
|
||||
/**
|
||||
* Read-only statistic of bytes read for this AVIOContext. |
||||
*/ |
||||
int64_t bytes_read; |
||||
|
||||
/**
|
||||
* Read-only statistic of bytes written for this AVIOContext. |
||||
*/ |
||||
int64_t bytes_written; |
||||
} AVIOContext; |
||||
|
||||
/**
|
||||
* Return the name of the protocol that will handle the passed URL. |
||||
* |
||||
* NULL is returned if no protocol could be found for the given URL. |
||||
* |
||||
* @return Name of the protocol or NULL. |
||||
*/ |
||||
const char *avio_find_protocol_name(const char *url); |
||||
|
||||
/**
|
||||
* Return AVIO_FLAG_* access flags corresponding to the access permissions |
||||
* of the resource in url, or a negative value corresponding to an |
||||
* AVERROR code in case of failure. The returned access flags are |
||||
* masked by the value in flags. |
||||
* |
||||
* @note This function is intrinsically unsafe, in the sense that the |
||||
* checked resource may change its existence or permission status from |
||||
* one call to another. Thus you should not trust the returned value, |
||||
* unless you are sure that no other processes are accessing the |
||||
* checked resource. |
||||
*/ |
||||
int avio_check(const char *url, int flags); |
||||
|
||||
/**
|
||||
* Open directory for reading. |
||||
* |
||||
* @param s directory read context. Pointer to a NULL pointer must be passed. |
||||
* @param url directory to be listed. |
||||
* @param options A dictionary filled with protocol-private options. On return |
||||
* this parameter will be destroyed and replaced with a dictionary |
||||
* containing options that were not found. May be NULL. |
||||
* @return >=0 on success or negative on error. |
||||
*/ |
||||
int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options); |
||||
|
||||
/**
|
||||
* Get next directory entry. |
||||
* |
||||
* Returned entry must be freed with avio_free_directory_entry(). In particular |
||||
* it may outlive AVIODirContext. |
||||
* |
||||
* @param s directory read context. |
||||
* @param[out] next next entry or NULL when no more entries. |
||||
* @return >=0 on success or negative on error. End of list is not considered an |
||||
* error. |
||||
*/ |
||||
int avio_read_dir(AVIODirContext *s, AVIODirEntry **next); |
||||
|
||||
/**
|
||||
* Close directory. |
||||
* |
||||
* @note Entries created using avio_read_dir() are not deleted and must be |
||||
* freeded with avio_free_directory_entry(). |
||||
* |
||||
* @param s directory read context. |
||||
* @return >=0 on success or negative on error. |
||||
*/ |
||||
int avio_close_dir(AVIODirContext **s); |
||||
|
||||
/**
|
||||
* Free entry allocated by avio_read_dir(). |
||||
* |
||||
* @param entry entry to be freed. |
||||
*/ |
||||
void avio_free_directory_entry(AVIODirEntry **entry); |
||||
|
||||
/**
|
||||
* Allocate and initialize an AVIOContext for buffered I/O. It must be later |
||||
* freed with avio_context_free(). |
||||
* |
||||
* @param buffer Memory block for input/output operations via AVIOContext. |
||||
* The buffer must be allocated with av_malloc() and friends. |
||||
* It may be freed and replaced with a new buffer by libavformat. |
||||
* AVIOContext.buffer holds the buffer currently in use, |
||||
* which must be later freed with av_free(). |
||||
* @param buffer_size The buffer size is very important for performance. |
||||
* For protocols with fixed blocksize it should be set to this blocksize. |
||||
* For others a typical size is a cache page, e.g. 4kb. |
||||
* @param write_flag Set to 1 if the buffer should be writable, 0 otherwise. |
||||
* @param opaque An opaque pointer to user-specific data. |
||||
* @param read_packet A function for refilling the buffer, may be NULL. |
||||
* For stream protocols, must never return 0 but rather |
||||
* a proper AVERROR code. |
||||
* @param write_packet A function for writing the buffer contents, may be NULL. |
||||
* The function may not change the input buffers content. |
||||
* @param seek A function for seeking to specified byte position, may be NULL. |
||||
* |
||||
* @return Allocated AVIOContext or NULL on failure. |
||||
*/ |
||||
AVIOContext *avio_alloc_context( |
||||
unsigned char *buffer, |
||||
int buffer_size, |
||||
int write_flag, |
||||
void *opaque, |
||||
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), |
||||
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), |
||||
int64_t (*seek)(void *opaque, int64_t offset, int whence)); |
||||
|
||||
/**
|
||||
* Free the supplied IO context and everything associated with it. |
||||
* |
||||
* @param s Double pointer to the IO context. This function will write NULL |
||||
* into s. |
||||
*/ |
||||
void avio_context_free(AVIOContext **s); |
||||
|
||||
void avio_w8(AVIOContext *s, int b); |
||||
void avio_write(AVIOContext *s, const unsigned char *buf, int size); |
||||
void avio_wl64(AVIOContext *s, uint64_t val); |
||||
void avio_wb64(AVIOContext *s, uint64_t val); |
||||
void avio_wl32(AVIOContext *s, unsigned int val); |
||||
void avio_wb32(AVIOContext *s, unsigned int val); |
||||
void avio_wl24(AVIOContext *s, unsigned int val); |
||||
void avio_wb24(AVIOContext *s, unsigned int val); |
||||
void avio_wl16(AVIOContext *s, unsigned int val); |
||||
void avio_wb16(AVIOContext *s, unsigned int val); |
||||
|
||||
/**
|
||||
* Write a NULL-terminated string. |
||||
* @return number of bytes written. |
||||
*/ |
||||
int avio_put_str(AVIOContext *s, const char *str); |
||||
|
||||
/**
|
||||
* Convert an UTF-8 string to UTF-16LE and write it. |
||||
* @param s the AVIOContext |
||||
* @param str NULL-terminated UTF-8 string |
||||
* |
||||
* @return number of bytes written. |
||||
*/ |
||||
int avio_put_str16le(AVIOContext *s, const char *str); |
||||
|
||||
/**
|
||||
* Convert an UTF-8 string to UTF-16BE and write it. |
||||
* @param s the AVIOContext |
||||
* @param str NULL-terminated UTF-8 string |
||||
* |
||||
* @return number of bytes written. |
||||
*/ |
||||
int avio_put_str16be(AVIOContext *s, const char *str); |
||||
|
||||
/**
|
||||
* Mark the written bytestream as a specific type. |
||||
* |
||||
* Zero-length ranges are omitted from the output. |
||||
* |
||||
* @param s the AVIOContext |
||||
* @param time the stream time the current bytestream pos corresponds to |
||||
* (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not |
||||
* applicable |
||||
* @param type the kind of data written starting at the current pos |
||||
*/ |
||||
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type); |
||||
|
||||
/**
|
||||
* ORing this as the "whence" parameter to a seek function causes it to |
||||
* return the filesize without seeking anywhere. Supporting this is optional. |
||||
* If it is not supported then the seek function will return <0. |
||||
*/ |
||||
#define AVSEEK_SIZE 0x10000 |
||||
|
||||
/**
|
||||
* Passing this flag as the "whence" parameter to a seek function causes it to |
||||
* seek by any means (like reopening and linear reading) or other normally unreasonable |
||||
* means that can be extremely slow. |
||||
* This may be ignored by the seek code. |
||||
*/ |
||||
#define AVSEEK_FORCE 0x20000 |
||||
|
||||
/**
|
||||
* fseek() equivalent for AVIOContext. |
||||
* @return new position or AVERROR. |
||||
*/ |
||||
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence); |
||||
|
||||
/**
|
||||
* Skip given number of bytes forward |
||||
* @return new position or AVERROR. |
||||
*/ |
||||
int64_t avio_skip(AVIOContext *s, int64_t offset); |
||||
|
||||
/**
|
||||
* ftell() equivalent for AVIOContext. |
||||
* @return position or AVERROR. |
||||
*/ |
||||
static av_always_inline int64_t avio_tell(AVIOContext *s) |
||||
{ |
||||
return avio_seek(s, 0, SEEK_CUR); |
||||
} |
||||
|
||||
/**
|
||||
* Get the filesize. |
||||
* @return filesize or AVERROR |
||||
*/ |
||||
int64_t avio_size(AVIOContext *s); |
||||
|
||||
/**
|
||||
* Similar to feof() but also returns nonzero on read errors. |
||||
* @return non zero if and only if at end of file or a read error happened when reading. |
||||
*/ |
||||
int avio_feof(AVIOContext *s); |
||||
|
||||
/**
|
||||
* Writes a formatted string to the context taking a va_list. |
||||
* @return number of bytes written, < 0 on error. |
||||
*/ |
||||
int avio_vprintf(AVIOContext *s, const char *fmt, va_list ap); |
||||
|
||||
/**
|
||||
* Writes a formatted string to the context. |
||||
* @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. |
||||
* |
||||
* For write streams, force the buffered data to be immediately written to the output, |
||||
* without to wait to fill the internal buffer. |
||||
* |
||||
* For read streams, discard all currently buffered data, and advance the |
||||
* reported file position to that of the underlying stream. This does not |
||||
* read new data, and does not perform any seeks. |
||||
*/ |
||||
void avio_flush(AVIOContext *s); |
||||
|
||||
/**
|
||||
* Read size bytes from AVIOContext into buf. |
||||
* @return number of bytes read or AVERROR |
||||
*/ |
||||
int avio_read(AVIOContext *s, unsigned char *buf, int size); |
||||
|
||||
/**
|
||||
* Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed |
||||
* to read fewer bytes than requested. The missing bytes can be read in the next |
||||
* call. This always tries to read at least 1 byte. |
||||
* Useful to reduce latency in certain cases. |
||||
* @return number of bytes read or AVERROR |
||||
*/ |
||||
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size); |
||||
|
||||
/**
|
||||
* @name Functions for reading from AVIOContext |
||||
* @{ |
||||
* |
||||
* @note return 0 if EOF, so you cannot use it if EOF handling is |
||||
* necessary |
||||
*/ |
||||
int avio_r8 (AVIOContext *s); |
||||
unsigned int avio_rl16(AVIOContext *s); |
||||
unsigned int avio_rl24(AVIOContext *s); |
||||
unsigned int avio_rl32(AVIOContext *s); |
||||
uint64_t avio_rl64(AVIOContext *s); |
||||
unsigned int avio_rb16(AVIOContext *s); |
||||
unsigned int avio_rb24(AVIOContext *s); |
||||
unsigned int avio_rb32(AVIOContext *s); |
||||
uint64_t avio_rb64(AVIOContext *s); |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* Read a string from pb into buf. The reading will terminate when either |
||||
* a NULL character was encountered, maxlen bytes have been read, or nothing |
||||
* more can be read from pb. The result is guaranteed to be NULL-terminated, it |
||||
* will be truncated if buf is too small. |
||||
* Note that the string is not interpreted or validated in any way, it |
||||
* might get truncated in the middle of a sequence for multi-byte encodings. |
||||
* |
||||
* @return number of bytes read (is always <= maxlen). |
||||
* If reading ends on EOF or error, the return value will be one more than |
||||
* bytes actually read. |
||||
*/ |
||||
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen); |
||||
|
||||
/**
|
||||
* Read a UTF-16 string from pb and convert it to UTF-8. |
||||
* The reading will terminate when either a null or invalid character was |
||||
* encountered or maxlen bytes have been read. |
||||
* @return number of bytes read (is always <= maxlen) |
||||
*/ |
||||
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen); |
||||
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen); |
||||
|
||||
|
||||
/**
|
||||
* @name URL open modes |
||||
* The flags argument to avio_open must be one of the following |
||||
* constants, optionally ORed with other flags. |
||||
* @{ |
||||
*/ |
||||
#define AVIO_FLAG_READ 1 /**< read-only */ |
||||
#define AVIO_FLAG_WRITE 2 /**< write-only */ |
||||
#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE) /**< read-write pseudo flag */ |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* Use non-blocking mode. |
||||
* If this flag is set, operations on the context will return |
||||
* AVERROR(EAGAIN) if they can not be performed immediately. |
||||
* If this flag is not set, operations on the context will never return |
||||
* AVERROR(EAGAIN). |
||||
* Note that this flag does not affect the opening/connecting of the |
||||
* context. Connecting a protocol will always block if necessary (e.g. on |
||||
* network protocols) but never hang (e.g. on busy devices). |
||||
* Warning: non-blocking protocols is work-in-progress; this flag may be |
||||
* silently ignored. |
||||
*/ |
||||
#define AVIO_FLAG_NONBLOCK 8 |
||||
|
||||
/**
|
||||
* Use direct mode. |
||||
* avio_read and avio_write should if possible be satisfied directly |
||||
* instead of going through a buffer, and avio_seek will always |
||||
* call the underlying seek function directly. |
||||
*/ |
||||
#define AVIO_FLAG_DIRECT 0x8000 |
||||
|
||||
/**
|
||||
* Create and initialize a AVIOContext for accessing the |
||||
* resource indicated by url. |
||||
* @note When the resource indicated by url has been opened in |
||||
* read+write mode, the AVIOContext can be used only for writing. |
||||
* |
||||
* @param s Used to return the pointer to the created AVIOContext. |
||||
* In case of failure the pointed to value is set to NULL. |
||||
* @param url resource to access |
||||
* @param flags flags which control how the resource indicated by url |
||||
* is to be opened |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code in case of failure |
||||
*/ |
||||
int avio_open(AVIOContext **s, const char *url, int flags); |
||||
|
||||
/**
|
||||
* Create and initialize a AVIOContext for accessing the |
||||
* resource indicated by url. |
||||
* @note When the resource indicated by url has been opened in |
||||
* read+write mode, the AVIOContext can be used only for writing. |
||||
* |
||||
* @param s Used to return the pointer to the created AVIOContext. |
||||
* In case of failure the pointed to value is set to NULL. |
||||
* @param url resource to access |
||||
* @param flags flags which control how the resource indicated by url |
||||
* is to be opened |
||||
* @param int_cb an interrupt callback to be used at the protocols level |
||||
* @param options A dictionary filled with protocol-private options. On return |
||||
* this parameter will be destroyed and replaced with a dict containing options |
||||
* that were not found. May be NULL. |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code in case of failure |
||||
*/ |
||||
int avio_open2(AVIOContext **s, const char *url, int flags, |
||||
const AVIOInterruptCB *int_cb, AVDictionary **options); |
||||
|
||||
/**
|
||||
* Close the resource accessed by the AVIOContext s and free it. |
||||
* This function can only be used if s was opened by avio_open(). |
||||
* |
||||
* The internal buffer is automatically flushed before closing the |
||||
* resource. |
||||
* |
||||
* @return 0 on success, an AVERROR < 0 on error. |
||||
* @see avio_closep |
||||
*/ |
||||
int avio_close(AVIOContext *s); |
||||
|
||||
/**
|
||||
* Close the resource accessed by the AVIOContext *s, free it |
||||
* and set the pointer pointing to it to NULL. |
||||
* This function can only be used if s was opened by avio_open(). |
||||
* |
||||
* The internal buffer is automatically flushed before closing the |
||||
* resource. |
||||
* |
||||
* @return 0 on success, an AVERROR < 0 on error. |
||||
* @see avio_close |
||||
*/ |
||||
int avio_closep(AVIOContext **s); |
||||
|
||||
|
||||
/**
|
||||
* Open a write only memory stream. |
||||
* |
||||
* @param s new IO context |
||||
* @return zero if no error. |
||||
*/ |
||||
int avio_open_dyn_buf(AVIOContext **s); |
||||
|
||||
/**
|
||||
* Return the written size and a pointer to the buffer. |
||||
* The AVIOContext stream is left intact. |
||||
* The buffer must NOT be freed. |
||||
* No padding is added to the buffer. |
||||
* |
||||
* @param s IO context |
||||
* @param pbuffer pointer to a byte buffer |
||||
* @return the length of the byte buffer |
||||
*/ |
||||
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer); |
||||
|
||||
/**
|
||||
* Return the written size and a pointer to the buffer. The buffer |
||||
* must be freed with av_free(). |
||||
* Padding of AV_INPUT_BUFFER_PADDING_SIZE is added to the buffer. |
||||
* |
||||
* @param s IO context |
||||
* @param pbuffer pointer to a byte buffer |
||||
* @return the length of the byte buffer |
||||
*/ |
||||
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer); |
||||
|
||||
/**
|
||||
* Iterate through names of available protocols. |
||||
* |
||||
* @param opaque A private pointer representing current protocol. |
||||
* It must be a pointer to NULL on first iteration and will |
||||
* be updated by successive calls to avio_enum_protocols. |
||||
* @param output If set to 1, iterate over output protocols, |
||||
* otherwise over input protocols. |
||||
* |
||||
* @return A static string containing the name of current protocol or NULL |
||||
*/ |
||||
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). |
||||
* |
||||
* @param h IO context from which to call the read_pause function pointer |
||||
* @param pause 1 for pause, 0 for resume |
||||
*/ |
||||
int avio_pause(AVIOContext *h, int pause); |
||||
|
||||
/**
|
||||
* Seek to a given timestamp relative to some component stream. |
||||
* Only meaningful if using a network streaming protocol (e.g. MMS.). |
||||
* |
||||
* @param h IO context from which to call the seek function pointers |
||||
* @param stream_index The stream index that the timestamp is relative to. |
||||
* If stream_index is (-1) the timestamp should be in AV_TIME_BASE |
||||
* units from the beginning of the presentation. |
||||
* If a stream_index >= 0 is used and the protocol does not support |
||||
* seeking based on component streams, the call will fail. |
||||
* @param timestamp timestamp in AVStream.time_base units |
||||
* or if there is no stream specified then in AV_TIME_BASE units. |
||||
* @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE |
||||
* and AVSEEK_FLAG_ANY. The protocol may silently ignore |
||||
* AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will |
||||
* fail if used and not supported. |
||||
* @return >= 0 on success |
||||
* @see AVInputFormat::read_seek |
||||
*/ |
||||
int64_t avio_seek_time(AVIOContext *h, int stream_index, |
||||
int64_t timestamp, int flags); |
||||
|
||||
/* Avoid a warning. The header can not be included because it breaks c++. */ |
||||
struct AVBPrint; |
||||
|
||||
/**
|
||||
* Read contents of h into print buffer, up to max_size bytes, or up to EOF. |
||||
* |
||||
* @return 0 for success (max_size bytes read or EOF reached), negative error |
||||
* code otherwise |
||||
*/ |
||||
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size); |
||||
|
||||
/**
|
||||
* Accept and allocate a client context on a server context. |
||||
* @param s the server context |
||||
* @param c the client context, must be unallocated |
||||
* @return >= 0 on success or a negative value corresponding |
||||
* to an AVERROR on failure |
||||
*/ |
||||
int avio_accept(AVIOContext *s, AVIOContext **c); |
||||
|
||||
/**
|
||||
* Perform one step of the protocol handshake to accept a new client. |
||||
* This function must be called on a client returned by avio_accept() before |
||||
* using it as a read/write context. |
||||
* It is separate from avio_accept() because it may block. |
||||
* A step of the handshake is defined by places where the application may |
||||
* decide to change the proceedings. |
||||
* For example, on a protocol with a request header and a reply header, each |
||||
* one can constitute a step because the application may use the parameters |
||||
* from the request to change parameters in the reply; or each individual |
||||
* chunk of the request can constitute a step. |
||||
* If the handshake is already finished, avio_handshake() does nothing and |
||||
* returns 0 immediately. |
||||
* |
||||
* @param c the client context to perform the handshake on |
||||
* @return 0 on a complete and successful handshake |
||||
* > 0 if the handshake progressed, but is not complete |
||||
* < 0 for an AVERROR code |
||||
*/ |
||||
int avio_handshake(AVIOContext *c); |
||||
#endif /* AVFORMAT_AVIO_H */ |
||||
@ -0,0 +1,341 @@ |
||||
/*
|
||||
* Copyright (c) 2007 The FFmpeg Project |
||||
* |
||||
* 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_NETWORK_H |
||||
#define AVFORMAT_NETWORK_H |
||||
|
||||
#include <errno.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "config.h" |
||||
#include "libavutil/error.h" |
||||
#include "os_support.h" |
||||
#include "avio.h" |
||||
#include "url.h" |
||||
|
||||
#if HAVE_UNISTD_H |
||||
#include <unistd.h> |
||||
#endif |
||||
|
||||
#if HAVE_WINSOCK2_H |
||||
#include <winsock2.h> |
||||
#include <ws2tcpip.h> |
||||
|
||||
#ifndef EPROTONOSUPPORT |
||||
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT |
||||
#endif |
||||
#ifndef ETIMEDOUT |
||||
#define ETIMEDOUT WSAETIMEDOUT |
||||
#endif |
||||
#ifndef ECONNREFUSED |
||||
#define ECONNREFUSED WSAECONNREFUSED |
||||
#endif |
||||
#ifndef EINPROGRESS |
||||
#define EINPROGRESS WSAEINPROGRESS |
||||
#endif |
||||
#ifndef ENOTCONN |
||||
#define ENOTCONN WSAENOTCONN |
||||
#endif |
||||
|
||||
#define getsockopt(a, b, c, d, e) getsockopt(a, b, c, (char*) d, e) |
||||
#define setsockopt(a, b, c, d, e) setsockopt(a, b, c, (const char*) d, e) |
||||
|
||||
int ff_neterrno(void); |
||||
#else |
||||
#include <sys/types.h> |
||||
#include <sys/socket.h> |
||||
#include <netinet/in.h> |
||||
#include <netinet/tcp.h> |
||||
#include <netdb.h> |
||||
|
||||
#define ff_neterrno() AVERROR(errno) |
||||
#endif /* HAVE_WINSOCK2_H */ |
||||
|
||||
#if HAVE_ARPA_INET_H |
||||
#include <arpa/inet.h> |
||||
#endif |
||||
|
||||
#if HAVE_POLL_H |
||||
#include <poll.h> |
||||
#endif |
||||
|
||||
int ff_socket_nonblock(int socket, int enable); |
||||
|
||||
int ff_network_init(void); |
||||
void ff_network_close(void); |
||||
|
||||
int ff_tls_init(void); |
||||
void ff_tls_deinit(void); |
||||
|
||||
int ff_network_wait_fd(int fd, int write); |
||||
|
||||
/**
|
||||
* This works similarly to ff_network_wait_fd, but waits up to 'timeout' microseconds |
||||
* Uses ff_network_wait_fd in a loop |
||||
* |
||||
* @param fd Socket descriptor |
||||
* @param write Set 1 to wait for socket able to be read, 0 to be written |
||||
* @param timeout Timeout interval, in microseconds. Actual precision is 100000 mcs, due to ff_network_wait_fd usage |
||||
* @param int_cb Interrupt callback, is checked before each ff_network_wait_fd call |
||||
* @return 0 if data can be read/written, AVERROR(ETIMEDOUT) if timeout expired, or negative error code |
||||
*/ |
||||
int ff_network_wait_fd_timeout(int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb); |
||||
|
||||
/**
|
||||
* Waits for up to 'timeout' microseconds. If the usert's int_cb is set and |
||||
* triggered, return before that. |
||||
* @param timeout Timeout in microseconds. Maybe have lower actual precision. |
||||
* @param int_cb Interrupt callback, is checked regularly. |
||||
* @return AVERROR(ETIMEDOUT) if timeout expirted, AVERROR_EXIT if interrupted by int_cb |
||||
*/ |
||||
int ff_network_sleep_interruptible(int64_t timeout, AVIOInterruptCB *int_cb); |
||||
|
||||
#if !HAVE_STRUCT_SOCKADDR_STORAGE |
||||
struct sockaddr_storage { |
||||
#if HAVE_STRUCT_SOCKADDR_SA_LEN |
||||
uint8_t ss_len; |
||||
uint8_t ss_family; |
||||
#else |
||||
uint16_t ss_family; |
||||
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */ |
||||
char ss_pad1[6]; |
||||
int64_t ss_align; |
||||
char ss_pad2[112]; |
||||
}; |
||||
#endif /* !HAVE_STRUCT_SOCKADDR_STORAGE */ |
||||
|
||||
typedef union sockaddr_union { |
||||
struct sockaddr_storage storage; |
||||
struct sockaddr_in in; |
||||
#if HAVE_STRUCT_SOCKADDR_IN6 |
||||
struct sockaddr_in6 in6; |
||||
#endif |
||||
} sockaddr_union; |
||||
|
||||
#ifndef MSG_NOSIGNAL |
||||
#define MSG_NOSIGNAL 0 |
||||
#endif |
||||
|
||||
#if !HAVE_STRUCT_ADDRINFO |
||||
struct addrinfo { |
||||
int ai_flags; |
||||
int ai_family; |
||||
int ai_socktype; |
||||
int ai_protocol; |
||||
int ai_addrlen; |
||||
struct sockaddr *ai_addr; |
||||
char *ai_canonname; |
||||
struct addrinfo *ai_next; |
||||
}; |
||||
#endif /* !HAVE_STRUCT_ADDRINFO */ |
||||
|
||||
/* getaddrinfo constants */ |
||||
#ifndef EAI_AGAIN |
||||
#define EAI_AGAIN 2 |
||||
#endif |
||||
#ifndef EAI_BADFLAGS |
||||
#define EAI_BADFLAGS 3 |
||||
#endif |
||||
#ifndef EAI_FAIL |
||||
#define EAI_FAIL 4 |
||||
#endif |
||||
#ifndef EAI_FAMILY |
||||
#define EAI_FAMILY 5 |
||||
#endif |
||||
#ifndef EAI_MEMORY |
||||
#define EAI_MEMORY 6 |
||||
#endif |
||||
#ifndef EAI_NODATA |
||||
#define EAI_NODATA 7 |
||||
#endif |
||||
#ifndef EAI_NONAME |
||||
#define EAI_NONAME 8 |
||||
#endif |
||||
#ifndef EAI_SERVICE |
||||
#define EAI_SERVICE 9 |
||||
#endif |
||||
#ifndef EAI_SOCKTYPE |
||||
#define EAI_SOCKTYPE 10 |
||||
#endif |
||||
|
||||
#ifndef AI_PASSIVE |
||||
#define AI_PASSIVE 1 |
||||
#endif |
||||
|
||||
#ifndef AI_CANONNAME |
||||
#define AI_CANONNAME 2 |
||||
#endif |
||||
|
||||
#ifndef AI_NUMERICHOST |
||||
#define AI_NUMERICHOST 4 |
||||
#endif |
||||
|
||||
#ifndef NI_NOFQDN |
||||
#define NI_NOFQDN 1 |
||||
#endif |
||||
|
||||
#ifndef NI_NUMERICHOST |
||||
#define NI_NUMERICHOST 2 |
||||
#endif |
||||
|
||||
#ifndef NI_NAMERQD |
||||
#define NI_NAMERQD 4 |
||||
#endif |
||||
|
||||
#ifndef NI_NUMERICSERV |
||||
#define NI_NUMERICSERV 8 |
||||
#endif |
||||
|
||||
#ifndef NI_DGRAM |
||||
#define NI_DGRAM 16 |
||||
#endif |
||||
|
||||
#if !HAVE_GETADDRINFO |
||||
int ff_getaddrinfo(const char *node, const char *service, |
||||
const struct addrinfo *hints, struct addrinfo **res); |
||||
void ff_freeaddrinfo(struct addrinfo *res); |
||||
int ff_getnameinfo(const struct sockaddr *sa, int salen, |
||||
char *host, int hostlen, |
||||
char *serv, int servlen, int flags); |
||||
#define getaddrinfo ff_getaddrinfo |
||||
#define freeaddrinfo ff_freeaddrinfo |
||||
#define getnameinfo ff_getnameinfo |
||||
#endif /* !HAVE_GETADDRINFO */ |
||||
|
||||
#if !HAVE_GETADDRINFO || HAVE_WINSOCK2_H |
||||
const char *ff_gai_strerror(int ecode); |
||||
#undef gai_strerror |
||||
#define gai_strerror ff_gai_strerror |
||||
#endif /* !HAVE_GETADDRINFO || HAVE_WINSOCK2_H */ |
||||
|
||||
#ifndef INADDR_LOOPBACK |
||||
#define INADDR_LOOPBACK 0x7f000001 |
||||
#endif |
||||
|
||||
#ifndef INET_ADDRSTRLEN |
||||
#define INET_ADDRSTRLEN 16 |
||||
#endif |
||||
|
||||
#ifndef INET6_ADDRSTRLEN |
||||
#define INET6_ADDRSTRLEN INET_ADDRSTRLEN |
||||
#endif |
||||
|
||||
#ifndef IN_MULTICAST |
||||
#define IN_MULTICAST(a) ((((uint32_t)(a)) & 0xf0000000) == 0xe0000000) |
||||
#endif |
||||
#ifndef IN6_IS_ADDR_MULTICAST |
||||
#define IN6_IS_ADDR_MULTICAST(a) (((uint8_t *) (a))[0] == 0xff) |
||||
#endif |
||||
|
||||
int ff_is_multicast_address(struct sockaddr *addr); |
||||
|
||||
#define POLLING_TIME 100 /// Time in milliseconds between interrupt check
|
||||
|
||||
/**
|
||||
* Bind to a file descriptor and poll for a connection. |
||||
* |
||||
* @param fd First argument of bind(). |
||||
* @param addr Second argument of bind(). |
||||
* @param addrlen Third argument of bind(). |
||||
* @param timeout Polling timeout in milliseconds. |
||||
* @param h URLContext providing interrupt check |
||||
* callback and logging context. |
||||
* @return A non-blocking file descriptor on success |
||||
* or an AVERROR on failure. |
||||
*/ |
||||
int ff_listen_bind(int fd, const struct sockaddr *addr, |
||||
socklen_t addrlen, int timeout, |
||||
URLContext *h); |
||||
|
||||
/**
|
||||
* Bind to a file descriptor to an address without accepting connections. |
||||
* @param fd First argument of bind(). |
||||
* @param addr Second argument of bind(). |
||||
* @param addrlen Third argument of bind(). |
||||
* @return 0 on success or an AVERROR on failure. |
||||
*/ |
||||
int ff_listen(int fd, const struct sockaddr *addr, socklen_t addrlen, |
||||
void *logctx); |
||||
|
||||
/**
|
||||
* Poll for a single connection on the passed file descriptor. |
||||
* @param fd The listening socket file descriptor. |
||||
* @param timeout Polling timeout in milliseconds. |
||||
* @param h URLContext providing interrupt check |
||||
* callback and logging context. |
||||
* @return A non-blocking file descriptor on success |
||||
* or an AVERROR on failure. |
||||
*/ |
||||
int ff_accept(int fd, int timeout, URLContext *h); |
||||
|
||||
/**
|
||||
* Connect to a file descriptor and poll for result. |
||||
* |
||||
* @param fd First argument of connect(), |
||||
* will be set as non-blocking. |
||||
* @param addr Second argument of connect(). |
||||
* @param addrlen Third argument of connect(). |
||||
* @param timeout Polling timeout in milliseconds. |
||||
* @param h URLContext providing interrupt check |
||||
* callback and logging context. |
||||
* @param will_try_next Whether the caller will try to connect to another |
||||
* address for the same host name, affecting the form of |
||||
* logged errors. |
||||
* @return 0 on success, AVERROR on failure. |
||||
*/ |
||||
int ff_listen_connect(int fd, const struct sockaddr *addr, |
||||
socklen_t addrlen, int timeout, |
||||
URLContext *h, int will_try_next); |
||||
|
||||
int ff_http_match_no_proxy(const char *no_proxy, const char *hostname); |
||||
|
||||
int ff_socket(int domain, int type, int protocol, void *logctx); |
||||
|
||||
void ff_log_net_error(void *ctx, int level, const char* prefix); |
||||
|
||||
/**
|
||||
* Connect to any of the given addrinfo addresses, with multiple attempts |
||||
* running in parallel. |
||||
* |
||||
* @param addrs The list of addresses to try to connect to. |
||||
* This list will be mutated internally, but the list head |
||||
* will remain as such, so this doesn't affect the caller |
||||
* freeing the list afterwards. |
||||
* @param timeout_ms_per_address The number of milliseconds to wait for each |
||||
* connection attempt. Since multiple addresses are tried, |
||||
* some of them in parallel, the total run time will at most |
||||
* be timeout_ms_per_address*ceil(nb_addrs/parallel) + |
||||
* (parallel - 1) * NEXT_ATTEMPT_DELAY_MS. |
||||
* @param parallel The maximum number of connections to attempt in parallel. |
||||
* This is limited to an internal maximum capacity. |
||||
* @param h URLContext providing interrupt check |
||||
* callback and logging context. |
||||
* @param fd If successful, the connected socket is returned here. |
||||
* @param customize_fd Function that will be called for each socket created, |
||||
* to allow the caller to set socket options before calling |
||||
* connect() on it, may be NULL. |
||||
* @param customize_ctx Context parameter passed to customize_fd. |
||||
* @return 0 on success, AVERROR on failure. |
||||
*/ |
||||
int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address, |
||||
int parallel, URLContext *h, int *fd, |
||||
void (*customize_fd)(void *, int), void *customize_ctx); |
||||
|
||||
#endif /* AVFORMAT_NETWORK_H */ |
||||
@ -0,0 +1,317 @@ |
||||
/*
|
||||
* various OS-feature replacement utilities |
||||
* copyright (c) 2000, 2001, 2002 Fabrice Bellard |
||||
* |
||||
* 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_OS_SUPPORT_H |
||||
#define AVFORMAT_OS_SUPPORT_H |
||||
|
||||
/**
|
||||
* @file |
||||
* miscellaneous OS support macros and functions. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <sys/stat.h> |
||||
|
||||
#ifdef _WIN32 |
||||
#if HAVE_DIRECT_H |
||||
#include <direct.h> |
||||
#endif |
||||
#if HAVE_IO_H |
||||
#include <io.h> |
||||
#endif |
||||
#endif |
||||
|
||||
#ifdef _WIN32 |
||||
# include <fcntl.h> |
||||
# include <stdint.h> |
||||
# ifdef lseek |
||||
# undef lseek |
||||
# endif |
||||
# define lseek(f,p,w) _lseeki64((f), (p), (w)) |
||||
# ifdef stat |
||||
# undef stat |
||||
# endif |
||||
|
||||
# define stat win32_stat |
||||
|
||||
/*
|
||||
* The POSIX definition for the stat() function uses a struct of the |
||||
* same name (struct stat), that why it takes this extra effort for |
||||
* redirecting/replacing the stat() function with our own one which |
||||
* is capable to handle long path names on Windows. |
||||
* The struct below roughly follows the POSIX definition. Time values |
||||
* are 64bit, but in cases when _USE_32BIT_TIME_T is defined, they |
||||
* will be set to values no larger than INT32_MAX which corresponds |
||||
* to file times up to the year 2038. |
||||
*/ |
||||
struct win32_stat |
||||
{ |
||||
_dev_t st_dev; /* ID of device containing file */ |
||||
_ino_t st_ino; /* inode number */ |
||||
unsigned short st_mode; /* protection */ |
||||
short st_nlink; /* number of hard links */ |
||||
short st_uid; /* user ID of owner */ |
||||
short st_gid; /* group ID of owner */ |
||||
_dev_t st_rdev; /* device ID (if special file) */ |
||||
int64_t st_size; /* total size, in bytes */ |
||||
int64_t st_atime; /* time of last access */ |
||||
int64_t st_mtime; /* time of last modification */ |
||||
int64_t st_ctime; /* time of last status change */ |
||||
}; |
||||
|
||||
# ifdef fstat |
||||
# undef fstat |
||||
# endif |
||||
# define fstat win32_fstat |
||||
#endif /* defined(_WIN32) */ |
||||
|
||||
|
||||
#ifdef __ANDROID__ |
||||
# if HAVE_UNISTD_H |
||||
# include <unistd.h> |
||||
# endif |
||||
# ifdef lseek |
||||
# undef lseek |
||||
# endif |
||||
# define lseek(f,p,w) lseek64((f), (p), (w)) |
||||
#endif |
||||
|
||||
static inline int is_dos_path(const char *path) |
||||
{ |
||||
#if HAVE_DOS_PATHS |
||||
if (path[0] && path[1] == ':') |
||||
return 1; |
||||
#endif |
||||
return 0; |
||||
} |
||||
|
||||
#if defined(_WIN32) |
||||
#ifndef S_IRUSR |
||||
#define S_IRUSR S_IREAD |
||||
#endif |
||||
#ifndef S_IWUSR |
||||
#define S_IWUSR S_IWRITE |
||||
#endif |
||||
#endif |
||||
|
||||
#if CONFIG_NETWORK |
||||
#if defined(_WIN32) |
||||
#define SHUT_RD SD_RECEIVE |
||||
#define SHUT_WR SD_SEND |
||||
#define SHUT_RDWR SD_BOTH |
||||
#else |
||||
#include <sys/socket.h> |
||||
#if !defined(SHUT_RD) /* OS/2, DJGPP */ |
||||
#define SHUT_RD 0 |
||||
#define SHUT_WR 1 |
||||
#define SHUT_RDWR 2 |
||||
#endif |
||||
#endif |
||||
|
||||
#if !HAVE_SOCKLEN_T |
||||
typedef int socklen_t; |
||||
#endif |
||||
|
||||
/* most of the time closing a socket is just closing an fd */ |
||||
#if !HAVE_CLOSESOCKET |
||||
#define closesocket close |
||||
#endif |
||||
|
||||
#if !HAVE_POLL_H |
||||
typedef unsigned long nfds_t; |
||||
|
||||
#if HAVE_WINSOCK2_H |
||||
#include <winsock2.h> |
||||
#endif |
||||
#if !HAVE_STRUCT_POLLFD |
||||
struct pollfd { |
||||
int fd; |
||||
short events; /* events to look for */ |
||||
short revents; /* events that occurred */ |
||||
}; |
||||
|
||||
/* events & revents */ |
||||
#define POLLIN 0x0001 /* any readable data available */ |
||||
#define POLLOUT 0x0002 /* file descriptor is writeable */ |
||||
#define POLLRDNORM POLLIN |
||||
#define POLLWRNORM POLLOUT |
||||
#define POLLRDBAND 0x0008 /* priority readable data */ |
||||
#define POLLWRBAND 0x0010 /* priority data can be written */ |
||||
#define POLLPRI 0x0020 /* high priority readable data */ |
||||
|
||||
/* revents only */ |
||||
#define POLLERR 0x0004 /* errors pending */ |
||||
#define POLLHUP 0x0080 /* disconnected */ |
||||
#define POLLNVAL 0x1000 /* invalid file descriptor */ |
||||
#endif |
||||
|
||||
|
||||
int ff_poll(struct pollfd *fds, nfds_t numfds, int timeout); |
||||
#define poll ff_poll |
||||
#endif /* HAVE_POLL_H */ |
||||
#endif /* CONFIG_NETWORK */ |
||||
|
||||
#ifdef _WIN32 |
||||
#include <stdio.h> |
||||
#include <windows.h> |
||||
#include "libavutil/wchar_filename.h" |
||||
|
||||
#define DEF_FS_FUNCTION(name, wfunc, afunc) \ |
||||
static inline int win32_##name(const char *filename_utf8) \
|
||||
{ \
|
||||
wchar_t *filename_w; \
|
||||
int ret; \
|
||||
\
|
||||
if (get_extended_win32_path(filename_utf8, &filename_w)) \
|
||||
return -1; \
|
||||
if (!filename_w) \
|
||||
goto fallback; \
|
||||
\
|
||||
ret = wfunc(filename_w); \
|
||||
av_free(filename_w); \
|
||||
return ret; \
|
||||
\
|
||||
fallback: \
|
||||
/* filename may be be in CP_ACP */ \
|
||||
return afunc(filename_utf8); \
|
||||
} |
||||
|
||||
DEF_FS_FUNCTION(unlink, _wunlink, _unlink) |
||||
DEF_FS_FUNCTION(mkdir, _wmkdir, _mkdir) |
||||
DEF_FS_FUNCTION(rmdir, _wrmdir , _rmdir) |
||||
|
||||
static inline int win32_access(const char *filename_utf8, int mode) |
||||
{ |
||||
wchar_t *filename_w; |
||||
int ret; |
||||
if (get_extended_win32_path(filename_utf8, &filename_w)) |
||||
return -1; |
||||
if (!filename_w) |
||||
goto fallback; |
||||
ret = _waccess(filename_w, mode); |
||||
av_free(filename_w); |
||||
return ret; |
||||
fallback: |
||||
return _access(filename_utf8, mode); |
||||
} |
||||
|
||||
static inline void copy_stat(struct _stat64 *crtstat, struct win32_stat *buf) |
||||
{ |
||||
buf->st_dev = crtstat->st_dev; |
||||
buf->st_ino = crtstat->st_ino; |
||||
buf->st_mode = crtstat->st_mode; |
||||
buf->st_nlink = crtstat->st_nlink; |
||||
buf->st_uid = crtstat->st_uid; |
||||
buf->st_gid = crtstat->st_gid; |
||||
buf->st_rdev = crtstat->st_rdev; |
||||
buf->st_size = crtstat->st_size; |
||||
buf->st_atime = crtstat->st_atime; |
||||
buf->st_mtime = crtstat->st_mtime; |
||||
buf->st_ctime = crtstat->st_ctime; |
||||
} |
||||
|
||||
static inline int win32_stat(const char *filename_utf8, struct win32_stat *buf) |
||||
{ |
||||
struct _stat64 crtstat = { 0 }; |
||||
wchar_t *filename_w; |
||||
int ret; |
||||
|
||||
if (get_extended_win32_path(filename_utf8, &filename_w)) |
||||
return -1; |
||||
|
||||
if (filename_w) { |
||||
ret = _wstat64(filename_w, &crtstat); |
||||
av_free(filename_w); |
||||
} else |
||||
ret = _stat64(filename_utf8, &crtstat); |
||||
|
||||
copy_stat(&crtstat, buf); |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static inline int win32_fstat(int fd, struct win32_stat *buf) |
||||
{ |
||||
struct _stat64 crtstat = { 0 }; |
||||
int ret; |
||||
|
||||
ret = _fstat64(fd, &crtstat); |
||||
|
||||
copy_stat(&crtstat, buf); |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static inline int win32_rename(const char *src_utf8, const char *dest_utf8) |
||||
{ |
||||
wchar_t *src_w, *dest_w; |
||||
int ret; |
||||
|
||||
if (get_extended_win32_path(src_utf8, &src_w)) |
||||
return -1; |
||||
if (get_extended_win32_path(dest_utf8, &dest_w)) { |
||||
av_free(src_w); |
||||
return -1; |
||||
} |
||||
if (!src_w || !dest_w) { |
||||
av_free(src_w); |
||||
av_free(dest_w); |
||||
goto fallback; |
||||
} |
||||
|
||||
ret = MoveFileExW(src_w, dest_w, MOVEFILE_REPLACE_EXISTING); |
||||
av_free(src_w); |
||||
av_free(dest_w); |
||||
// Lacking proper mapping from GetLastError() error codes to errno codes
|
||||
if (ret) |
||||
errno = EPERM; |
||||
return ret; |
||||
|
||||
fallback: |
||||
/* filename may be be in CP_ACP */ |
||||
#if !HAVE_UWP |
||||
ret = MoveFileExA(src_utf8, dest_utf8, MOVEFILE_REPLACE_EXISTING); |
||||
if (ret) |
||||
errno = EPERM; |
||||
#else |
||||
/* Windows Phone doesn't have MoveFileExA, and for Windows Store apps,
|
||||
* it is available but not allowed by the app certification kit. However, |
||||
* it's unlikely that anybody would input filenames in CP_ACP there, so this |
||||
* fallback is kept mostly for completeness. Alternatively we could |
||||
* do MultiByteToWideChar(CP_ACP) and use MoveFileExW, but doing |
||||
* explicit conversions with CP_ACP is allegedly forbidden in windows |
||||
* store apps (or windows phone), and the notion of a native code page |
||||
* doesn't make much sense there. */ |
||||
ret = rename(src_utf8, dest_utf8); |
||||
#endif |
||||
return ret; |
||||
} |
||||
|
||||
#define mkdir(a, b) win32_mkdir(a) |
||||
#define rename win32_rename |
||||
#define rmdir win32_rmdir |
||||
#define unlink win32_unlink |
||||
#define access win32_access |
||||
|
||||
#endif |
||||
|
||||
#endif /* AVFORMAT_OS_SUPPORT_H */ |
||||
@ -0,0 +1,409 @@ |
||||
/*
|
||||
* 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 |
||||
* unbuffered private I/O API |
||||
*/ |
||||
|
||||
#ifndef AVFORMAT_URL_H |
||||
#define AVFORMAT_URL_H |
||||
|
||||
#include "avio.h" |
||||
|
||||
#include "libavutil/dict.h" |
||||
#include "libavutil/log.h" |
||||
|
||||
#define URL_PROTOCOL_FLAG_NESTED_SCHEME 1 /*< The protocol name can be the first part of a nested protocol scheme */ |
||||
#define URL_PROTOCOL_FLAG_NETWORK 2 /*< The protocol uses network */ |
||||
|
||||
extern const AVClass ffurl_context_class; |
||||
|
||||
typedef struct URLContext { |
||||
const AVClass *av_class; /**< information for av_log(). Set by url_open(). */ |
||||
const struct URLProtocol *prot; |
||||
void *priv_data; |
||||
char *filename; /**< specified URL */ |
||||
int flags; |
||||
int max_packet_size; /**< if non zero, the stream is packetized with this max packet size */ |
||||
int is_streamed; /**< true if streamed (no seek possible), default = false */ |
||||
int is_connected; |
||||
AVIOInterruptCB interrupt_callback; |
||||
int64_t rw_timeout; /**< maximum time to wait for (network) read/write operation completion, in mcs */ |
||||
const char *protocol_whitelist; |
||||
const char *protocol_blacklist; |
||||
int min_packet_size; /**< if non zero, the stream is packetized with this min packet size */ |
||||
} URLContext; |
||||
|
||||
typedef struct URLProtocol { |
||||
const char *name; |
||||
int (*url_open)( URLContext *h, const char *url, int flags); |
||||
/**
|
||||
* This callback is to be used by protocols which open further nested |
||||
* protocols. options are then to be passed to ffurl_open_whitelist() |
||||
* or ffurl_connect() for those nested protocols. |
||||
*/ |
||||
int (*url_open2)(URLContext *h, const char *url, int flags, AVDictionary **options); |
||||
int (*url_accept)(URLContext *s, URLContext **c); |
||||
int (*url_handshake)(URLContext *c); |
||||
|
||||
/**
|
||||
* Read data from the protocol. |
||||
* If data is immediately available (even less than size), EOF is |
||||
* reached or an error occurs (including EINTR), return immediately. |
||||
* Otherwise: |
||||
* In non-blocking mode, return AVERROR(EAGAIN) immediately. |
||||
* In blocking mode, wait for data/EOF/error with a short timeout (0.1s), |
||||
* and return AVERROR(EAGAIN) on timeout. |
||||
* Checking interrupt_callback, looping on EINTR and EAGAIN and until |
||||
* enough data has been read is left to the calling function; see |
||||
* retry_transfer_wrapper in avio.c. |
||||
*/ |
||||
int (*url_read)( URLContext *h, unsigned char *buf, int size); |
||||
int (*url_write)(URLContext *h, const unsigned char *buf, int size); |
||||
int64_t (*url_seek)( URLContext *h, int64_t pos, int whence); |
||||
int (*url_close)(URLContext *h); |
||||
int (*url_read_pause)(URLContext *h, int pause); |
||||
int64_t (*url_read_seek)(URLContext *h, int stream_index, |
||||
int64_t timestamp, int flags); |
||||
int (*url_get_file_handle)(URLContext *h); |
||||
int (*url_get_multi_file_handle)(URLContext *h, int **handles, |
||||
int *numhandles); |
||||
int (*url_get_short_seek)(URLContext *h); |
||||
int (*url_shutdown)(URLContext *h, int flags); |
||||
const AVClass *priv_data_class; |
||||
int priv_data_size; |
||||
int flags; |
||||
int (*url_check)(URLContext *h, int mask); |
||||
int (*url_open_dir)(URLContext *h); |
||||
int (*url_read_dir)(URLContext *h, AVIODirEntry **next); |
||||
int (*url_close_dir)(URLContext *h); |
||||
int (*url_delete)(URLContext *h); |
||||
int (*url_move)(URLContext *h_src, URLContext *h_dst); |
||||
const char *default_whitelist; |
||||
} URLProtocol; |
||||
|
||||
/**
|
||||
* Create a URLContext for accessing to the resource indicated by |
||||
* url, but do not initiate the connection yet. |
||||
* |
||||
* @param puc pointer to the location where, in case of success, the |
||||
* function puts the pointer to the created URLContext |
||||
* @param flags flags which control how the resource indicated by url |
||||
* is to be opened |
||||
* @param int_cb interrupt callback to use for the URLContext, may be |
||||
* NULL |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code in case of failure |
||||
*/ |
||||
int ffurl_alloc(URLContext **puc, const char *filename, int flags, |
||||
const AVIOInterruptCB *int_cb); |
||||
|
||||
/**
|
||||
* Connect an URLContext that has been allocated by ffurl_alloc |
||||
* |
||||
* @param options A dictionary filled with options for nested protocols, |
||||
* i.e. it will be passed to url_open2() for protocols implementing it. |
||||
* This parameter will be destroyed and replaced with a dict containing options |
||||
* that were not found. May be NULL. |
||||
*/ |
||||
int ffurl_connect(URLContext *uc, AVDictionary **options); |
||||
|
||||
/**
|
||||
* Create an URLContext for accessing to the resource indicated by |
||||
* url, and open it. |
||||
* |
||||
* @param puc pointer to the location where, in case of success, the |
||||
* function puts the pointer to the created URLContext |
||||
* @param flags flags which control how the resource indicated by url |
||||
* is to be opened |
||||
* @param int_cb interrupt callback to use for the URLContext, may be |
||||
* NULL |
||||
* @param options A dictionary filled with protocol-private options. On return |
||||
* this parameter will be destroyed and replaced with a dict containing options |
||||
* that were not found. May be NULL. |
||||
* @param parent An enclosing URLContext, whose generic options should |
||||
* be applied to this URLContext as well. |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code in case of failure |
||||
*/ |
||||
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, |
||||
const AVIOInterruptCB *int_cb, AVDictionary **options, |
||||
const char *whitelist, const char* blacklist, |
||||
URLContext *parent); |
||||
|
||||
/**
|
||||
* Accept an URLContext c on an URLContext s |
||||
* |
||||
* @param s server context |
||||
* @param c client context, must be unallocated. |
||||
* @return >= 0 on success, ff_neterrno() on failure. |
||||
*/ |
||||
int ffurl_accept(URLContext *s, URLContext **c); |
||||
|
||||
/**
|
||||
* Perform one step of the protocol handshake to accept a new client. |
||||
* See avio_handshake() for details. |
||||
* Implementations should try to return decreasing values. |
||||
* If the protocol uses an underlying protocol, the underlying handshake is |
||||
* usually the first step, and the return value can be: |
||||
* (largest value for this protocol) + (return value from other protocol) |
||||
* |
||||
* @param c the client context |
||||
* @return >= 0 on success or a negative value corresponding |
||||
* to an AVERROR code on failure |
||||
*/ |
||||
int ffurl_handshake(URLContext *c); |
||||
|
||||
/**
|
||||
* Read up to size bytes from the resource accessed by h, and store |
||||
* the read bytes in buf. |
||||
* |
||||
* @return The number of bytes actually read, or a negative value |
||||
* corresponding to an AVERROR code in case of error. A value of zero |
||||
* indicates that it is not possible to read more from the accessed |
||||
* resource (except if the value of the size argument is also zero). |
||||
*/ |
||||
int ffurl_read(URLContext *h, unsigned char *buf, int size); |
||||
|
||||
/**
|
||||
* Read as many bytes as possible (up to size), calling the |
||||
* read function multiple times if necessary. |
||||
* This makes special short-read handling in applications |
||||
* unnecessary, if the return value is < size then it is |
||||
* certain there was either an error or the end of file was reached. |
||||
*/ |
||||
int ffurl_read_complete(URLContext *h, unsigned char *buf, int size); |
||||
|
||||
/**
|
||||
* Write size bytes from buf to the resource accessed by h. |
||||
* |
||||
* @return the number of bytes actually written, or a negative value |
||||
* corresponding to an AVERROR code in case of failure |
||||
*/ |
||||
int ffurl_write(URLContext *h, const unsigned char *buf, int size); |
||||
|
||||
/**
|
||||
* Change the position that will be used by the next read/write |
||||
* operation on the resource accessed by h. |
||||
* |
||||
* @param pos specifies the new position to set |
||||
* @param whence specifies how pos should be interpreted, it must be |
||||
* one of SEEK_SET (seek from the beginning), SEEK_CUR (seek from the |
||||
* current position), SEEK_END (seek from the end), or AVSEEK_SIZE |
||||
* (return the filesize of the requested resource, pos is ignored). |
||||
* @return a negative value corresponding to an AVERROR code in case |
||||
* of failure, or the resulting file position, measured in bytes from |
||||
* the beginning of the file. You can use this feature together with |
||||
* SEEK_CUR to read the current file position. |
||||
*/ |
||||
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence); |
||||
|
||||
/**
|
||||
* Close the resource accessed by the URLContext h, and free the |
||||
* memory used by it. Also set the URLContext pointer to NULL. |
||||
* |
||||
* @return a negative value if an error condition occurred, 0 |
||||
* otherwise |
||||
*/ |
||||
int ffurl_closep(URLContext **h); |
||||
int ffurl_close(URLContext *h); |
||||
|
||||
/**
|
||||
* Return the filesize of the resource accessed by h, AVERROR(ENOSYS) |
||||
* if the operation is not supported by h, or another negative value |
||||
* corresponding to an AVERROR error code in case of failure. |
||||
*/ |
||||
int64_t ffurl_size(URLContext *h); |
||||
|
||||
/**
|
||||
* Return the file descriptor associated with this URL. For RTP, this |
||||
* will return only the RTP file descriptor, not the RTCP file descriptor. |
||||
* |
||||
* @return the file descriptor associated with this URL, or <0 on error. |
||||
*/ |
||||
int ffurl_get_file_handle(URLContext *h); |
||||
|
||||
/**
|
||||
* Return the file descriptors associated with this URL. |
||||
* |
||||
* @return 0 on success or <0 on error. |
||||
*/ |
||||
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles); |
||||
|
||||
/**
|
||||
* Return the current short seek threshold value for this URL. |
||||
* |
||||
* @return threshold (>0) on success or <=0 on error. |
||||
*/ |
||||
int ffurl_get_short_seek(URLContext *h); |
||||
|
||||
/**
|
||||
* Signal the URLContext that we are done reading or writing the stream. |
||||
* |
||||
* @param h pointer to the resource |
||||
* @param flags flags which control how the resource indicated by url |
||||
* is to be shutdown |
||||
* |
||||
* @return a negative value if an error condition occurred, 0 |
||||
* otherwise |
||||
*/ |
||||
int ffurl_shutdown(URLContext *h, int flags); |
||||
|
||||
/**
|
||||
* Check if the user has requested to interrupt a blocking function |
||||
* associated with cb. |
||||
*/ |
||||
int ff_check_interrupt(AVIOInterruptCB *cb); |
||||
|
||||
/* udp.c */ |
||||
int ff_udp_set_remote_url(URLContext *h, const char *uri); |
||||
int ff_udp_get_local_port(URLContext *h); |
||||
|
||||
/**
|
||||
* Assemble a URL string from components. This is the reverse operation |
||||
* of av_url_split. |
||||
* |
||||
* Note, this requires networking to be initialized, so the caller must |
||||
* ensure ff_network_init has been called. |
||||
* |
||||
* @see av_url_split |
||||
* |
||||
* @param str the buffer to fill with the url |
||||
* @param size the size of the str buffer |
||||
* @param proto the protocol identifier, if null, the separator |
||||
* after the identifier is left out, too |
||||
* @param authorization an optional authorization string, may be null. |
||||
* An empty string is treated the same as a null string. |
||||
* @param hostname the host name string |
||||
* @param port the port number, left out from the string if negative |
||||
* @param fmt a generic format string for everything to add after the |
||||
* host/port, may be null |
||||
* @return the number of characters written to the destination buffer |
||||
*/ |
||||
int ff_url_join(char *str, int size, const char *proto, |
||||
const char *authorization, const char *hostname, |
||||
int port, const char *fmt, ...) av_printf_format(7, 8); |
||||
|
||||
/**
|
||||
* Convert a relative url into an absolute url, given a base url. |
||||
* |
||||
* @param buf the buffer where output absolute url is written |
||||
* @param size the size of buf |
||||
* @param base the base url, may be equal to buf. |
||||
* @param rel the new url, which is interpreted relative to base |
||||
* @param handle_dos_paths handle DOS paths for file or unspecified protocol |
||||
*/ |
||||
int ff_make_absolute_url2(char *buf, int size, const char *base, |
||||
const char *rel, int handle_dos_paths); |
||||
|
||||
/**
|
||||
* Convert a relative url into an absolute url, given a base url. |
||||
* |
||||
* Same as ff_make_absolute_url2 with handle_dos_paths being equal to |
||||
* HAVE_DOS_PATHS config variable. |
||||
*/ |
||||
int ff_make_absolute_url(char *buf, int size, const char *base, |
||||
const char *rel); |
||||
|
||||
/**
|
||||
* Allocate directory entry with default values. |
||||
* |
||||
* @return entry or NULL on error |
||||
*/ |
||||
AVIODirEntry *ff_alloc_dir_entry(void); |
||||
|
||||
const AVClass *ff_urlcontext_child_class_iterate(void **iter); |
||||
|
||||
/**
|
||||
* Construct a list of protocols matching a given whitelist and/or blacklist. |
||||
* |
||||
* @param whitelist a comma-separated list of allowed protocol names or NULL. If |
||||
* this is a non-empty string, only protocols in this list will |
||||
* be included. |
||||
* @param blacklist a comma-separated list of forbidden protocol names or NULL. |
||||
* If this is a non-empty string, all protocols in this list |
||||
* will be excluded. |
||||
* |
||||
* @return a NULL-terminated array of matching protocols. The array must be |
||||
* freed by the caller. |
||||
*/ |
||||
const URLProtocol **ffurl_get_protocols(const char *whitelist, |
||||
const char *blacklist); |
||||
|
||||
typedef struct URLComponents { |
||||
const char *url; /**< whole URL, for reference */ |
||||
const char *scheme; /**< possibly including lavf-specific options */ |
||||
const char *authority; /**< "//" if it is a real URL */ |
||||
const char *userinfo; /**< including final '@' if present */ |
||||
const char *host; |
||||
const char *port; /**< including initial ':' if present */ |
||||
const char *path; |
||||
const char *query; /**< including initial '?' if present */ |
||||
const char *fragment; /**< including initial '#' if present */ |
||||
const char *end; |
||||
} URLComponents; |
||||
|
||||
#define url_component_end_scheme authority |
||||
#define url_component_end_authority userinfo |
||||
#define url_component_end_userinfo host |
||||
#define url_component_end_host port |
||||
#define url_component_end_port path |
||||
#define url_component_end_path query |
||||
#define url_component_end_query fragment |
||||
#define url_component_end_fragment end |
||||
#define url_component_end_authority_full path |
||||
|
||||
#define URL_COMPONENT_HAVE(uc, component) \ |
||||
((uc).url_component_end_##component > (uc).component) |
||||
|
||||
/**
|
||||
* Parse an URL to find the components. |
||||
* |
||||
* Each component runs until the start of the next component, |
||||
* possibly including a mandatory delimiter. |
||||
* |
||||
* @param uc structure to fill with pointers to the components. |
||||
* @param url URL to parse. |
||||
* @param end end of the URL, or NULL to parse to the end of string. |
||||
* |
||||
* @return >= 0 for success or an AVERROR code, especially if the URL is |
||||
* malformed. |
||||
*/ |
||||
int ff_url_decompose(URLComponents *uc, const char *url, const char *end); |
||||
|
||||
/**
|
||||
* 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 ffurl_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 ffurl_delete(const char *url); |
||||
|
||||
#endif /* AVFORMAT_URL_H */ |
||||
@ -0,0 +1,47 @@ |
||||
/*
|
||||
* 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_H |
||||
#define AVFORMAT_VERSION_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup libavf |
||||
* Libavformat version macros |
||||
*/ |
||||
|
||||
#include "libavutil/version.h" |
||||
|
||||
#include "version_major.h" |
||||
|
||||
#define LIBAVFORMAT_VERSION_MINOR 3 |
||||
#define LIBAVFORMAT_VERSION_MICRO 100 |
||||
|
||||
#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ |
||||
LIBAVFORMAT_VERSION_MINOR, \
|
||||
LIBAVFORMAT_VERSION_MICRO) |
||||
#define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \ |
||||
LIBAVFORMAT_VERSION_MINOR, \
|
||||
LIBAVFORMAT_VERSION_MICRO) |
||||
#define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT |
||||
|
||||
#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION) |
||||
|
||||
#endif /* AVFORMAT_VERSION_H */ |
||||
@ -0,0 +1,52 @@ |
||||
/*
|
||||
* Version macros. |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVFORMAT_VERSION_MAJOR_H |
||||
#define AVFORMAT_VERSION_MAJOR_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup libavf |
||||
* Libavformat version macros |
||||
*/ |
||||
|
||||
// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
|
||||
// Also please add any ticket numbers that you believe might be affected here
|
||||
#define LIBAVFORMAT_VERSION_MAJOR 60 |
||||
|
||||
/**
|
||||
* FF_API_* defines may be placed below to indicate public API that will be |
||||
* dropped at a future version bump. The defines themselves are not part of |
||||
* the public API and may change, break or disappear at any time. |
||||
* |
||||
* @note, when bumping the major version it is recommended to manually |
||||
* disable each FF_API_* in its own commit instead of disabling them all |
||||
* at once through the bump. This improves the git bisect-ability of the change. |
||||
* |
||||
*/ |
||||
#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 61) |
||||
#define FF_API_GET_END_PTS (LIBAVFORMAT_VERSION_MAJOR < 61) |
||||
#define FF_API_AVIODIRCONTEXT (LIBAVFORMAT_VERSION_MAJOR < 61) |
||||
#define FF_API_AVFORMAT_IO_CLOSE (LIBAVFORMAT_VERSION_MAJOR < 61) |
||||
|
||||
|
||||
#define FF_API_R_FRAME_RATE 1 |
||||
|
||||
#endif /* AVFORMAT_VERSION_MAJOR_H */ |
||||
@ -0,0 +1,32 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>CFBundleDevelopmentRegion</key> |
||||
<string>en</string> |
||||
<key>CFBundleExecutable</key> |
||||
<string>libavformat</string> |
||||
<key>CFBundleIdentifier</key> |
||||
<string>com.arthenica.ffmpegkit.Libavformat</string> |
||||
<key>CFBundleInfoDictionaryVersion</key> |
||||
<string>6.0</string> |
||||
<key>CFBundleName</key> |
||||
<string>libavformat</string> |
||||
<key>CFBundlePackageType</key> |
||||
<string>FMWK</string> |
||||
<key>CFBundleShortVersionString</key> |
||||
<string>60.3.100</string> |
||||
<key>CFBundleVersion</key> |
||||
<string>60.3.100</string> |
||||
<key>CFBundleSignature</key> |
||||
<string>????</string> |
||||
<key>MinimumOSVersion</key> |
||||
<string>12.1</string> |
||||
<key>CFBundleSupportedPlatforms</key> |
||||
<array> |
||||
<string>iPhoneOS</string> |
||||
</array> |
||||
<key>NSPrincipalClass</key> |
||||
<string></string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,165 @@ |
||||
GNU LESSER GENERAL PUBLIC LICENSE |
||||
Version 3, 29 June 2007 |
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
|
||||
This version of the GNU Lesser General Public License incorporates |
||||
the terms and conditions of version 3 of the GNU General Public |
||||
License, supplemented by the additional permissions listed below. |
||||
|
||||
0. Additional Definitions. |
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser |
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU |
||||
General Public License. |
||||
|
||||
"The Library" refers to a covered work governed by this License, |
||||
other than an Application or a Combined Work as defined below. |
||||
|
||||
An "Application" is any work that makes use of an interface provided |
||||
by the Library, but which is not otherwise based on the Library. |
||||
Defining a subclass of a class defined by the Library is deemed a mode |
||||
of using an interface provided by the Library. |
||||
|
||||
A "Combined Work" is a work produced by combining or linking an |
||||
Application with the Library. The particular version of the Library |
||||
with which the Combined Work was made is also called the "Linked |
||||
Version". |
||||
|
||||
The "Minimal Corresponding Source" for a Combined Work means the |
||||
Corresponding Source for the Combined Work, excluding any source code |
||||
for portions of the Combined Work that, considered in isolation, are |
||||
based on the Application, and not on the Linked Version. |
||||
|
||||
The "Corresponding Application Code" for a Combined Work means the |
||||
object code and/or source code for the Application, including any data |
||||
and utility programs needed for reproducing the Combined Work from the |
||||
Application, but excluding the System Libraries of the Combined Work. |
||||
|
||||
1. Exception to Section 3 of the GNU GPL. |
||||
|
||||
You may convey a covered work under sections 3 and 4 of this License |
||||
without being bound by section 3 of the GNU GPL. |
||||
|
||||
2. Conveying Modified Versions. |
||||
|
||||
If you modify a copy of the Library, and, in your modifications, a |
||||
facility refers to a function or data to be supplied by an Application |
||||
that uses the facility (other than as an argument passed when the |
||||
facility is invoked), then you may convey a copy of the modified |
||||
version: |
||||
|
||||
a) under this License, provided that you make a good faith effort to |
||||
ensure that, in the event an Application does not supply the |
||||
function or data, the facility still operates, and performs |
||||
whatever part of its purpose remains meaningful, or |
||||
|
||||
b) under the GNU GPL, with none of the additional permissions of |
||||
this License applicable to that copy. |
||||
|
||||
3. Object Code Incorporating Material from Library Header Files. |
||||
|
||||
The object code form of an Application may incorporate material from |
||||
a header file that is part of the Library. You may convey such object |
||||
code under terms of your choice, provided that, if the incorporated |
||||
material is not limited to numerical parameters, data structure |
||||
layouts and accessors, or small macros, inline functions and templates |
||||
(ten or fewer lines in length), you do both of the following: |
||||
|
||||
a) Give prominent notice with each copy of the object code that the |
||||
Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
4. Combined Works. |
||||
|
||||
You may convey a Combined Work under terms of your choice that, |
||||
taken together, effectively do not restrict modification of the |
||||
portions of the Library contained in the Combined Work and reverse |
||||
engineering for debugging such modifications, if you also do each of |
||||
the following: |
||||
|
||||
a) Give prominent notice with each copy of the Combined Work that |
||||
the Library is used in it and that the Library and its use are |
||||
covered by this License. |
||||
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license |
||||
document. |
||||
|
||||
c) For a Combined Work that displays copyright notices during |
||||
execution, include the copyright notice for the Library among |
||||
these notices, as well as a reference directing the user to the |
||||
copies of the GNU GPL and this license document. |
||||
|
||||
d) Do one of the following: |
||||
|
||||
0) Convey the Minimal Corresponding Source under the terms of this |
||||
License, and the Corresponding Application Code in a form |
||||
suitable for, and under terms that permit, the user to |
||||
recombine or relink the Application with a modified version of |
||||
the Linked Version to produce a modified Combined Work, in the |
||||
manner specified by section 6 of the GNU GPL for conveying |
||||
Corresponding Source. |
||||
|
||||
1) Use a suitable shared library mechanism for linking with the |
||||
Library. A suitable mechanism is one that (a) uses at run time |
||||
a copy of the Library already present on the user's computer |
||||
system, and (b) will operate properly with a modified version |
||||
of the Library that is interface-compatible with the Linked |
||||
Version. |
||||
|
||||
e) Provide Installation Information, but only if you would otherwise |
||||
be required to provide such information under section 6 of the |
||||
GNU GPL, and only to the extent that such information is |
||||
necessary to install and execute a modified version of the |
||||
Combined Work produced by recombining or relinking the |
||||
Application with a modified version of the Linked Version. (If |
||||
you use option 4d0, the Installation Information must accompany |
||||
the Minimal Corresponding Source and Corresponding Application |
||||
Code. If you use option 4d1, you must provide the Installation |
||||
Information in the manner specified by section 6 of the GNU GPL |
||||
for conveying Corresponding Source.) |
||||
|
||||
5. Combined Libraries. |
||||
|
||||
You may place library facilities that are a work based on the |
||||
Library side by side in a single library together with other library |
||||
facilities that are not Applications and are not covered by this |
||||
License, and convey such a combined library under terms of your |
||||
choice, if you do both of the following: |
||||
|
||||
a) Accompany the combined library with a copy of the same work based |
||||
on the Library, uncombined with any other library facilities, |
||||
conveyed under the terms of this License. |
||||
|
||||
b) Give prominent notice with the combined library that part of it |
||||
is a work based on the Library, and explaining where to find the |
||||
accompanying uncombined form of the same work. |
||||
|
||||
6. Revised Versions of the GNU Lesser General Public License. |
||||
|
||||
The Free Software Foundation may publish revised and/or new versions |
||||
of the GNU Lesser General Public License from time to time. Such new |
||||
versions will be similar in spirit to the present version, but may |
||||
differ in detail to address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the |
||||
Library as you received it specifies that a certain numbered version |
||||
of the GNU Lesser General Public License "or any later version" |
||||
applies to it, you have the option of following the terms and |
||||
conditions either of that published version or of any later version |
||||
published by the Free Software Foundation. If the Library as you |
||||
received it does not specify a version number of the GNU Lesser |
||||
General Public License, you may choose any version of the GNU Lesser |
||||
General Public License ever published by the Free Software Foundation. |
||||
|
||||
If the Library as you received it specifies that a proxy can decide |
||||
whether future versions of the GNU Lesser General Public License shall |
||||
apply, that proxy's public statement of acceptance of any version is |
||||
permanent authorization for you to choose that version for the |
||||
Library. |
||||
Binary file not shown.
@ -0,0 +1,27 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
||||
<plist version="1.0"> |
||||
<dict> |
||||
<key>AvailableLibraries</key> |
||||
<array> |
||||
<dict> |
||||
<key>BinaryPath</key> |
||||
<string>libavutil.framework/libavutil</string> |
||||
<key>LibraryIdentifier</key> |
||||
<string>ios-arm64</string> |
||||
<key>LibraryPath</key> |
||||
<string>libavutil.framework</string> |
||||
<key>SupportedArchitectures</key> |
||||
<array> |
||||
<string>arm64</string> |
||||
</array> |
||||
<key>SupportedPlatform</key> |
||||
<string>ios</string> |
||||
</dict> |
||||
</array> |
||||
<key>CFBundlePackageType</key> |
||||
<string>XFWK</string> |
||||
<key>XCFrameworkFormatVersion</key> |
||||
<string>1.0</string> |
||||
</dict> |
||||
</plist> |
||||
@ -0,0 +1,50 @@ |
||||
/*
|
||||
* Copyright (c) 2015 Janne Grunau <janne-libav@jannau.net> |
||||
* |
||||
* 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_AARCH64_TIMER_H |
||||
#define AVUTIL_AARCH64_TIMER_H |
||||
|
||||
#include <stdint.h> |
||||
#include "config.h" |
||||
|
||||
#if defined(__APPLE__) |
||||
|
||||
#include <mach/mach_time.h> |
||||
|
||||
#define AV_READ_TIME mach_absolute_time |
||||
|
||||
#elif HAVE_INLINE_ASM |
||||
|
||||
#define AV_READ_TIME read_time |
||||
|
||||
static inline uint64_t read_time(void) |
||||
{ |
||||
uint64_t cycle_counter; |
||||
__asm__ volatile( |
||||
"isb \t\n" |
||||
"mrs %0, pmccntr_el0 " |
||||
: "=r"(cycle_counter) :: "memory" ); |
||||
|
||||
return cycle_counter; |
||||
} |
||||
|
||||
#endif /* HAVE_INLINE_ASM */ |
||||
|
||||
#endif /* AVUTIL_AARCH64_TIMER_H */ |
||||
@ -0,0 +1,63 @@ |
||||
/*
|
||||
* copyright (c) 2006 Mans Rullgard |
||||
* |
||||
* 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 |
||||
* @ingroup lavu_adler32 |
||||
* Public header for Adler-32 hash function implementation. |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_ADLER32_H |
||||
#define AVUTIL_ADLER32_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
#include "attributes.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_adler32 Adler-32 |
||||
* @ingroup lavu_hash |
||||
* Adler-32 hash function implementation. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
typedef uint32_t AVAdler; |
||||
|
||||
/**
|
||||
* Calculate the Adler32 checksum of a buffer. |
||||
* |
||||
* Passing the return value to a subsequent av_adler32_update() call |
||||
* allows the checksum of multiple buffers to be calculated as though |
||||
* they were concatenated. |
||||
* |
||||
* @param adler initial checksum value |
||||
* @param buf pointer to input buffer |
||||
* @param len size of input buffer |
||||
* @return updated checksum |
||||
*/ |
||||
AVAdler av_adler32_update(AVAdler adler, const uint8_t *buf, |
||||
size_t len) av_pure; |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_ADLER32_H */ |
||||
@ -0,0 +1,69 @@ |
||||
/*
|
||||
* copyright (c) 2007 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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_AES_H |
||||
#define AVUTIL_AES_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "attributes.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_aes AES |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
extern const int av_aes_size; |
||||
|
||||
struct AVAES; |
||||
|
||||
/**
|
||||
* Allocate an AVAES context. |
||||
*/ |
||||
struct AVAES *av_aes_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize an AVAES context. |
||||
* |
||||
* @param a The AVAES context |
||||
* @param key Pointer to the key |
||||
* @param key_bits 128, 192 or 256 |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt); |
||||
|
||||
/**
|
||||
* Encrypt or decrypt a buffer using a previously initialized context. |
||||
* |
||||
* @param a The AVAES context |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @param count number of 16 byte blocks |
||||
* @param iv initialization vector for CBC mode, if NULL then ECB will be used |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_AES_H */ |
||||
@ -0,0 +1,99 @@ |
||||
/*
|
||||
* AES-CTR cipher |
||||
* Copyright (c) 2015 Eran Kornblau <erankor at gmail dot 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_AES_CTR_H |
||||
#define AVUTIL_AES_CTR_H |
||||
|
||||
/**
|
||||
* @defgroup lavu_aes_ctr AES-CTR |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "attributes.h" |
||||
|
||||
#define AES_CTR_KEY_SIZE (16) |
||||
#define AES_CTR_IV_SIZE (8) |
||||
|
||||
struct AVAESCTR; |
||||
|
||||
/**
|
||||
* Allocate an AVAESCTR context. |
||||
*/ |
||||
struct AVAESCTR *av_aes_ctr_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize an AVAESCTR context. |
||||
* |
||||
* @param a The AVAESCTR context to initialize |
||||
* @param key encryption key, must have a length of AES_CTR_KEY_SIZE |
||||
*/ |
||||
int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key); |
||||
|
||||
/**
|
||||
* Release an AVAESCTR context. |
||||
* |
||||
* @param a The AVAESCTR context |
||||
*/ |
||||
void av_aes_ctr_free(struct AVAESCTR *a); |
||||
|
||||
/**
|
||||
* Process a buffer using a previously initialized context. |
||||
* |
||||
* @param a The AVAESCTR context |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @param size the size of src and dst |
||||
*/ |
||||
void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int size); |
||||
|
||||
/**
|
||||
* Get the current iv |
||||
*/ |
||||
const uint8_t* av_aes_ctr_get_iv(struct AVAESCTR *a); |
||||
|
||||
/**
|
||||
* Generate a random iv |
||||
*/ |
||||
void av_aes_ctr_set_random_iv(struct AVAESCTR *a); |
||||
|
||||
/**
|
||||
* Forcefully change the 8-byte iv |
||||
*/ |
||||
void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t* iv); |
||||
|
||||
/**
|
||||
* Forcefully change the "full" 16-byte iv, including the counter |
||||
*/ |
||||
void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t* iv); |
||||
|
||||
/**
|
||||
* Increment the top 64 bit of the iv (performed after each frame) |
||||
*/ |
||||
void av_aes_ctr_increment_iv(struct AVAESCTR *a); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_AES_CTR_H */ |
||||
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* Copyright (c) 2023 Jan Ekström <jeebjp@gmail.com> |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H |
||||
#define AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H |
||||
|
||||
#include <stddef.h> |
||||
#include "frame.h" |
||||
#include "rational.h" |
||||
|
||||
/**
|
||||
* Ambient viewing environment metadata as defined by H.274. The values are |
||||
* saved in AVRationals so that they keep their exactness, while allowing for |
||||
* easy access to a double value with f.ex. av_q2d. |
||||
* |
||||
* @note sizeof(AVAmbientViewingEnvironment) is not part of the public ABI, and |
||||
* it must be allocated using av_ambient_viewing_environment_alloc. |
||||
*/ |
||||
typedef struct AVAmbientViewingEnvironment { |
||||
/**
|
||||
* Environmental illuminance of the ambient viewing environment in lux. |
||||
*/ |
||||
AVRational ambient_illuminance; |
||||
|
||||
/**
|
||||
* Normalized x chromaticity coordinate of the environmental ambient light |
||||
* in the nominal viewing environment according to the CIE 1931 definition |
||||
* of x and y as specified in ISO/CIE 11664-1. |
||||
*/ |
||||
AVRational ambient_light_x; |
||||
|
||||
/**
|
||||
* Normalized y chromaticity coordinate of the environmental ambient light |
||||
* in the nominal viewing environment according to the CIE 1931 definition |
||||
* of x and y as specified in ISO/CIE 11664-1. |
||||
*/ |
||||
AVRational ambient_light_y; |
||||
} AVAmbientViewingEnvironment; |
||||
|
||||
/**
|
||||
* Allocate an AVAmbientViewingEnvironment structure. |
||||
* |
||||
* @return the newly allocated struct or NULL on failure |
||||
*/ |
||||
AVAmbientViewingEnvironment *av_ambient_viewing_environment_alloc(size_t *size); |
||||
|
||||
/**
|
||||
* Allocate and add an AVAmbientViewingEnvironment structure to an existing |
||||
* AVFrame as side data. |
||||
* |
||||
* @return the newly allocated struct, or NULL on failure |
||||
*/ |
||||
AVAmbientViewingEnvironment *av_ambient_viewing_environment_create_side_data(AVFrame *frame); |
||||
|
||||
#endif /* AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H */ |
||||
@ -0,0 +1,46 @@ |
||||
/*
|
||||
* Copyright (c) 2009 Mans Rullgard <mans@mansr.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_ARM_TIMER_H |
||||
#define AVUTIL_ARM_TIMER_H |
||||
|
||||
#include <stdint.h> |
||||
#include "config.h" |
||||
|
||||
#if defined(__APPLE__) |
||||
|
||||
#include <mach/mach_time.h> |
||||
|
||||
#define AV_READ_TIME mach_absolute_time |
||||
|
||||
#elif HAVE_INLINE_ASM && defined(__ARM_ARCH_7A__) |
||||
|
||||
#define AV_READ_TIME read_time |
||||
|
||||
static inline uint64_t read_time(void) |
||||
{ |
||||
unsigned cc; |
||||
__asm__ volatile ("mrc p15, 0, %0, c9, c13, 0" : "=r"(cc)); |
||||
return cc; |
||||
} |
||||
|
||||
#endif /* HAVE_INLINE_ASM && __ARM_ARCH_7A__ */ |
||||
|
||||
#endif /* AVUTIL_ARM_TIMER_H */ |
||||
@ -0,0 +1,173 @@ |
||||
/*
|
||||
* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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 |
||||
* Macro definitions for various function/variable attributes |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_ATTRIBUTES_H |
||||
#define AVUTIL_ATTRIBUTES_H |
||||
|
||||
#ifdef __GNUC__ |
||||
# define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y)) |
||||
# define AV_GCC_VERSION_AT_MOST(x,y) (__GNUC__ < (x) || __GNUC__ == (x) && __GNUC_MINOR__ <= (y)) |
||||
#else |
||||
# define AV_GCC_VERSION_AT_LEAST(x,y) 0 |
||||
# 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 |
||||
#elif defined(_MSC_VER) |
||||
# define av_always_inline __forceinline |
||||
#else |
||||
# define av_always_inline inline |
||||
#endif |
||||
#endif |
||||
|
||||
#ifndef av_extern_inline |
||||
#if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__) |
||||
# define av_extern_inline extern inline |
||||
#else |
||||
# define av_extern_inline inline |
||||
#endif |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,4) |
||||
# define av_warn_unused_result __attribute__((warn_unused_result)) |
||||
#else |
||||
# define av_warn_unused_result |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,1) |
||||
# define av_noinline __attribute__((noinline)) |
||||
#elif defined(_MSC_VER) |
||||
# define av_noinline __declspec(noinline) |
||||
#else |
||||
# define av_noinline |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) |
||||
# define av_pure __attribute__((pure)) |
||||
#else |
||||
# define av_pure |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(2,6) || defined(__clang__) |
||||
# define av_const __attribute__((const)) |
||||
#else |
||||
# define av_const |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(4,3) || defined(__clang__) |
||||
# define av_cold __attribute__((cold)) |
||||
#else |
||||
# define av_cold |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(4,1) && !defined(__llvm__) |
||||
# define av_flatten __attribute__((flatten)) |
||||
#else |
||||
# define av_flatten |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,1) |
||||
# define attribute_deprecated __attribute__((deprecated)) |
||||
#elif defined(_MSC_VER) |
||||
# define attribute_deprecated __declspec(deprecated) |
||||
#else |
||||
# define attribute_deprecated |
||||
#endif |
||||
|
||||
/**
|
||||
* Disable warnings about deprecated features |
||||
* This is useful for sections of code kept for backward compatibility and |
||||
* scheduled for removal. |
||||
*/ |
||||
#ifndef AV_NOWARN_DEPRECATED |
||||
#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\"") \
|
||||
code \
|
||||
_Pragma("GCC diagnostic pop") |
||||
#elif defined(_MSC_VER) |
||||
# define AV_NOWARN_DEPRECATED(code) \ |
||||
__pragma(warning(push)) \
|
||||
__pragma(warning(disable : 4996)) \
|
||||
code; \
|
||||
__pragma(warning(pop)) |
||||
#else |
||||
# define AV_NOWARN_DEPRECATED(code) code |
||||
#endif |
||||
#endif |
||||
|
||||
#if defined(__GNUC__) || defined(__clang__) |
||||
# define av_unused __attribute__((unused)) |
||||
#else |
||||
# define av_unused |
||||
#endif |
||||
|
||||
/**
|
||||
* Mark a variable as used and prevent the compiler from optimizing it |
||||
* away. This is useful for variables accessed only from inline |
||||
* assembler without the compiler being aware. |
||||
*/ |
||||
#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__) |
||||
# define av_used __attribute__((used)) |
||||
#else |
||||
# define av_used |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,3) || defined(__clang__) |
||||
# define av_alias __attribute__((may_alias)) |
||||
#else |
||||
# define av_alias |
||||
#endif |
||||
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && !defined(__INTEL_COMPILER) |
||||
# define av_uninit(x) x=x |
||||
#else |
||||
# define av_uninit(x) x |
||||
#endif |
||||
|
||||
#if defined(__GNUC__) || defined(__clang__) |
||||
# define av_builtin_constant_p __builtin_constant_p |
||||
# define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos))) |
||||
#else |
||||
# define av_builtin_constant_p(x) 0 |
||||
# define av_printf_format(fmtpos, attrpos) |
||||
#endif |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(2,5) || defined(__clang__) |
||||
# define av_noreturn __attribute__((noreturn)) |
||||
#else |
||||
# define av_noreturn |
||||
#endif |
||||
|
||||
#endif /* AVUTIL_ATTRIBUTES_H */ |
||||
@ -0,0 +1,34 @@ |
||||
/*
|
||||
* 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_ATTRIBUTES_INTERNAL_H |
||||
#define AVUTIL_ATTRIBUTES_INTERNAL_H |
||||
|
||||
#include "attributes.h" |
||||
|
||||
#if (AV_GCC_VERSION_AT_LEAST(4,0) || defined(__clang__)) && (defined(__ELF__) || defined(__MACH__)) |
||||
# define attribute_visibility_hidden __attribute__((visibility("hidden"))) |
||||
# define FF_VISIBILITY_PUSH_HIDDEN _Pragma("GCC visibility push(hidden)") |
||||
# define FF_VISIBILITY_POP_HIDDEN _Pragma("GCC visibility pop") |
||||
#else |
||||
# define attribute_visibility_hidden |
||||
# define FF_VISIBILITY_PUSH_HIDDEN |
||||
# define FF_VISIBILITY_POP_HIDDEN |
||||
#endif |
||||
|
||||
#endif /* AVUTIL_ATTRIBUTES_INTERNAL_H */ |
||||
@ -0,0 +1,186 @@ |
||||
/*
|
||||
* Audio FIFO |
||||
* Copyright (c) 2012 Justin Ruggles <justin.ruggles@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 |
||||
*/ |
||||
|
||||
/**
|
||||
* @file |
||||
* Audio FIFO Buffer |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_AUDIO_FIFO_H |
||||
#define AVUTIL_AUDIO_FIFO_H |
||||
|
||||
#include "attributes.h" |
||||
#include "samplefmt.h" |
||||
|
||||
/**
|
||||
* @addtogroup lavu_audio |
||||
* @{ |
||||
* |
||||
* @defgroup lavu_audiofifo Audio FIFO Buffer |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Context for an Audio FIFO Buffer. |
||||
* |
||||
* - Operates at the sample level rather than the byte level. |
||||
* - Supports multiple channels with either planar or packed sample format. |
||||
* - Automatic reallocation when writing to a full buffer. |
||||
*/ |
||||
typedef struct AVAudioFifo AVAudioFifo; |
||||
|
||||
/**
|
||||
* Free an AVAudioFifo. |
||||
* |
||||
* @param af AVAudioFifo to free |
||||
*/ |
||||
void av_audio_fifo_free(AVAudioFifo *af); |
||||
|
||||
/**
|
||||
* Allocate an AVAudioFifo. |
||||
* |
||||
* @param sample_fmt sample format |
||||
* @param channels number of channels |
||||
* @param nb_samples initial allocation size, in samples |
||||
* @return newly allocated AVAudioFifo, or NULL on error |
||||
*/ |
||||
AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, |
||||
int nb_samples); |
||||
|
||||
/**
|
||||
* Reallocate an AVAudioFifo. |
||||
* |
||||
* @param af AVAudioFifo to reallocate |
||||
* @param nb_samples new allocation size, in samples |
||||
* @return 0 if OK, or negative AVERROR code on failure |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples); |
||||
|
||||
/**
|
||||
* Write data to an AVAudioFifo. |
||||
* |
||||
* The AVAudioFifo will be reallocated automatically if the available space |
||||
* is less than nb_samples. |
||||
* |
||||
* @see enum AVSampleFormat |
||||
* The documentation for AVSampleFormat describes the data layout. |
||||
* |
||||
* @param af AVAudioFifo to write to |
||||
* @param data audio data plane pointers |
||||
* @param nb_samples number of samples to write |
||||
* @return number of samples actually written, or negative AVERROR |
||||
* code on failure. If successful, the number of samples |
||||
* actually written will always be nb_samples. |
||||
*/ |
||||
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples); |
||||
|
||||
/**
|
||||
* Peek data from an AVAudioFifo. |
||||
* |
||||
* @see enum AVSampleFormat |
||||
* The documentation for AVSampleFormat describes the data layout. |
||||
* |
||||
* @param af AVAudioFifo to read from |
||||
* @param data audio data plane pointers |
||||
* @param nb_samples number of samples to peek |
||||
* @return number of samples actually peek, or negative AVERROR code |
||||
* on failure. The number of samples actually peek will not |
||||
* be greater than nb_samples, and will only be less than |
||||
* nb_samples if av_audio_fifo_size is less than nb_samples. |
||||
*/ |
||||
int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples); |
||||
|
||||
/**
|
||||
* Peek data from an AVAudioFifo. |
||||
* |
||||
* @see enum AVSampleFormat |
||||
* The documentation for AVSampleFormat describes the data layout. |
||||
* |
||||
* @param af AVAudioFifo to read from |
||||
* @param data audio data plane pointers |
||||
* @param nb_samples number of samples to peek |
||||
* @param offset offset from current read position |
||||
* @return number of samples actually peek, or negative AVERROR code |
||||
* on failure. The number of samples actually peek will not |
||||
* be greater than nb_samples, and will only be less than |
||||
* nb_samples if av_audio_fifo_size is less than nb_samples. |
||||
*/ |
||||
int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offset); |
||||
|
||||
/**
|
||||
* Read data from an AVAudioFifo. |
||||
* |
||||
* @see enum AVSampleFormat |
||||
* The documentation for AVSampleFormat describes the data layout. |
||||
* |
||||
* @param af AVAudioFifo to read from |
||||
* @param data audio data plane pointers |
||||
* @param nb_samples number of samples to read |
||||
* @return number of samples actually read, or negative AVERROR code |
||||
* on failure. The number of samples actually read will not |
||||
* be greater than nb_samples, and will only be less than |
||||
* nb_samples if av_audio_fifo_size is less than nb_samples. |
||||
*/ |
||||
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples); |
||||
|
||||
/**
|
||||
* Drain data from an AVAudioFifo. |
||||
* |
||||
* Removes the data without reading it. |
||||
* |
||||
* @param af AVAudioFifo to drain |
||||
* @param nb_samples number of samples to drain |
||||
* @return 0 if OK, or negative AVERROR code on failure |
||||
*/ |
||||
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples); |
||||
|
||||
/**
|
||||
* Reset the AVAudioFifo buffer. |
||||
* |
||||
* This empties all data in the buffer. |
||||
* |
||||
* @param af AVAudioFifo to reset |
||||
*/ |
||||
void av_audio_fifo_reset(AVAudioFifo *af); |
||||
|
||||
/**
|
||||
* Get the current number of samples in the AVAudioFifo available for reading. |
||||
* |
||||
* @param af the AVAudioFifo to query |
||||
* @return number of samples available for reading |
||||
*/ |
||||
int av_audio_fifo_size(AVAudioFifo *af); |
||||
|
||||
/**
|
||||
* Get the current number of samples in the AVAudioFifo available for writing. |
||||
* |
||||
* @param af the AVAudioFifo to query |
||||
* @return number of samples available for writing |
||||
*/ |
||||
int av_audio_fifo_space(AVAudioFifo *af); |
||||
|
||||
/**
|
||||
* @} |
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_AUDIO_FIFO_H */ |
||||
@ -0,0 +1,75 @@ |
||||
/*
|
||||
* copyright (c) 2010 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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 |
||||
* simple assert() macros that are a bit more flexible than ISO C assert(). |
||||
* @author Michael Niedermayer <michaelni@gmx.at> |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_AVASSERT_H |
||||
#define AVUTIL_AVASSERT_H |
||||
|
||||
#include <stdlib.h> |
||||
#include "log.h" |
||||
#include "macros.h" |
||||
|
||||
/**
|
||||
* assert() equivalent, that is always enabled. |
||||
*/ |
||||
#define av_assert0(cond) do { \ |
||||
if (!(cond)) { \
|
||||
av_log(NULL, AV_LOG_PANIC, "Assertion %s failed at %s:%d\n", \
|
||||
AV_STRINGIFY(cond), __FILE__, __LINE__); \
|
||||
abort(); \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
|
||||
/**
|
||||
* assert() equivalent, that does not lie in speed critical code. |
||||
* These asserts() thus can be enabled without fearing speed loss. |
||||
*/ |
||||
#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 0 |
||||
#define av_assert1(cond) av_assert0(cond) |
||||
#else |
||||
#define av_assert1(cond) ((void)0) |
||||
#endif |
||||
|
||||
|
||||
/**
|
||||
* assert() equivalent, that does lie in speed critical code. |
||||
*/ |
||||
#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1 |
||||
#define av_assert2(cond) av_assert0(cond) |
||||
#define av_assert2_fpu() av_assert0_fpu() |
||||
#else |
||||
#define av_assert2(cond) ((void)0) |
||||
#define av_assert2_fpu() ((void)0) |
||||
#endif |
||||
|
||||
/**
|
||||
* Assert that floating point operations can be executed. |
||||
* |
||||
* This will av_assert0() that the cpu is not in MMX state on X86 |
||||
*/ |
||||
void av_assert0_fpu(void); |
||||
|
||||
#endif /* AVUTIL_AVASSERT_H */ |
||||
@ -0,0 +1,6 @@ |
||||
/* Generated by ffmpeg configure */ |
||||
#ifndef AVUTIL_AVCONFIG_H |
||||
#define AVUTIL_AVCONFIG_H |
||||
#define AV_HAVE_BIGENDIAN 0 |
||||
#define AV_HAVE_FAST_UNALIGNED 1 |
||||
#endif /* AVUTIL_AVCONFIG_H */ |
||||
@ -0,0 +1,429 @@ |
||||
/*
|
||||
* Copyright (c) 2007 Mans Rullgard |
||||
* |
||||
* 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_AVSTRING_H |
||||
#define AVUTIL_AVSTRING_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
#include "attributes.h" |
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @addtogroup lavu_string |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Return non-zero if pfx is a prefix of str. If it is, *ptr is set to |
||||
* the address of the first character in str after the prefix. |
||||
* |
||||
* @param str input string |
||||
* @param pfx prefix to test |
||||
* @param ptr updated if the prefix is matched inside str |
||||
* @return non-zero if the prefix matches, zero otherwise |
||||
*/ |
||||
int av_strstart(const char *str, const char *pfx, const char **ptr); |
||||
|
||||
/**
|
||||
* Return non-zero if pfx is a prefix of str independent of case. If |
||||
* it is, *ptr is set to the address of the first character in str |
||||
* after the prefix. |
||||
* |
||||
* @param str input string |
||||
* @param pfx prefix to test |
||||
* @param ptr updated if the prefix is matched inside str |
||||
* @return non-zero if the prefix matches, zero otherwise |
||||
*/ |
||||
int av_stristart(const char *str, const char *pfx, const char **ptr); |
||||
|
||||
/**
|
||||
* Locate the first case-independent occurrence in the string haystack |
||||
* of the string needle. A zero-length string needle is considered to |
||||
* match at the start of haystack. |
||||
* |
||||
* This function is a case-insensitive version of the standard strstr(). |
||||
* |
||||
* @param haystack string to search in |
||||
* @param needle string to search for |
||||
* @return pointer to the located match within haystack |
||||
* or a null pointer if no match |
||||
*/ |
||||
char *av_stristr(const char *haystack, const char *needle); |
||||
|
||||
/**
|
||||
* Locate the first occurrence of the string needle in the string haystack |
||||
* where not more than hay_length characters are searched. A zero-length |
||||
* string needle is considered to match at the start of haystack. |
||||
* |
||||
* This function is a length-limited version of the standard strstr(). |
||||
* |
||||
* @param haystack string to search in |
||||
* @param needle string to search for |
||||
* @param hay_length length of string to search in |
||||
* @return pointer to the located match within haystack |
||||
* or a null pointer if no match |
||||
*/ |
||||
char *av_strnstr(const char *haystack, const char *needle, size_t hay_length); |
||||
|
||||
/**
|
||||
* Copy the string src to dst, but no more than size - 1 bytes, and |
||||
* null-terminate dst. |
||||
* |
||||
* This function is the same as BSD strlcpy(). |
||||
* |
||||
* @param dst destination buffer |
||||
* @param src source string |
||||
* @param size size of destination buffer |
||||
* @return the length of src |
||||
* |
||||
* @warning since the return value is the length of src, src absolutely |
||||
* _must_ be a properly 0-terminated string, otherwise this will read beyond |
||||
* the end of the buffer and possibly crash. |
||||
*/ |
||||
size_t av_strlcpy(char *dst, const char *src, size_t size); |
||||
|
||||
/**
|
||||
* Append the string src to the string dst, but to a total length of |
||||
* no more than size - 1 bytes, and null-terminate dst. |
||||
* |
||||
* This function is similar to BSD strlcat(), but differs when |
||||
* size <= strlen(dst). |
||||
* |
||||
* @param dst destination buffer |
||||
* @param src source string |
||||
* @param size size of destination buffer |
||||
* @return the total length of src and dst |
||||
* |
||||
* @warning since the return value use the length of src and dst, these |
||||
* absolutely _must_ be a properly 0-terminated strings, otherwise this |
||||
* will read beyond the end of the buffer and possibly crash. |
||||
*/ |
||||
size_t av_strlcat(char *dst, const char *src, size_t size); |
||||
|
||||
/**
|
||||
* Append output to a string, according to a format. Never write out of |
||||
* the destination buffer, and always put a terminating 0 within |
||||
* the buffer. |
||||
* @param dst destination buffer (string to which the output is |
||||
* appended) |
||||
* @param size total size of the destination buffer |
||||
* @param fmt printf-compatible format string, specifying how the |
||||
* following parameters are used |
||||
* @return the length of the string that would have been generated |
||||
* if enough space had been available |
||||
*/ |
||||
size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4); |
||||
|
||||
/**
|
||||
* Get the count of continuous non zero chars starting from the beginning. |
||||
* |
||||
* @param s the string whose length to count |
||||
* @param len maximum number of characters to check in the string, that |
||||
* is the maximum value which is returned by the function |
||||
*/ |
||||
static inline size_t av_strnlen(const char *s, size_t len) |
||||
{ |
||||
size_t i; |
||||
for (i = 0; i < len && s[i]; i++) |
||||
; |
||||
return i; |
||||
} |
||||
|
||||
/**
|
||||
* Print arguments following specified format into a large enough auto |
||||
* allocated buffer. It is similar to GNU asprintf(). |
||||
* @param fmt printf-compatible format string, specifying how the |
||||
* following parameters are used. |
||||
* @return the allocated string |
||||
* @note You have to free the string yourself with av_free(). |
||||
*/ |
||||
char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2); |
||||
|
||||
/**
|
||||
* Unescape the given string until a non escaped terminating char, |
||||
* and return the token corresponding to the unescaped string. |
||||
* |
||||
* The normal \ and ' escaping is supported. Leading and trailing |
||||
* whitespaces are removed, unless they are escaped with '\' or are |
||||
* enclosed between ''. |
||||
* |
||||
* @param buf the buffer to parse, buf will be updated to point to the |
||||
* terminating char |
||||
* @param term a 0-terminated list of terminating chars |
||||
* @return the malloced unescaped string, which must be av_freed by |
||||
* the user, NULL in case of allocation failure |
||||
*/ |
||||
char *av_get_token(const char **buf, const char *term); |
||||
|
||||
/**
|
||||
* Split the string into several tokens which can be accessed by |
||||
* successive calls to av_strtok(). |
||||
* |
||||
* A token is defined as a sequence of characters not belonging to the |
||||
* set specified in delim. |
||||
* |
||||
* On the first call to av_strtok(), s should point to the string to |
||||
* parse, and the value of saveptr is ignored. In subsequent calls, s |
||||
* should be NULL, and saveptr should be unchanged since the previous |
||||
* call. |
||||
* |
||||
* This function is similar to strtok_r() defined in POSIX.1. |
||||
* |
||||
* @param s the string to parse, may be NULL |
||||
* @param delim 0-terminated list of token delimiters, must be non-NULL |
||||
* @param saveptr user-provided pointer which points to stored |
||||
* information necessary for av_strtok() to continue scanning the same |
||||
* string. saveptr is updated to point to the next character after the |
||||
* first delimiter found, or to NULL if the string was terminated |
||||
* @return the found token, or NULL when no token is found |
||||
*/ |
||||
char *av_strtok(char *s, const char *delim, char **saveptr); |
||||
|
||||
/**
|
||||
* Locale-independent conversion of ASCII isdigit. |
||||
*/ |
||||
static inline av_const int av_isdigit(int c) |
||||
{ |
||||
return c >= '0' && c <= '9'; |
||||
} |
||||
|
||||
/**
|
||||
* Locale-independent conversion of ASCII isgraph. |
||||
*/ |
||||
static inline av_const int av_isgraph(int c) |
||||
{ |
||||
return c > 32 && c < 127; |
||||
} |
||||
|
||||
/**
|
||||
* Locale-independent conversion of ASCII isspace. |
||||
*/ |
||||
static inline av_const int av_isspace(int c) |
||||
{ |
||||
return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || |
||||
c == '\v'; |
||||
} |
||||
|
||||
/**
|
||||
* Locale-independent conversion of ASCII characters to uppercase. |
||||
*/ |
||||
static inline av_const int av_toupper(int c) |
||||
{ |
||||
if (c >= 'a' && c <= 'z') |
||||
c ^= 0x20; |
||||
return c; |
||||
} |
||||
|
||||
/**
|
||||
* Locale-independent conversion of ASCII characters to lowercase. |
||||
*/ |
||||
static inline av_const int av_tolower(int c) |
||||
{ |
||||
if (c >= 'A' && c <= 'Z') |
||||
c ^= 0x20; |
||||
return c; |
||||
} |
||||
|
||||
/**
|
||||
* Locale-independent conversion of ASCII isxdigit. |
||||
*/ |
||||
static inline av_const int av_isxdigit(int c) |
||||
{ |
||||
c = av_tolower(c); |
||||
return av_isdigit(c) || (c >= 'a' && c <= 'f'); |
||||
} |
||||
|
||||
/**
|
||||
* Locale-independent case-insensitive compare. |
||||
* @note This means only ASCII-range characters are case-insensitive |
||||
*/ |
||||
int av_strcasecmp(const char *a, const char *b); |
||||
|
||||
/**
|
||||
* Locale-independent case-insensitive compare. |
||||
* @note This means only ASCII-range characters are case-insensitive |
||||
*/ |
||||
int av_strncasecmp(const char *a, const char *b, size_t n); |
||||
|
||||
/**
|
||||
* Locale-independent strings replace. |
||||
* @note This means only ASCII-range characters are replace |
||||
*/ |
||||
char *av_strireplace(const char *str, const char *from, const char *to); |
||||
|
||||
/**
|
||||
* Thread safe basename. |
||||
* @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 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); |
||||
|
||||
/**
|
||||
* Match instances of a name in a comma-separated list of names. |
||||
* List entries are checked from the start to the end of the names list, |
||||
* the first match ends further processing. If an entry prefixed with '-' |
||||
* matches, then 0 is returned. The "ALL" list entry is considered to |
||||
* match all names. |
||||
* |
||||
* @param name Name to look for. |
||||
* @param names List of names. |
||||
* @return 1 on match, 0 otherwise. |
||||
*/ |
||||
int av_match_name(const char *name, const char *names); |
||||
|
||||
/**
|
||||
* Append path component to the existing path. |
||||
* Path separator '/' is placed between when needed. |
||||
* Resulting string have to be freed with av_free(). |
||||
* @param path base path |
||||
* @param component component to be appended |
||||
* @return new path or NULL on error. |
||||
*/ |
||||
char *av_append_path_component(const char *path, const char *component); |
||||
|
||||
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.
|
||||
}; |
||||
|
||||
/**
|
||||
* Consider spaces special and escape them even in the middle of the |
||||
* string. |
||||
* |
||||
* This is equivalent to adding the whitespace characters to the special |
||||
* characters lists, except it is guaranteed to use the exact same list |
||||
* of whitespace characters as the rest of libavutil. |
||||
*/ |
||||
#define AV_ESCAPE_FLAG_WHITESPACE (1 << 0) |
||||
|
||||
/**
|
||||
* Escape only specified special characters. |
||||
* Without this flag, escape also any characters that may be considered |
||||
* special by av_get_token(), such as the single quote. |
||||
*/ |
||||
#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(). |
||||
* |
||||
* @param dst pointer where an allocated string is put |
||||
* @param src string to escape, must be non-NULL |
||||
* @param special_chars string containing the special characters which |
||||
* need to be escaped, can be NULL |
||||
* @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros. |
||||
* Any unknown value for mode will be considered equivalent to |
||||
* AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without |
||||
* notice. |
||||
* @param flags flags which control how to escape, see AV_ESCAPE_FLAG_ macros |
||||
* @return the length of the allocated string, or a negative error code in case of error |
||||
* @see av_bprint_escape() |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_escape(char **dst, const char *src, const char *special_chars, |
||||
enum AVEscapeMode mode, int flags); |
||||
|
||||
#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES 1 ///< accept codepoints over 0x10FFFF
|
||||
#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS 2 ///< accept non-characters - 0xFFFE and 0xFFFF
|
||||
#define AV_UTF8_FLAG_ACCEPT_SURROGATES 4 ///< accept UTF-16 surrogates codes
|
||||
#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES 8 ///< exclude control codes not accepted by XML
|
||||
|
||||
#define AV_UTF8_FLAG_ACCEPT_ALL \ |
||||
AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES|AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS|AV_UTF8_FLAG_ACCEPT_SURROGATES |
||||
|
||||
/**
|
||||
* Read and decode a single UTF-8 code point (character) from the |
||||
* buffer in *buf, and update *buf to point to the next byte to |
||||
* decode. |
||||
* |
||||
* In case of an invalid byte sequence, the pointer will be updated to |
||||
* the next byte after the invalid sequence and the function will |
||||
* return an error code. |
||||
* |
||||
* Depending on the specified flags, the function will also fail in |
||||
* case the decoded code point does not belong to a valid range. |
||||
* |
||||
* @note For speed-relevant code a carefully implemented use of |
||||
* GET_UTF8() may be preferred. |
||||
* |
||||
* @param codep pointer used to return the parsed code in case of success. |
||||
* The value in *codep is set even in case the range check fails. |
||||
* @param bufp pointer to the address the first byte of the sequence |
||||
* to decode, updated by the function to point to the |
||||
* byte next after the decoded sequence |
||||
* @param buf_end pointer to the end of the buffer, points to the next |
||||
* byte past the last in the buffer. This is used to |
||||
* avoid buffer overreads (in case of an unfinished |
||||
* UTF-8 sequence towards the end of the buffer). |
||||
* @param flags a collection of AV_UTF8_FLAG_* flags |
||||
* @return >= 0 in case a sequence was successfully read, a negative |
||||
* value in case of invalid sequence |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end, |
||||
unsigned int flags); |
||||
|
||||
/**
|
||||
* Check if a name is in a list. |
||||
* @returns 0 if not found, or the 1 based index where it has been found in the |
||||
* list. |
||||
*/ |
||||
int av_match_list(const char *name, const char *list, char separator); |
||||
|
||||
/**
|
||||
* See libc sscanf manual for more information. |
||||
* Locale-independent sscanf implementation. |
||||
*/ |
||||
int av_sscanf(const char *string, const char *format, ...); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_AVSTRING_H */ |
||||
@ -0,0 +1,371 @@ |
||||
/*
|
||||
* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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_AVUTIL_H |
||||
#define AVUTIL_AVUTIL_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavu |
||||
* Convenience header that includes @ref lavu "libavutil"'s core. |
||||
*/ |
||||
|
||||
/**
|
||||
* @mainpage |
||||
* |
||||
* @section ffmpeg_intro Introduction |
||||
* |
||||
* This document describes the usage of the different libraries |
||||
* provided by FFmpeg. |
||||
* |
||||
* @li @ref libavc "libavcodec" encoding/decoding library |
||||
* @li @ref lavfi "libavfilter" graph-based frame editing library |
||||
* @li @ref libavf "libavformat" I/O and muxing/demuxing library |
||||
* @li @ref lavd "libavdevice" special devices muxing/demuxing library |
||||
* @li @ref lavu "libavutil" common utility library |
||||
* @li @ref lswr "libswresample" audio resampling, format conversion and mixing |
||||
* @li @ref lpp "libpostproc" post processing library |
||||
* @li @ref libsws "libswscale" color conversion and scaling library |
||||
* |
||||
* @section ffmpeg_versioning Versioning and compatibility |
||||
* |
||||
* Each of the FFmpeg libraries contains a version.h header, which defines a |
||||
* major, minor and micro version number with the |
||||
* <em>LIBRARYNAME_VERSION_{MAJOR,MINOR,MICRO}</em> macros. The major version |
||||
* number is incremented with backward incompatible changes - e.g. removing |
||||
* parts of the public API, reordering public struct members, etc. The minor |
||||
* version number is incremented for backward compatible API changes or major |
||||
* new features - e.g. adding a new public function or a new decoder. The micro |
||||
* version number is incremented for smaller changes that a calling program |
||||
* might still want to check for - e.g. changing behavior in a previously |
||||
* unspecified situation. |
||||
* |
||||
* FFmpeg guarantees backward API and ABI compatibility for each library as long |
||||
* as its major version number is unchanged. This means that no public symbols |
||||
* will be removed or renamed. Types and names of the public struct members and |
||||
* values of public macros and enums will remain the same (unless they were |
||||
* explicitly declared as not part of the public API). Documented behavior will |
||||
* not change. |
||||
* |
||||
* In other words, any correct program that works with a given FFmpeg snapshot |
||||
* should work just as well without any changes with any later snapshot with the |
||||
* same major versions. This applies to both rebuilding the program against new |
||||
* FFmpeg versions or to replacing the dynamic FFmpeg libraries that a program |
||||
* links against. |
||||
* |
||||
* However, new public symbols may be added and new members may be appended to |
||||
* public structs whose size is not part of public ABI (most public structs in |
||||
* FFmpeg). New macros and enum values may be added. Behavior in undocumented |
||||
* situations may change slightly (and be documented). All those are accompanied |
||||
* by an entry in doc/APIchanges and incrementing either the minor or micro |
||||
* version number. |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavu libavutil |
||||
* Common code shared across all FFmpeg libraries. |
||||
* |
||||
* @note |
||||
* libavutil is designed to be modular. In most cases, in order to use the |
||||
* functions provided by one component of libavutil you must explicitly include |
||||
* the specific header containing that feature. If you are only using |
||||
* media-related components, you could simply include libavutil/avutil.h, which |
||||
* brings in most of the "core" components. |
||||
* |
||||
* @{ |
||||
* |
||||
* @defgroup lavu_crypto Crypto and Hashing |
||||
* |
||||
* @{ |
||||
* @} |
||||
* |
||||
* @defgroup lavu_math Mathematics |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_string String Manipulation |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_mem Memory Management |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_data Data Structures |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_video Video related |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_audio Audio related |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_error Error Codes |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_log Logging Facility |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup lavu_misc Other |
||||
* |
||||
* @{ |
||||
* |
||||
* @defgroup preproc_misc Preprocessor String Macros |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
* |
||||
* @defgroup version_utils Library Version Macros |
||||
* |
||||
* @{ |
||||
* |
||||
* @} |
||||
*/ |
||||
|
||||
|
||||
/**
|
||||
* @addtogroup lavu_ver |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Return the LIBAVUTIL_VERSION_INT constant. |
||||
*/ |
||||
unsigned avutil_version(void); |
||||
|
||||
/**
|
||||
* Return an informative version string. This usually is the actual release |
||||
* version number or a git commit description. This string has no fixed format |
||||
* and can change any time. It should never be parsed by code. |
||||
*/ |
||||
const char *av_version_info(void); |
||||
|
||||
/**
|
||||
* Return the libavutil build-time configuration. |
||||
*/ |
||||
const char *avutil_configuration(void); |
||||
|
||||
/**
|
||||
* Return the libavutil license. |
||||
*/ |
||||
const char *avutil_license(void); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @addtogroup lavu_media Media Type |
||||
* @brief Media Type |
||||
*/ |
||||
|
||||
enum AVMediaType { |
||||
AVMEDIA_TYPE_UNKNOWN = -1, ///< Usually treated as AVMEDIA_TYPE_DATA
|
||||
AVMEDIA_TYPE_VIDEO, |
||||
AVMEDIA_TYPE_AUDIO, |
||||
AVMEDIA_TYPE_DATA, ///< Opaque data information usually continuous
|
||||
AVMEDIA_TYPE_SUBTITLE, |
||||
AVMEDIA_TYPE_ATTACHMENT, ///< Opaque data information usually sparse
|
||||
AVMEDIA_TYPE_NB |
||||
}; |
||||
|
||||
/**
|
||||
* Return a string describing the media_type enum, NULL if media_type |
||||
* is unknown. |
||||
*/ |
||||
const char *av_get_media_type_string(enum AVMediaType media_type); |
||||
|
||||
/**
|
||||
* @defgroup lavu_const Constants |
||||
* @{ |
||||
* |
||||
* @defgroup lavu_enc Encoding specific |
||||
* |
||||
* @note those definition should move to avcodec |
||||
* @{ |
||||
*/ |
||||
|
||||
#define FF_LAMBDA_SHIFT 7 |
||||
#define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT) |
||||
#define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda
|
||||
#define FF_LAMBDA_MAX (256*128-1) |
||||
|
||||
#define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove
|
||||
|
||||
/**
|
||||
* @} |
||||
* @defgroup lavu_time Timestamp specific |
||||
* |
||||
* FFmpeg internal timebase and timestamp definitions |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @brief Undefined timestamp value |
||||
* |
||||
* Usually reported by demuxer that work on containers that do not provide |
||||
* either pts or dts. |
||||
*/ |
||||
|
||||
#define AV_NOPTS_VALUE ((int64_t)UINT64_C(0x8000000000000000)) |
||||
|
||||
/**
|
||||
* Internal time base represented as integer |
||||
*/ |
||||
|
||||
#define AV_TIME_BASE 1000000 |
||||
|
||||
/**
|
||||
* Internal time base represented as fractional value |
||||
*/ |
||||
|
||||
#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE} |
||||
|
||||
/**
|
||||
* @} |
||||
* @} |
||||
* @defgroup lavu_picture Image related |
||||
* |
||||
* AVPicture types, pixel formats and basic image planes manipulation. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
enum AVPictureType { |
||||
AV_PICTURE_TYPE_NONE = 0, ///< Undefined
|
||||
AV_PICTURE_TYPE_I, ///< Intra
|
||||
AV_PICTURE_TYPE_P, ///< Predicted
|
||||
AV_PICTURE_TYPE_B, ///< Bi-dir predicted
|
||||
AV_PICTURE_TYPE_S, ///< S(GMC)-VOP MPEG-4
|
||||
AV_PICTURE_TYPE_SI, ///< Switching Intra
|
||||
AV_PICTURE_TYPE_SP, ///< Switching Predicted
|
||||
AV_PICTURE_TYPE_BI, ///< BI type
|
||||
}; |
||||
|
||||
/**
|
||||
* Return a single letter to describe the given picture type |
||||
* pict_type. |
||||
* |
||||
* @param[in] pict_type the picture type @return a single character |
||||
* representing the picture type, '?' if pict_type is unknown |
||||
*/ |
||||
char av_get_picture_type_char(enum AVPictureType pict_type); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#include "common.h" |
||||
#include "error.h" |
||||
#include "rational.h" |
||||
#include "version.h" |
||||
#include "macros.h" |
||||
#include "mathematics.h" |
||||
#include "log.h" |
||||
#include "pixfmt.h" |
||||
|
||||
/**
|
||||
* Return x default pointer in case p is NULL. |
||||
*/ |
||||
static inline void *av_x_if_null(const void *p, const void *x) |
||||
{ |
||||
return (void *)(intptr_t)(p ? p : x); |
||||
} |
||||
|
||||
/**
|
||||
* Compute the length of an integer list. |
||||
* |
||||
* @param elsize size in bytes of each list element (only 1, 2, 4 or 8) |
||||
* @param term list terminator (usually 0 or -1) |
||||
* @param list pointer to the list |
||||
* @return length of the list, in elements, not counting the terminator |
||||
*/ |
||||
unsigned av_int_list_length_for_size(unsigned elsize, |
||||
const void *list, uint64_t term) av_pure; |
||||
|
||||
/**
|
||||
* Compute the length of an integer list. |
||||
* |
||||
* @param term list terminator (usually 0 or -1) |
||||
* @param list pointer to the list |
||||
* @return length of the list, in elements, not counting the terminator |
||||
*/ |
||||
#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. |
||||
*/ |
||||
AVRational av_get_time_base_q(void); |
||||
|
||||
#define AV_FOURCC_MAX_STRING_SIZE 32 |
||||
|
||||
#define av_fourcc2str(fourcc) av_fourcc_make_string((char[AV_FOURCC_MAX_STRING_SIZE]){0}, fourcc) |
||||
|
||||
/**
|
||||
* Fill the provided buffer with a string containing a FourCC (four-character |
||||
* code) representation. |
||||
* |
||||
* @param buf a buffer with size in bytes of at least AV_FOURCC_MAX_STRING_SIZE |
||||
* @param fourcc the fourcc to represent |
||||
* @return the buffer in input |
||||
*/ |
||||
char *av_fourcc_make_string(char *buf, uint32_t fourcc); |
||||
|
||||
/**
|
||||
* @} |
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_AVUTIL_H */ |
||||
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.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_BASE64_H |
||||
#define AVUTIL_BASE64_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @defgroup lavu_base64 Base64 |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Decode a base64-encoded string. |
||||
* |
||||
* @param out buffer for decoded data |
||||
* @param in null-terminated input string |
||||
* @param out_size size in bytes of the out buffer, must be at |
||||
* least 3/4 of the length of in, that is AV_BASE64_DECODE_SIZE(strlen(in)) |
||||
* @return number of bytes written, or a negative value in case of |
||||
* invalid input |
||||
*/ |
||||
int av_base64_decode(uint8_t *out, const char *in, int out_size); |
||||
|
||||
/**
|
||||
* Calculate the output size in bytes needed to decode a base64 string |
||||
* with length x to a data buffer. |
||||
*/ |
||||
#define AV_BASE64_DECODE_SIZE(x) ((x) * 3LL / 4) |
||||
|
||||
/**
|
||||
* Encode data to base64 and null-terminate. |
||||
* |
||||
* @param out buffer for encoded data |
||||
* @param out_size size in bytes of the out buffer (including the |
||||
* null terminator), must be at least AV_BASE64_SIZE(in_size) |
||||
* @param in input buffer containing the data to encode |
||||
* @param in_size size in bytes of the in buffer |
||||
* @return out or NULL in case of error |
||||
*/ |
||||
char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size); |
||||
|
||||
/**
|
||||
* Calculate the output size needed to base64-encode x bytes to a |
||||
* null-terminated string. |
||||
*/ |
||||
#define AV_BASE64_SIZE(x) (((x)+2) / 3 * 4 + 1) |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_BASE64_H */ |
||||
@ -0,0 +1,82 @@ |
||||
/*
|
||||
* Blowfish algorithm |
||||
* Copyright (c) 2012 Samuel Pitoiset |
||||
* |
||||
* 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_BLOWFISH_H |
||||
#define AVUTIL_BLOWFISH_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @defgroup lavu_blowfish Blowfish |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
#define AV_BF_ROUNDS 16 |
||||
|
||||
typedef struct AVBlowfish { |
||||
uint32_t p[AV_BF_ROUNDS + 2]; |
||||
uint32_t s[4][256]; |
||||
} AVBlowfish; |
||||
|
||||
/**
|
||||
* Allocate an AVBlowfish context. |
||||
*/ |
||||
AVBlowfish *av_blowfish_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize an AVBlowfish context. |
||||
* |
||||
* @param ctx an AVBlowfish context |
||||
* @param key a key |
||||
* @param key_len length of the key |
||||
*/ |
||||
void av_blowfish_init(struct AVBlowfish *ctx, const uint8_t *key, int key_len); |
||||
|
||||
/**
|
||||
* Encrypt or decrypt a buffer using a previously initialized context. |
||||
* |
||||
* @param ctx an AVBlowfish context |
||||
* @param xl left four bytes halves of input to be encrypted |
||||
* @param xr right four bytes halves of input to be encrypted |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_blowfish_crypt_ecb(struct AVBlowfish *ctx, uint32_t *xl, uint32_t *xr, |
||||
int decrypt); |
||||
|
||||
/**
|
||||
* Encrypt or decrypt a buffer using a previously initialized context. |
||||
* |
||||
* @param ctx an AVBlowfish context |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @param count number of 8 byte blocks |
||||
* @param iv initialization vector for CBC mode, if NULL ECB will be used |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_blowfish_crypt(struct AVBlowfish *ctx, uint8_t *dst, const uint8_t *src, |
||||
int count, uint8_t *iv, int decrypt); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_BLOWFISH_H */ |
||||
@ -0,0 +1,251 @@ |
||||
/*
|
||||
* Copyright (c) 2012 Nicolas George |
||||
* |
||||
* 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 |
||||
* @ingroup lavu_avbprint |
||||
* AVBPrint public header |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_BPRINT_H |
||||
#define AVUTIL_BPRINT_H |
||||
|
||||
#include <stdarg.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "avstring.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_avbprint AVBPrint |
||||
* @ingroup lavu_data |
||||
* |
||||
* A buffer to print data progressively |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Define a structure with extra padding to a fixed size |
||||
* This helps ensuring binary compatibility with future versions. |
||||
*/ |
||||
|
||||
#define FF_PAD_STRUCTURE(name, size, ...) \ |
||||
struct ff_pad_helper_##name { __VA_ARGS__ }; \
|
||||
typedef struct name { \
|
||||
__VA_ARGS__ \
|
||||
char reserved_padding[size - sizeof(struct ff_pad_helper_##name)]; \
|
||||
} name; |
||||
|
||||
/**
|
||||
* Buffer to print data progressively |
||||
* |
||||
* The string buffer grows as necessary and is always 0-terminated. |
||||
* The content of the string is never accessed, and thus is |
||||
* encoding-agnostic and can even hold binary data. |
||||
* |
||||
* Small buffers are kept in the structure itself, and thus require no |
||||
* memory allocation at all (unless the contents of the buffer is needed |
||||
* after the structure goes out of scope). This is almost as lightweight as |
||||
* declaring a local `char buf[512]`. |
||||
* |
||||
* The length of the string can go beyond the allocated size: the buffer is |
||||
* then truncated, but the functions still keep account of the actual total |
||||
* length. |
||||
* |
||||
* In other words, AVBPrint.len can be greater than AVBPrint.size and records |
||||
* the total length of what would have been to the buffer if there had been |
||||
* enough memory. |
||||
* |
||||
* Append operations do not need to be tested for failure: if a memory |
||||
* allocation fails, data stop being appended to the buffer, but the length |
||||
* is still updated. This situation can be tested with |
||||
* av_bprint_is_complete(). |
||||
* |
||||
* The AVBPrint.size_max field determines several possible behaviours: |
||||
* - `size_max = -1` (= `UINT_MAX`) or any large value will let the buffer be |
||||
* reallocated as necessary, with an amortized linear cost. |
||||
* - `size_max = 0` prevents writing anything to the buffer: only the total |
||||
* length is computed. The write operations can then possibly be repeated in |
||||
* a buffer with exactly the necessary size |
||||
* (using `size_init = size_max = len + 1`). |
||||
* - `size_max = 1` is automatically replaced by the exact size available in the |
||||
* structure itself, thus ensuring no dynamic memory allocation. The |
||||
* internal buffer is large enough to hold a reasonable paragraph of text, |
||||
* such as the current paragraph. |
||||
*/ |
||||
|
||||
FF_PAD_STRUCTURE(AVBPrint, 1024, |
||||
char *str; /**< string so far */ |
||||
unsigned len; /**< length so far */ |
||||
unsigned size; /**< allocated memory */ |
||||
unsigned size_max; /**< maximum allocated memory */ |
||||
char reserved_internal_buffer[1]; |
||||
) |
||||
|
||||
/**
|
||||
* @name Max size special values |
||||
* Convenience macros for special values for av_bprint_init() size_max |
||||
* parameter. |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Buffer will be reallocated as necessary, with an amortized linear cost. |
||||
*/ |
||||
#define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1) |
||||
/**
|
||||
* Use the exact size available in the AVBPrint structure itself. |
||||
* |
||||
* Thus ensuring no dynamic memory allocation. The internal buffer is large |
||||
* enough to hold a reasonable paragraph of text, such as the current paragraph. |
||||
*/ |
||||
#define AV_BPRINT_SIZE_AUTOMATIC 1 |
||||
/**
|
||||
* Do not write anything to the buffer, only calculate the total length. |
||||
* |
||||
* The write operations can then possibly be repeated in a buffer with |
||||
* exactly the necessary size (using `size_init = size_max = AVBPrint.len + 1`). |
||||
*/ |
||||
#define AV_BPRINT_SIZE_COUNT_ONLY 0 |
||||
/** @} */ |
||||
|
||||
/**
|
||||
* Init a print buffer. |
||||
* |
||||
* @param buf buffer to init |
||||
* @param size_init initial size (including the final 0) |
||||
* @param size_max maximum size; |
||||
* - `0` means do not write anything, just count the length |
||||
* - `1` is replaced by the maximum value for automatic storage |
||||
* any large value means that the internal buffer will be |
||||
* reallocated as needed up to that limit |
||||
* - `-1` is converted to `UINT_MAX`, the largest limit possible. |
||||
* Check also `AV_BPRINT_SIZE_*` macros. |
||||
*/ |
||||
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max); |
||||
|
||||
/**
|
||||
* Init a print buffer using a pre-existing buffer. |
||||
* |
||||
* The buffer will not be reallocated. |
||||
* |
||||
* @param buf buffer structure to init |
||||
* @param buffer byte buffer to use for the string data |
||||
* @param size size of buffer |
||||
*/ |
||||
void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size); |
||||
|
||||
/**
|
||||
* Append a formatted string to a print buffer. |
||||
*/ |
||||
void av_bprintf(AVBPrint *buf, const char *fmt, ...) av_printf_format(2, 3); |
||||
|
||||
/**
|
||||
* Append a formatted string to a print buffer. |
||||
*/ |
||||
void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg); |
||||
|
||||
/**
|
||||
* Append char c n times to a print buffer. |
||||
*/ |
||||
void av_bprint_chars(AVBPrint *buf, char c, unsigned n); |
||||
|
||||
/**
|
||||
* Append data to a print buffer. |
||||
* |
||||
* param buf bprint buffer to use |
||||
* param data pointer to data |
||||
* param size size of data |
||||
*/ |
||||
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size); |
||||
|
||||
struct tm; |
||||
/**
|
||||
* Append a formatted date and time to a print buffer. |
||||
* |
||||
* param buf bprint buffer to use |
||||
* param fmt date and time format string, see strftime() |
||||
* param tm broken-down time structure to translate |
||||
* |
||||
* @note due to poor design of the standard strftime function, it may |
||||
* produce poor results if the format string expands to a very long text and |
||||
* the bprint buffer is near the limit stated by the size_max option. |
||||
*/ |
||||
void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm); |
||||
|
||||
/**
|
||||
* Allocate bytes in the buffer for external use. |
||||
* |
||||
* @param[in] buf buffer structure |
||||
* @param[in] size required size |
||||
* @param[out] mem pointer to the memory area |
||||
* @param[out] actual_size size of the memory area after allocation; |
||||
* can be larger or smaller than size |
||||
*/ |
||||
void av_bprint_get_buffer(AVBPrint *buf, unsigned size, |
||||
unsigned char **mem, unsigned *actual_size); |
||||
|
||||
/**
|
||||
* Reset the string to "" but keep internal allocated data. |
||||
*/ |
||||
void av_bprint_clear(AVBPrint *buf); |
||||
|
||||
/**
|
||||
* Test if the print buffer is complete (not truncated). |
||||
* |
||||
* It may have been truncated due to a memory allocation failure |
||||
* or the size_max limit (compare size and size_max if necessary). |
||||
*/ |
||||
static inline int av_bprint_is_complete(const AVBPrint *buf) |
||||
{ |
||||
return buf->len < buf->size; |
||||
} |
||||
|
||||
/**
|
||||
* Finalize a print buffer. |
||||
* |
||||
* The print buffer can no longer be used afterwards, |
||||
* but the len and size fields are still valid. |
||||
* |
||||
* @arg[out] ret_str if not NULL, used to return a permanent copy of the |
||||
* buffer contents, or NULL if memory allocation fails; |
||||
* if NULL, the buffer is discarded and freed |
||||
* @return 0 for success or error code (probably AVERROR(ENOMEM)) |
||||
*/ |
||||
int av_bprint_finalize(AVBPrint *buf, char **ret_str); |
||||
|
||||
/**
|
||||
* Escape the content in src and append it to dstbuf. |
||||
* |
||||
* @param dstbuf already inited destination bprint buffer |
||||
* @param src string containing the text to escape |
||||
* @param special_chars string containing the special characters which |
||||
* need to be escaped, can be NULL |
||||
* @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros. |
||||
* Any unknown value for mode will be considered equivalent to |
||||
* AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without |
||||
* notice. |
||||
* @param flags flags which control how to escape, see AV_ESCAPE_FLAG_* macros |
||||
*/ |
||||
void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, |
||||
enum AVEscapeMode mode, int flags); |
||||
|
||||
/** @} */ |
||||
|
||||
#endif /* AVUTIL_BPRINT_H */ |
||||
@ -0,0 +1,111 @@ |
||||
/*
|
||||
* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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 |
||||
* byte swapping routines |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_BSWAP_H |
||||
#define AVUTIL_BSWAP_H |
||||
|
||||
#include <stdint.h> |
||||
#include "libavutil/avconfig.h" |
||||
#include "attributes.h" |
||||
|
||||
#ifdef HAVE_AV_CONFIG_H |
||||
|
||||
#include "config.h" |
||||
|
||||
#if ARCH_AARCH64 |
||||
# include "aarch64/bswap.h" |
||||
#elif ARCH_ARM |
||||
# include "arm/bswap.h" |
||||
#elif ARCH_AVR32 |
||||
# include "avr32/bswap.h" |
||||
#elif ARCH_RISCV |
||||
# include "riscv/bswap.h" |
||||
#elif ARCH_SH4 |
||||
# include "sh4/bswap.h" |
||||
#elif ARCH_X86 |
||||
# include "x86/bswap.h" |
||||
#endif |
||||
|
||||
#endif /* HAVE_AV_CONFIG_H */ |
||||
|
||||
#define AV_BSWAP16C(x) (((x) << 8 & 0xff00) | ((x) >> 8 & 0x00ff)) |
||||
#define AV_BSWAP32C(x) (AV_BSWAP16C(x) << 16 | AV_BSWAP16C((x) >> 16)) |
||||
#define AV_BSWAP64C(x) (AV_BSWAP32C(x) << 32 | AV_BSWAP32C((x) >> 32)) |
||||
|
||||
#define AV_BSWAPC(s, x) AV_BSWAP##s##C(x) |
||||
|
||||
#ifndef av_bswap16 |
||||
static av_always_inline av_const uint16_t av_bswap16(uint16_t x) |
||||
{ |
||||
x= (x>>8) | (x<<8); |
||||
return x; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef av_bswap32 |
||||
static av_always_inline av_const uint32_t av_bswap32(uint32_t x) |
||||
{ |
||||
return AV_BSWAP32C(x); |
||||
} |
||||
#endif |
||||
|
||||
#ifndef av_bswap64 |
||||
static inline uint64_t av_const av_bswap64(uint64_t x) |
||||
{ |
||||
return (uint64_t)av_bswap32(x) << 32 | av_bswap32(x >> 32); |
||||
} |
||||
#endif |
||||
|
||||
// be2ne ... big-endian to native-endian
|
||||
// le2ne ... little-endian to native-endian
|
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
#define av_be2ne16(x) (x) |
||||
#define av_be2ne32(x) (x) |
||||
#define av_be2ne64(x) (x) |
||||
#define av_le2ne16(x) av_bswap16(x) |
||||
#define av_le2ne32(x) av_bswap32(x) |
||||
#define av_le2ne64(x) av_bswap64(x) |
||||
#define AV_BE2NEC(s, x) (x) |
||||
#define AV_LE2NEC(s, x) AV_BSWAPC(s, x) |
||||
#else |
||||
#define av_be2ne16(x) av_bswap16(x) |
||||
#define av_be2ne32(x) av_bswap32(x) |
||||
#define av_be2ne64(x) av_bswap64(x) |
||||
#define av_le2ne16(x) (x) |
||||
#define av_le2ne32(x) (x) |
||||
#define av_le2ne64(x) (x) |
||||
#define AV_BE2NEC(s, x) AV_BSWAPC(s, x) |
||||
#define AV_LE2NEC(s, x) (x) |
||||
#endif |
||||
|
||||
#define AV_BE2NE16C(x) AV_BE2NEC(16, x) |
||||
#define AV_BE2NE32C(x) AV_BE2NEC(32, x) |
||||
#define AV_BE2NE64C(x) AV_BE2NEC(64, x) |
||||
#define AV_LE2NE16C(x) AV_LE2NEC(16, x) |
||||
#define AV_LE2NE32C(x) AV_LE2NEC(32, x) |
||||
#define AV_LE2NE64C(x) AV_LE2NEC(64, x) |
||||
|
||||
#endif /* AVUTIL_BSWAP_H */ |
||||
@ -0,0 +1,322 @@ |
||||
/*
|
||||
* 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 |
||||
* @ingroup lavu_buffer |
||||
* refcounted data buffer API |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_BUFFER_H |
||||
#define AVUTIL_BUFFER_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @defgroup lavu_buffer AVBuffer |
||||
* @ingroup lavu_data |
||||
* |
||||
* @{ |
||||
* AVBuffer is an API for reference-counted data buffers. |
||||
* |
||||
* There are two core objects in this API -- AVBuffer and AVBufferRef. AVBuffer |
||||
* represents the data buffer itself; it is opaque and not meant to be accessed |
||||
* by the caller directly, but only through AVBufferRef. However, the caller may |
||||
* e.g. compare two AVBuffer pointers to check whether two different references |
||||
* are describing the same data buffer. AVBufferRef represents a single |
||||
* reference to an AVBuffer and it is the object that may be manipulated by the |
||||
* caller directly. |
||||
* |
||||
* There are two functions provided for creating a new AVBuffer with a single |
||||
* reference -- av_buffer_alloc() to just allocate a new buffer, and |
||||
* av_buffer_create() to wrap an existing array in an AVBuffer. From an existing |
||||
* reference, additional references may be created with av_buffer_ref(). |
||||
* Use av_buffer_unref() to free a reference (this will automatically free the |
||||
* data once all the references are freed). |
||||
* |
||||
* The convention throughout this API and the rest of FFmpeg is such that the |
||||
* buffer is considered writable if there exists only one reference to it (and |
||||
* it has not been marked as read-only). The av_buffer_is_writable() function is |
||||
* provided to check whether this is true and av_buffer_make_writable() will |
||||
* automatically create a new writable buffer when necessary. |
||||
* Of course nothing prevents the calling code from violating this convention, |
||||
* however that is safe only when all the existing references are under its |
||||
* control. |
||||
* |
||||
* @note Referencing and unreferencing the buffers is thread-safe and thus |
||||
* may be done from multiple threads simultaneously without any need for |
||||
* additional locking. |
||||
* |
||||
* @note Two different references to the same buffer can point to different |
||||
* parts of the buffer (i.e. their AVBufferRef.data will not be equal). |
||||
*/ |
||||
|
||||
/**
|
||||
* A reference counted buffer type. It is opaque and is meant to be used through |
||||
* references (AVBufferRef). |
||||
*/ |
||||
typedef struct AVBuffer AVBuffer; |
||||
|
||||
/**
|
||||
* A reference to a data buffer. |
||||
* |
||||
* The size of this struct is not a part of the public ABI and it is not meant |
||||
* to be allocated directly. |
||||
*/ |
||||
typedef struct AVBufferRef { |
||||
AVBuffer *buffer; |
||||
|
||||
/**
|
||||
* The data buffer. It is considered writable if and only if |
||||
* this is the only reference to the buffer, in which case |
||||
* av_buffer_is_writable() returns 1. |
||||
*/ |
||||
uint8_t *data; |
||||
/**
|
||||
* Size of data in bytes. |
||||
*/ |
||||
size_t size; |
||||
} AVBufferRef; |
||||
|
||||
/**
|
||||
* Allocate an AVBuffer of the given size using av_malloc(). |
||||
* |
||||
* @return an AVBufferRef of given size or NULL when out of memory |
||||
*/ |
||||
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(size_t size); |
||||
|
||||
/**
|
||||
* Always treat the buffer as read-only, even when it has only one |
||||
* reference. |
||||
*/ |
||||
#define AV_BUFFER_FLAG_READONLY (1 << 0) |
||||
|
||||
/**
|
||||
* Create an AVBuffer from an existing array. |
||||
* |
||||
* If this function is successful, data is owned by the AVBuffer. The caller may |
||||
* only access data through the returned AVBufferRef and references derived from |
||||
* it. |
||||
* If this function fails, data is left untouched. |
||||
* @param data data array |
||||
* @param size size of data in bytes |
||||
* @param free a callback for freeing this buffer's data |
||||
* @param opaque parameter to be got for processing or passed to free |
||||
* @param flags a combination of AV_BUFFER_FLAG_* |
||||
* |
||||
* @return an AVBufferRef referring to data on success, NULL on failure. |
||||
*/ |
||||
AVBufferRef *av_buffer_create(uint8_t *data, size_t size, |
||||
void (*free)(void *opaque, uint8_t *data), |
||||
void *opaque, int flags); |
||||
|
||||
/**
|
||||
* Default free callback, which calls av_free() on the buffer data. |
||||
* This function is meant to be passed to av_buffer_create(), not called |
||||
* directly. |
||||
*/ |
||||
void av_buffer_default_free(void *opaque, uint8_t *data); |
||||
|
||||
/**
|
||||
* Create a new reference to an AVBuffer. |
||||
* |
||||
* @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on |
||||
* failure. |
||||
*/ |
||||
AVBufferRef *av_buffer_ref(const AVBufferRef *buf); |
||||
|
||||
/**
|
||||
* Free a given reference and automatically free the buffer if there are no more |
||||
* references to it. |
||||
* |
||||
* @param buf the reference to be freed. The pointer is set to NULL on return. |
||||
*/ |
||||
void av_buffer_unref(AVBufferRef **buf); |
||||
|
||||
/**
|
||||
* @return 1 if the caller may write to the data referred to by buf (which is |
||||
* true if and only if buf is the only reference to the underlying AVBuffer). |
||||
* Return 0 otherwise. |
||||
* A positive answer is valid until av_buffer_ref() is called on buf. |
||||
*/ |
||||
int av_buffer_is_writable(const AVBufferRef *buf); |
||||
|
||||
/**
|
||||
* @return the opaque parameter set by av_buffer_create. |
||||
*/ |
||||
void *av_buffer_get_opaque(const AVBufferRef *buf); |
||||
|
||||
int av_buffer_get_ref_count(const AVBufferRef *buf); |
||||
|
||||
/**
|
||||
* Create a writable reference from a given buffer reference, avoiding data copy |
||||
* if possible. |
||||
* |
||||
* @param buf buffer reference to make writable. On success, buf is either left |
||||
* untouched, or it is unreferenced and a new writable AVBufferRef is |
||||
* written in its place. On failure, buf is left untouched. |
||||
* @return 0 on success, a negative AVERROR on failure. |
||||
*/ |
||||
int av_buffer_make_writable(AVBufferRef **buf); |
||||
|
||||
/**
|
||||
* Reallocate a given buffer. |
||||
* |
||||
* @param buf a buffer reference to reallocate. On success, buf will be |
||||
* unreferenced and a new reference with the required size will be |
||||
* written in its place. On failure buf will be left untouched. *buf |
||||
* may be NULL, then a new buffer is allocated. |
||||
* @param size required new buffer size. |
||||
* @return 0 on success, a negative AVERROR on failure. |
||||
* |
||||
* @note the buffer is actually reallocated with av_realloc() only if it was |
||||
* initially allocated through av_buffer_realloc(NULL) and there is only one |
||||
* 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, 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); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavu_bufferpool AVBufferPool |
||||
* @ingroup lavu_data |
||||
* |
||||
* @{ |
||||
* AVBufferPool is an API for a lock-free thread-safe pool of AVBuffers. |
||||
* |
||||
* Frequently allocating and freeing large buffers may be slow. AVBufferPool is |
||||
* meant to solve this in cases when the caller needs a set of buffers of the |
||||
* same size (the most obvious use case being buffers for raw video or audio |
||||
* frames). |
||||
* |
||||
* At the beginning, the user must call av_buffer_pool_init() to create the |
||||
* buffer pool. Then whenever a buffer is needed, call av_buffer_pool_get() to |
||||
* get a reference to a new buffer, similar to av_buffer_alloc(). This new |
||||
* reference works in all aspects the same way as the one created by |
||||
* av_buffer_alloc(). However, when the last reference to this buffer is |
||||
* unreferenced, it is returned to the pool instead of being freed and will be |
||||
* reused for subsequent av_buffer_pool_get() calls. |
||||
* |
||||
* When the caller is done with the pool and no longer needs to allocate any new |
||||
* buffers, av_buffer_pool_uninit() must be called to mark the pool as freeable. |
||||
* Once all the buffers are released, it will automatically be freed. |
||||
* |
||||
* Allocating and releasing buffers with this API is thread-safe as long as |
||||
* either the default alloc callback is used, or the user-supplied one is |
||||
* thread-safe. |
||||
*/ |
||||
|
||||
/**
|
||||
* The buffer pool. This structure is opaque and not meant to be accessed |
||||
* directly. It is allocated with av_buffer_pool_init() and freed with |
||||
* av_buffer_pool_uninit(). |
||||
*/ |
||||
typedef struct AVBufferPool AVBufferPool; |
||||
|
||||
/**
|
||||
* Allocate and initialize a buffer pool. |
||||
* |
||||
* @param size size of each buffer in this pool |
||||
* @param alloc a function that will be used to allocate new buffers when the |
||||
* pool is empty. May be NULL, then the default allocator will be used |
||||
* (av_buffer_alloc()). |
||||
* @return newly created buffer pool on success, NULL on error. |
||||
*/ |
||||
AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size)); |
||||
|
||||
/**
|
||||
* Allocate and initialize a buffer pool with a more complex allocator. |
||||
* |
||||
* @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. 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. May be NULL. |
||||
* @return newly created buffer pool on success, NULL on error. |
||||
*/ |
||||
AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque, |
||||
AVBufferRef* (*alloc)(void *opaque, size_t size), |
||||
void (*pool_free)(void *opaque)); |
||||
|
||||
/**
|
||||
* Mark the pool as being available for freeing. It will actually be freed only |
||||
* once all the allocated buffers associated with the pool are released. Thus it |
||||
* is safe to call this function while some of the allocated buffers are still |
||||
* in use. |
||||
* |
||||
* @param pool pointer to the pool to be freed. It will be set to NULL. |
||||
*/ |
||||
void av_buffer_pool_uninit(AVBufferPool **pool); |
||||
|
||||
/**
|
||||
* Allocate a new AVBuffer, reusing an old buffer from the pool when available. |
||||
* This function may be called simultaneously from multiple threads. |
||||
* |
||||
* @return a reference to the new buffer on success, NULL on error. |
||||
*/ |
||||
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); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_BUFFER_H */ |
||||
@ -0,0 +1,70 @@ |
||||
/*
|
||||
* An implementation of the CAMELLIA algorithm as mentioned in RFC3713 |
||||
* Copyright (c) 2014 Supraja Meedinti |
||||
* |
||||
* 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_CAMELLIA_H |
||||
#define AVUTIL_CAMELLIA_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
|
||||
/**
|
||||
* @file |
||||
* @brief Public header for libavutil CAMELLIA algorithm |
||||
* @defgroup lavu_camellia CAMELLIA |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
extern const int av_camellia_size; |
||||
|
||||
struct AVCAMELLIA; |
||||
|
||||
/**
|
||||
* Allocate an AVCAMELLIA context |
||||
* To free the struct: av_free(ptr) |
||||
*/ |
||||
struct AVCAMELLIA *av_camellia_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize an AVCAMELLIA context. |
||||
* |
||||
* @param ctx an AVCAMELLIA context |
||||
* @param key a key of 16, 24, 32 bytes used for encryption/decryption |
||||
* @param key_bits number of keybits: possible are 128, 192, 256 |
||||
*/ |
||||
int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits); |
||||
|
||||
/**
|
||||
* Encrypt or decrypt a buffer using a previously initialized context |
||||
* |
||||
* @param ctx an AVCAMELLIA context |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @param count number of 16 byte blocks |
||||
* @param iv initialization vector for CBC mode, NULL for ECB mode |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
#endif /* AVUTIL_CAMELLIA_H */ |
||||
@ -0,0 +1,80 @@ |
||||
/*
|
||||
* An implementation of the CAST128 algorithm as mentioned in RFC2144 |
||||
* Copyright (c) 2014 Supraja Meedinti |
||||
* |
||||
* 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_CAST5_H |
||||
#define AVUTIL_CAST5_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
|
||||
/**
|
||||
* @file |
||||
* @brief Public header for libavutil CAST5 algorithm |
||||
* @defgroup lavu_cast5 CAST5 |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
extern const int av_cast5_size; |
||||
|
||||
struct AVCAST5; |
||||
|
||||
/**
|
||||
* Allocate an AVCAST5 context |
||||
* To free the struct: av_free(ptr) |
||||
*/ |
||||
struct AVCAST5 *av_cast5_alloc(void); |
||||
/**
|
||||
* Initialize an AVCAST5 context. |
||||
* |
||||
* @param ctx an AVCAST5 context |
||||
* @param key a key of 5,6,...16 bytes used for encryption/decryption |
||||
* @param key_bits number of keybits: possible are 40,48,...,128 |
||||
* @return 0 on success, less than 0 on failure |
||||
*/ |
||||
int av_cast5_init(struct AVCAST5 *ctx, const uint8_t *key, int key_bits); |
||||
|
||||
/**
|
||||
* Encrypt or decrypt a buffer using a previously initialized context, ECB mode only |
||||
* |
||||
* @param ctx an AVCAST5 context |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @param count number of 8 byte blocks |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_cast5_crypt(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, int decrypt); |
||||
|
||||
/**
|
||||
* Encrypt or decrypt a buffer using a previously initialized context |
||||
* |
||||
* @param ctx an AVCAST5 context |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @param count number of 8 byte blocks |
||||
* @param iv initialization vector for CBC mode, NULL for ECB mode |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_cast5_crypt2(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); |
||||
/**
|
||||
* @} |
||||
*/ |
||||
#endif /* AVUTIL_CAST5_H */ |
||||
@ -0,0 +1,783 @@ |
||||
/*
|
||||
* Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
||||
* Copyright (c) 2008 Peter Ross |
||||
* |
||||
* 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_CHANNEL_LAYOUT_H |
||||
#define AVUTIL_CHANNEL_LAYOUT_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stdlib.h> |
||||
|
||||
#include "version.h" |
||||
#include "attributes.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavu_audio_channels |
||||
* Public libavutil channel layout APIs header. |
||||
*/ |
||||
|
||||
|
||||
/**
|
||||
* @defgroup lavu_audio_channels Audio channels |
||||
* @ingroup lavu_audio |
||||
* |
||||
* Audio channel layout utility functions |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
enum AVChannel { |
||||
///< Invalid channel index
|
||||
AV_CHAN_NONE = -1, |
||||
AV_CHAN_FRONT_LEFT, |
||||
AV_CHAN_FRONT_RIGHT, |
||||
AV_CHAN_FRONT_CENTER, |
||||
AV_CHAN_LOW_FREQUENCY, |
||||
AV_CHAN_BACK_LEFT, |
||||
AV_CHAN_BACK_RIGHT, |
||||
AV_CHAN_FRONT_LEFT_OF_CENTER, |
||||
AV_CHAN_FRONT_RIGHT_OF_CENTER, |
||||
AV_CHAN_BACK_CENTER, |
||||
AV_CHAN_SIDE_LEFT, |
||||
AV_CHAN_SIDE_RIGHT, |
||||
AV_CHAN_TOP_CENTER, |
||||
AV_CHAN_TOP_FRONT_LEFT, |
||||
AV_CHAN_TOP_FRONT_CENTER, |
||||
AV_CHAN_TOP_FRONT_RIGHT, |
||||
AV_CHAN_TOP_BACK_LEFT, |
||||
AV_CHAN_TOP_BACK_CENTER, |
||||
AV_CHAN_TOP_BACK_RIGHT, |
||||
/** Stereo downmix. */ |
||||
AV_CHAN_STEREO_LEFT = 29, |
||||
/** See above. */ |
||||
AV_CHAN_STEREO_RIGHT, |
||||
AV_CHAN_WIDE_LEFT, |
||||
AV_CHAN_WIDE_RIGHT, |
||||
AV_CHAN_SURROUND_DIRECT_LEFT, |
||||
AV_CHAN_SURROUND_DIRECT_RIGHT, |
||||
AV_CHAN_LOW_FREQUENCY_2, |
||||
AV_CHAN_TOP_SIDE_LEFT, |
||||
AV_CHAN_TOP_SIDE_RIGHT, |
||||
AV_CHAN_BOTTOM_FRONT_CENTER, |
||||
AV_CHAN_BOTTOM_FRONT_LEFT, |
||||
AV_CHAN_BOTTOM_FRONT_RIGHT, |
||||
|
||||
/** Channel is empty can be safely skipped. */ |
||||
AV_CHAN_UNUSED = 0x200, |
||||
|
||||
/** Channel contains data, but its position is unknown. */ |
||||
AV_CHAN_UNKNOWN = 0x300, |
||||
|
||||
/**
|
||||
* Range of channels between AV_CHAN_AMBISONIC_BASE and |
||||
* AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system. |
||||
* |
||||
* Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and |
||||
* AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is |
||||
* `<n> = <i> - AV_CHAN_AMBISONIC_BASE`. |
||||
* |
||||
* @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel |
||||
* orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels |
||||
* implicitly by their position in the stream. |
||||
*/ |
||||
AV_CHAN_AMBISONIC_BASE = 0x400, |
||||
// leave space for 1024 ids, which correspond to maximum order-32 harmonics,
|
||||
// which should be enough for the foreseeable use cases
|
||||
AV_CHAN_AMBISONIC_END = 0x7ff, |
||||
}; |
||||
|
||||
enum AVChannelOrder { |
||||
/**
|
||||
* Only the channel count is specified, without any further information |
||||
* about the channel order. |
||||
*/ |
||||
AV_CHANNEL_ORDER_UNSPEC, |
||||
/**
|
||||
* The native channel order, i.e. the channels are in the same order in |
||||
* which they are defined in the AVChannel enum. This supports up to 63 |
||||
* different channels. |
||||
*/ |
||||
AV_CHANNEL_ORDER_NATIVE, |
||||
/**
|
||||
* The channel order does not correspond to any other predefined order and |
||||
* is stored as an explicit map. For example, this could be used to support |
||||
* layouts with 64 or more channels, or with empty/skipped (AV_CHAN_SILENCE) |
||||
* channels at arbitrary positions. |
||||
*/ |
||||
AV_CHANNEL_ORDER_CUSTOM, |
||||
/**
|
||||
* The audio is represented as the decomposition of the sound field into |
||||
* spherical harmonics. Each channel corresponds to a single expansion |
||||
* component. Channels are ordered according to ACN (Ambisonic Channel |
||||
* Number). |
||||
* |
||||
* The channel with the index n in the stream contains the spherical |
||||
* harmonic of degree l and order m given by |
||||
* @code{.unparsed} |
||||
* l = floor(sqrt(n)), |
||||
* m = n - l * (l + 1). |
||||
* @endcode |
||||
* |
||||
* Conversely given a spherical harmonic of degree l and order m, the |
||||
* corresponding channel index n is given by |
||||
* @code{.unparsed} |
||||
* n = l * (l + 1) + m. |
||||
* @endcode |
||||
* |
||||
* Normalization is assumed to be SN3D (Schmidt Semi-Normalization) |
||||
* as defined in AmbiX format $ 2.1. |
||||
*/ |
||||
AV_CHANNEL_ORDER_AMBISONIC, |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* @defgroup channel_masks Audio channel masks |
||||
* |
||||
* A channel layout is a 64-bits integer with a bit set for every channel. |
||||
* The number of bits set must be equal to the number of channels. |
||||
* The value 0 means that the channel layout is not known. |
||||
* @note this data structure is not powerful enough to handle channels |
||||
* combinations that have the same channel multiple times, such as |
||||
* dual-mono. |
||||
* |
||||
* @{ |
||||
*/ |
||||
#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. |
||||
@deprecated channel order is now indicated in a special field in |
||||
AVChannelLayout |
||||
*/ |
||||
#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL |
||||
#endif |
||||
|
||||
/**
|
||||
* @} |
||||
* @defgroup channel_mask_c Audio channel layouts |
||||
* @{ |
||||
* */ |
||||
#define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER) |
||||
#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT) |
||||
#define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY) |
||||
#define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER) |
||||
#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) |
||||
#define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY) |
||||
#define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER) |
||||
#define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY) |
||||
#define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT) |
||||
#define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT) |
||||
#define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY) |
||||
#define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY) |
||||
#define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER) |
||||
#define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) |
||||
#define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER) |
||||
#define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) |
||||
#define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER) |
||||
#define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY) |
||||
#define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) |
||||
#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) |
||||
#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) |
||||
#define AV_CH_LAYOUT_7POINT1_TOP_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT) |
||||
#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_CUBE (AV_CH_LAYOUT_QUAD|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_HEXADECAGONAL (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT) |
||||
#define AV_CH_LAYOUT_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, |
||||
AV_MATRIX_ENCODING_DOLBY, |
||||
AV_MATRIX_ENCODING_DPLII, |
||||
AV_MATRIX_ENCODING_DPLIIX, |
||||
AV_MATRIX_ENCODING_DPLIIZ, |
||||
AV_MATRIX_ENCODING_DOLBYEX, |
||||
AV_MATRIX_ENCODING_DOLBYHEADPHONE, |
||||
AV_MATRIX_ENCODING_NB |
||||
}; |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* An AVChannelCustom defines a single channel within a custom order layout |
||||
* |
||||
* Unlike most structures in FFmpeg, sizeof(AVChannelCustom) is a part of the |
||||
* public ABI. |
||||
* |
||||
* No new fields may be added to it without a major version bump. |
||||
*/ |
||||
typedef struct AVChannelCustom { |
||||
enum AVChannel id; |
||||
char name[16]; |
||||
void *opaque; |
||||
} AVChannelCustom; |
||||
|
||||
/**
|
||||
* An AVChannelLayout holds information about the channel layout of audio data. |
||||
* |
||||
* A channel layout here is defined as a set of channels ordered in a specific |
||||
* way (unless the channel order is AV_CHANNEL_ORDER_UNSPEC, in which case an |
||||
* AVChannelLayout carries only the channel count). |
||||
* All orders may be treated as if they were AV_CHANNEL_ORDER_UNSPEC by |
||||
* ignoring everything but the channel count, as long as av_channel_layout_check() |
||||
* considers they are valid. |
||||
* |
||||
* Unlike most structures in FFmpeg, sizeof(AVChannelLayout) is a part of the |
||||
* public ABI and may be used by the caller. E.g. it may be allocated on stack |
||||
* or embedded in caller-defined structs. |
||||
* |
||||
* AVChannelLayout can be initialized as follows: |
||||
* - default initialization with {0}, followed by setting all used fields |
||||
* correctly; |
||||
* - by assigning one of the predefined AV_CHANNEL_LAYOUT_* initializers; |
||||
* - with a constructor function, such as av_channel_layout_default(), |
||||
* av_channel_layout_from_mask() or av_channel_layout_from_string(). |
||||
* |
||||
* The channel layout must be unitialized with av_channel_layout_uninit() |
||||
* |
||||
* Copying an AVChannelLayout via assigning is forbidden, |
||||
* av_channel_layout_copy() must be used instead (and its return value should |
||||
* be checked) |
||||
* |
||||
* No new fields may be added to it without a major version bump, except for |
||||
* new elements of the union fitting in sizeof(uint64_t). |
||||
*/ |
||||
typedef struct AVChannelLayout { |
||||
/**
|
||||
* Channel order used in this layout. |
||||
* This is a mandatory field. |
||||
*/ |
||||
enum AVChannelOrder order; |
||||
|
||||
/**
|
||||
* Number of channels in this layout. Mandatory field. |
||||
*/ |
||||
int nb_channels; |
||||
|
||||
/**
|
||||
* Details about which channels are present in this layout. |
||||
* For AV_CHANNEL_ORDER_UNSPEC, this field is undefined and must not be |
||||
* used. |
||||
*/ |
||||
union { |
||||
/**
|
||||
* This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used |
||||
* for AV_CHANNEL_ORDER_AMBISONIC to signal non-diegetic channels. |
||||
* It is a bitmask, where the position of each set bit means that the |
||||
* AVChannel with the corresponding value is present. |
||||
* |
||||
* I.e. when (mask & (1 << AV_CHAN_FOO)) is non-zero, then AV_CHAN_FOO |
||||
* is present in the layout. Otherwise it is not present. |
||||
* |
||||
* @note when a channel layout using a bitmask is constructed or |
||||
* modified manually (i.e. not using any of the av_channel_layout_* |
||||
* functions), the code doing it must ensure that the number of set bits |
||||
* is equal to nb_channels. |
||||
*/ |
||||
uint64_t mask; |
||||
/**
|
||||
* This member must be used when the channel order is |
||||
* AV_CHANNEL_ORDER_CUSTOM. It is a nb_channels-sized array, with each |
||||
* element signalling the presence of the AVChannel with the |
||||
* corresponding value in map[i].id. |
||||
* |
||||
* I.e. when map[i].id is equal to AV_CHAN_FOO, then AV_CH_FOO is the |
||||
* i-th channel in the audio data. |
||||
* |
||||
* When map[i].id is in the range between AV_CHAN_AMBISONIC_BASE and |
||||
* AV_CHAN_AMBISONIC_END (inclusive), the channel contains an ambisonic |
||||
* component with ACN index (as defined above) |
||||
* n = map[i].id - AV_CHAN_AMBISONIC_BASE. |
||||
* |
||||
* map[i].name may be filled with a 0-terminated string, in which case |
||||
* it will be used for the purpose of identifying the channel with the |
||||
* convenience functions below. Otherise it must be zeroed. |
||||
*/ |
||||
AVChannelCustom *map; |
||||
} u; |
||||
|
||||
/**
|
||||
* For some private data of the user. |
||||
*/ |
||||
void *opaque; |
||||
} AVChannelLayout; |
||||
|
||||
#define AV_CHANNEL_LAYOUT_MASK(nb, m) \ |
||||
{ .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = (nb), .u = { .mask = (m) }} |
||||
|
||||
/**
|
||||
* @name Common pre-defined channel layouts |
||||
* @{ |
||||
*/ |
||||
#define AV_CHANNEL_LAYOUT_MONO AV_CHANNEL_LAYOUT_MASK(1, AV_CH_LAYOUT_MONO) |
||||
#define AV_CHANNEL_LAYOUT_STEREO AV_CHANNEL_LAYOUT_MASK(2, AV_CH_LAYOUT_STEREO) |
||||
#define AV_CHANNEL_LAYOUT_2POINT1 AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_2POINT1) |
||||
#define AV_CHANNEL_LAYOUT_2_1 AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_2_1) |
||||
#define AV_CHANNEL_LAYOUT_SURROUND AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_SURROUND) |
||||
#define AV_CHANNEL_LAYOUT_3POINT1 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_3POINT1) |
||||
#define AV_CHANNEL_LAYOUT_4POINT0 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_4POINT0) |
||||
#define AV_CHANNEL_LAYOUT_4POINT1 AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_4POINT1) |
||||
#define AV_CHANNEL_LAYOUT_2_2 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_2_2) |
||||
#define AV_CHANNEL_LAYOUT_QUAD AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_QUAD) |
||||
#define AV_CHANNEL_LAYOUT_5POINT0 AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_5POINT0) |
||||
#define AV_CHANNEL_LAYOUT_5POINT1 AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_5POINT1) |
||||
#define AV_CHANNEL_LAYOUT_5POINT0_BACK AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_5POINT0_BACK) |
||||
#define AV_CHANNEL_LAYOUT_5POINT1_BACK AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_5POINT1_BACK) |
||||
#define AV_CHANNEL_LAYOUT_6POINT0 AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_6POINT0) |
||||
#define AV_CHANNEL_LAYOUT_6POINT0_FRONT AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_6POINT0_FRONT) |
||||
#define AV_CHANNEL_LAYOUT_HEXAGONAL AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_HEXAGONAL) |
||||
#define AV_CHANNEL_LAYOUT_6POINT1 AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1) |
||||
#define AV_CHANNEL_LAYOUT_6POINT1_BACK AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1_BACK) |
||||
#define AV_CHANNEL_LAYOUT_6POINT1_FRONT AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1_FRONT) |
||||
#define AV_CHANNEL_LAYOUT_7POINT0 AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_7POINT0) |
||||
#define AV_CHANNEL_LAYOUT_7POINT0_FRONT AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_7POINT0_FRONT) |
||||
#define AV_CHANNEL_LAYOUT_7POINT1 AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1) |
||||
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_WIDE) |
||||
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_WIDE_BACK) |
||||
#define AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_TOP_BACK) |
||||
#define AV_CHANNEL_LAYOUT_OCTAGONAL AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_OCTAGONAL) |
||||
#define AV_CHANNEL_LAYOUT_CUBE AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_CUBE) |
||||
#define AV_CHANNEL_LAYOUT_HEXADECAGONAL AV_CHANNEL_LAYOUT_MASK(16, AV_CH_LAYOUT_HEXADECAGONAL) |
||||
#define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX AV_CHANNEL_LAYOUT_MASK(2, AV_CH_LAYOUT_STEREO_DOWNMIX) |
||||
#define AV_CHANNEL_LAYOUT_22POINT2 AV_CHANNEL_LAYOUT_MASK(24, AV_CH_LAYOUT_22POINT2) |
||||
#define AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER \ |
||||
{ .order = AV_CHANNEL_ORDER_AMBISONIC, .nb_channels = 4, .u = { .mask = 0 }} |
||||
/** @} */ |
||||
|
||||
struct AVBPrint; |
||||
|
||||
#if FF_API_OLD_CHANNEL_LAYOUT |
||||
/**
|
||||
* @name Deprecated Functions |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Return a channel layout id that matches name, or 0 if no match is found. |
||||
* |
||||
* name can be one or several of the following notations, |
||||
* separated by '+' or '|': |
||||
* - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0, |
||||
* 5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix); |
||||
* - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC, |
||||
* SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR); |
||||
* - a number of channels, in decimal, followed by 'c', yielding |
||||
* the default channel layout for that number of channels (@see |
||||
* av_get_default_channel_layout); |
||||
* - a channel layout mask, in hexadecimal starting with "0x" (see the |
||||
* 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); |
||||
|
||||
/**
|
||||
* Return a channel layout and the number of channels based on the specified name. |
||||
* |
||||
* This function is similar to (@see av_get_channel_layout), but can also parse |
||||
* unknown channel layout specifications. |
||||
* |
||||
* @param[in] name channel layout specification string |
||||
* @param[out] channel_layout parsed channel layout (0 if unknown) |
||||
* @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); |
||||
|
||||
/**
|
||||
* Return a description of a channel layout. |
||||
* If nb_channels is <= 0, it is guessed from the channel_layout. |
||||
* |
||||
* @param buf put here the string containing the channel layout |
||||
* @param buf_size size in bytes of the buffer |
||||
* @param nb_channels number of channels |
||||
* @param channel_layout channel layout bitset |
||||
* @deprecated use av_channel_layout_describe() |
||||
*/ |
||||
attribute_deprecated |
||||
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout); |
||||
|
||||
/**
|
||||
* 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); |
||||
|
||||
/**
|
||||
* Get the index of a channel in channel_layout. |
||||
* |
||||
* @param channel_layout channel layout bitset |
||||
* @param channel a channel layout describing exactly one channel which must be |
||||
* present in channel_layout. |
||||
* |
||||
* @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); |
||||
|
||||
/**
|
||||
* Get the description of a given 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); |
||||
|
||||
/**
|
||||
* Get the value and name of a standard channel layout. |
||||
* |
||||
* @param[in] index index in an internal list, starting at 0 |
||||
* @param[out] layout channel layout mask |
||||
* @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. |
||||
* @param channel the AVChannel whose name to get |
||||
* @return amount of bytes needed to hold the output string, or a negative AVERROR |
||||
* on failure. If the returned value is bigger than buf_size, then the |
||||
* string was truncated. |
||||
*/ |
||||
int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel); |
||||
|
||||
/**
|
||||
* bprint variant of av_channel_name(). |
||||
* |
||||
* @note the string will be appended to the bprint buffer. |
||||
*/ |
||||
void av_channel_name_bprint(struct AVBPrint *bp, enum AVChannel channel_id); |
||||
|
||||
/**
|
||||
* Get a human readable string describing a given channel. |
||||
* |
||||
* @param buf pre-allocated buffer where to put the generated string |
||||
* @param buf_size size in bytes of the buffer. |
||||
* @param channel the AVChannel whose description to get |
||||
* @return amount of bytes needed to hold the output string, or a negative AVERROR |
||||
* on failure. If the returned value is bigger than buf_size, then the |
||||
* string was truncated. |
||||
*/ |
||||
int av_channel_description(char *buf, size_t buf_size, enum AVChannel channel); |
||||
|
||||
/**
|
||||
* bprint variant of av_channel_description(). |
||||
* |
||||
* @note the string will be appended to the bprint buffer. |
||||
*/ |
||||
void av_channel_description_bprint(struct AVBPrint *bp, enum AVChannel channel_id); |
||||
|
||||
/**
|
||||
* This is the inverse function of @ref av_channel_name(). |
||||
* |
||||
* @return the channel with the given name |
||||
* AV_CHAN_NONE when name does not identify a known channel |
||||
*/ |
||||
enum AVChannel av_channel_from_string(const char *name); |
||||
|
||||
/**
|
||||
* Initialize a native channel layout from a bitmask indicating which channels |
||||
* are present. |
||||
* |
||||
* @param channel_layout the layout structure to be initialized |
||||
* @param mask bitmask describing the channel layout |
||||
* |
||||
* @return 0 on success |
||||
* AVERROR(EINVAL) for invalid mask values |
||||
*/ |
||||
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask); |
||||
|
||||
/**
|
||||
* Initialize a channel layout from a given string description. |
||||
* The input string can be represented by: |
||||
* - the formal channel layout name (returned by av_channel_layout_describe()) |
||||
* - single or multiple channel names (returned by av_channel_name(), eg. "FL", |
||||
* or concatenated with "+", each optionally containing a custom name after |
||||
* a "@", eg. "FL@Left+FR@Right+LFE") |
||||
* - a decimal or hexadecimal value of a native channel layout (eg. "4" or "0x4") |
||||
* - the number of channels with default layout (eg. "4c") |
||||
* - the number of unordered channels (eg. "4C" or "4 channels") |
||||
* - the ambisonic order followed by optional non-diegetic channels (eg. |
||||
* "ambisonic 2+stereo") |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @param str string describing the channel layout |
||||
* @return 0 channel layout was detected, AVERROR_INVALIDATATA otherwise |
||||
*/ |
||||
int av_channel_layout_from_string(AVChannelLayout *channel_layout, |
||||
const char *str); |
||||
|
||||
/**
|
||||
* Get the default channel layout for a given number of channels. |
||||
* |
||||
* @param ch_layout the layout structure to be initialized |
||||
* @param nb_channels number of channels |
||||
*/ |
||||
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels); |
||||
|
||||
/**
|
||||
* Iterate over all standard channel layouts. |
||||
* |
||||
* @param opaque a pointer where libavutil will store the iteration state. Must |
||||
* point to NULL to start the iteration. |
||||
* |
||||
* @return the standard channel layout or NULL when the iteration is |
||||
* finished |
||||
*/ |
||||
const AVChannelLayout *av_channel_layout_standard(void **opaque); |
||||
|
||||
/**
|
||||
* Free any allocated data in the channel layout and reset the channel |
||||
* count to 0. |
||||
* |
||||
* @param channel_layout the layout structure to be uninitialized |
||||
*/ |
||||
void av_channel_layout_uninit(AVChannelLayout *channel_layout); |
||||
|
||||
/**
|
||||
* Make a copy of a channel layout. This differs from just assigning src to dst |
||||
* in that it allocates and copies the map for AV_CHANNEL_ORDER_CUSTOM. |
||||
* |
||||
* @note the destination channel_layout will be always uninitialized before copy. |
||||
* |
||||
* @param dst destination channel layout |
||||
* @param src source channel layout |
||||
* @return 0 on success, a negative AVERROR on error. |
||||
*/ |
||||
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src); |
||||
|
||||
/**
|
||||
* Get a human-readable string describing the channel layout properties. |
||||
* The string will be in the same format that is accepted by |
||||
* @ref av_channel_layout_from_string(), allowing to rebuild the same |
||||
* channel layout, except for opaque pointers. |
||||
* |
||||
* @param channel_layout channel layout to be described |
||||
* @param buf pre-allocated buffer where to put the generated string |
||||
* @param buf_size size in bytes of the buffer. |
||||
* @return amount of bytes needed to hold the output string, or a negative AVERROR |
||||
* on failure. If the returned value is bigger than buf_size, then the |
||||
* string was truncated. |
||||
*/ |
||||
int av_channel_layout_describe(const AVChannelLayout *channel_layout, |
||||
char *buf, size_t buf_size); |
||||
|
||||
/**
|
||||
* bprint variant of av_channel_layout_describe(). |
||||
* |
||||
* @note the string will be appended to the bprint buffer. |
||||
* @return 0 on success, or a negative AVERROR value on failure. |
||||
*/ |
||||
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, |
||||
struct AVBPrint *bp); |
||||
|
||||
/**
|
||||
* Get the channel with the given index in a channel layout. |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @param idx index of the channel |
||||
* @return channel with the index idx in channel_layout on success or |
||||
* AV_CHAN_NONE on failure (if idx is not valid or the channel order is |
||||
* unspecified) |
||||
*/ |
||||
enum AVChannel |
||||
av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx); |
||||
|
||||
/**
|
||||
* Get the index of a given channel in a channel layout. In case multiple |
||||
* channels are found, only the first match will be returned. |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @param channel the channel whose index to obtain |
||||
* @return index of channel in channel_layout on success or a negative number if |
||||
* channel is not present in channel_layout. |
||||
*/ |
||||
int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout, |
||||
enum AVChannel channel); |
||||
|
||||
/**
|
||||
* Get the index in a channel layout of a channel described by the given string. |
||||
* In case multiple channels are found, only the first match will be returned. |
||||
* |
||||
* This function accepts channel names in the same format as |
||||
* @ref av_channel_from_string(). |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @param name string describing the channel whose index to obtain |
||||
* @return a channel index described by the given string, or a negative AVERROR |
||||
* value. |
||||
*/ |
||||
int av_channel_layout_index_from_string(const AVChannelLayout *channel_layout, |
||||
const char *name); |
||||
|
||||
/**
|
||||
* Get a channel described by the given string. |
||||
* |
||||
* This function accepts channel names in the same format as |
||||
* @ref av_channel_from_string(). |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @param name string describing the channel to obtain |
||||
* @return a channel described by the given string in channel_layout on success |
||||
* or AV_CHAN_NONE on failure (if the string is not valid or the channel |
||||
* order is unspecified) |
||||
*/ |
||||
enum AVChannel |
||||
av_channel_layout_channel_from_string(const AVChannelLayout *channel_layout, |
||||
const char *name); |
||||
|
||||
/**
|
||||
* Find out what channels from a given set are present in a channel layout, |
||||
* without regard for their positions. |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @param mask a combination of AV_CH_* representing a set of channels |
||||
* @return a bitfield representing all the channels from mask that are present |
||||
* in channel_layout |
||||
*/ |
||||
uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout, |
||||
uint64_t mask); |
||||
|
||||
/**
|
||||
* Check whether a channel layout is valid, i.e. can possibly describe audio |
||||
* data. |
||||
* |
||||
* @param channel_layout input channel layout |
||||
* @return 1 if channel_layout is valid, 0 otherwise. |
||||
*/ |
||||
int av_channel_layout_check(const AVChannelLayout *channel_layout); |
||||
|
||||
/**
|
||||
* Check whether two channel layouts are semantically the same, i.e. the same |
||||
* channels are present on the same positions in both. |
||||
* |
||||
* If one of the channel layouts is AV_CHANNEL_ORDER_UNSPEC, while the other is |
||||
* not, they are considered to be unequal. If both are AV_CHANNEL_ORDER_UNSPEC, |
||||
* they are considered equal iff the channel counts are the same in both. |
||||
* |
||||
* @param chl input channel layout |
||||
* @param chl1 input channel layout |
||||
* @return 0 if chl and chl1 are equal, 1 if they are not equal. A negative |
||||
* AVERROR code if one or both are invalid. |
||||
*/ |
||||
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_CHANNEL_LAYOUT_H */ |
||||
@ -0,0 +1,578 @@ |
||||
/*
|
||||
* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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 |
||||
* common internal and external API header |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_COMMON_H |
||||
#define AVUTIL_COMMON_H |
||||
|
||||
#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) && !defined(UINT64_C) |
||||
#error missing -D__STDC_CONSTANT_MACROS / #define __STDC_CONSTANT_MACROS |
||||
#endif |
||||
|
||||
#include <errno.h> |
||||
#include <inttypes.h> |
||||
#include <limits.h> |
||||
#include <math.h> |
||||
#include <stdint.h> |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "macros.h" |
||||
|
||||
//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)) |
||||
/* 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)) |
||||
/* Backwards compat. */ |
||||
#define FF_CEIL_RSHIFT AV_CEIL_RSHIFT |
||||
|
||||
#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b)) |
||||
#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b)) |
||||
|
||||
/**
|
||||
* Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they |
||||
* are not representable as absolute values of their type. This is the same |
||||
* as with *abs() |
||||
* @see FFNABS() |
||||
*/ |
||||
#define FFABS(a) ((a) >= 0 ? (a) : (-(a))) |
||||
#define FFSIGN(a) ((a) > 0 ? 1 : -1) |
||||
|
||||
/**
|
||||
* Negative Absolute value. |
||||
* this works for all integers of all types. |
||||
* As with many macros, this evaluates its argument twice, it thus must not have |
||||
* a sideeffect, that is FFNABS(x++) has undefined behavior. |
||||
*/ |
||||
#define FFNABS(a) ((a) <= 0 ? (a) : (-(a))) |
||||
|
||||
/**
|
||||
* 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 FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a)) |
||||
#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a)) |
||||
|
||||
/* misc math functions */ |
||||
|
||||
#ifdef HAVE_AV_CONFIG_H |
||||
# include "config.h" |
||||
# include "intmath.h" |
||||
#endif |
||||
|
||||
#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); |
||||
#endif |
||||
|
||||
#ifndef av_log2_16bit |
||||
av_const int av_log2_16bit(unsigned v); |
||||
#endif |
||||
|
||||
/**
|
||||
* Clip a signed integer value into the amin-amax range. |
||||
* @param a value to clip |
||||
* @param amin minimum value of the clip range |
||||
* @param amax maximum value of the clip range |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const int av_clip_c(int a, int amin, int amax) |
||||
{ |
||||
#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; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed 64bit integer value into the amin-amax range. |
||||
* @param a value to clip |
||||
* @param amin minimum value of the clip range |
||||
* @param amax maximum value of the clip range |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax) |
||||
{ |
||||
#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; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed integer value into the 0-255 range. |
||||
* @param a value to clip |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const uint8_t av_clip_uint8_c(int a) |
||||
{ |
||||
if (a&(~0xFF)) return (~a)>>31; |
||||
else return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed integer value into the -128,127 range. |
||||
* @param a value to clip |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const int8_t av_clip_int8_c(int a) |
||||
{ |
||||
if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F; |
||||
else return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed integer value into the 0-65535 range. |
||||
* @param a value to clip |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const uint16_t av_clip_uint16_c(int a) |
||||
{ |
||||
if (a&(~0xFFFF)) return (~a)>>31; |
||||
else return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed integer value into the -32768,32767 range. |
||||
* @param a value to clip |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const int16_t av_clip_int16_c(int a) |
||||
{ |
||||
if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF; |
||||
else return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed 64-bit integer value into the -2147483648,2147483647 range. |
||||
* @param a value to clip |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a) |
||||
{ |
||||
if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF); |
||||
else return (int32_t)a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed integer into the -(2^p),(2^p-1) range. |
||||
* @param a value to clip |
||||
* @param p bit position to clip at |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const int av_clip_intp2_c(int a, int p) |
||||
{ |
||||
if (((unsigned)a + (1 << p)) & ~((2 << p) - 1)) |
||||
return (a >> 31) ^ ((1 << p) - 1); |
||||
else |
||||
return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a signed integer to an unsigned power of two range. |
||||
* @param a value to clip |
||||
* @param p bit position to clip at |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p) |
||||
{ |
||||
if (a & ~((1<<p) - 1)) return (~a) >> 31 & ((1<<p) - 1); |
||||
else return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clear high bits from an unsigned integer starting with specific bit position |
||||
* @param a value to clip |
||||
* @param p bit position to clip at |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p) |
||||
{ |
||||
return a & ((1U << p) - 1); |
||||
} |
||||
|
||||
/**
|
||||
* Add two signed 32-bit values with saturation. |
||||
* |
||||
* @param a one value |
||||
* @param b another value |
||||
* @return sum with signed saturation |
||||
*/ |
||||
static av_always_inline int av_sat_add32_c(int a, int b) |
||||
{ |
||||
return av_clipl_int32((int64_t)a + b); |
||||
} |
||||
|
||||
/**
|
||||
* Add a doubled value to another value with saturation at both stages. |
||||
* |
||||
* @param a first value |
||||
* @param b value doubled and added to a |
||||
* @return sum sat(a + sat(2*b)) with signed saturation |
||||
*/ |
||||
static av_always_inline int av_sat_dadd32_c(int a, int b) |
||||
{ |
||||
return av_sat_add32(a, av_sat_add32(b, b)); |
||||
} |
||||
|
||||
/**
|
||||
* Subtract two signed 32-bit values with saturation. |
||||
* |
||||
* @param a one value |
||||
* @param b another value |
||||
* @return difference with signed saturation |
||||
*/ |
||||
static av_always_inline int av_sat_sub32_c(int a, int b) |
||||
{ |
||||
return av_clipl_int32((int64_t)a - b); |
||||
} |
||||
|
||||
/**
|
||||
* Subtract a doubled value from another value with saturation at both stages. |
||||
* |
||||
* @param a first value |
||||
* @param b value doubled and subtracted from a |
||||
* @return difference sat(a - sat(2*b)) with signed saturation |
||||
*/ |
||||
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 |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const float av_clipf_c(float a, float amin, float amax) |
||||
{ |
||||
#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 |
||||
if (amin > amax) abort(); |
||||
#endif |
||||
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 |
||||
* @return clipped value |
||||
*/ |
||||
static av_always_inline av_const double av_clipd_c(double a, double amin, double amax) |
||||
{ |
||||
#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 |
||||
if (amin > amax) abort(); |
||||
#endif |
||||
return FFMIN(FFMAX(a, amin), amax); |
||||
} |
||||
|
||||
/** Compute ceil(log2(x)).
|
||||
* @param x value used to compute ceil(log2(x)) |
||||
* @return computed ceiling of log2(x) |
||||
*/ |
||||
static av_always_inline av_const int av_ceil_log2_c(int x) |
||||
{ |
||||
return av_log2((x - 1U) << 1); |
||||
} |
||||
|
||||
/**
|
||||
* Count number of bits set to one in x |
||||
* @param x value to count bits of |
||||
* @return the number of bits set to one in x |
||||
*/ |
||||
static av_always_inline av_const int av_popcount_c(uint32_t x) |
||||
{ |
||||
x -= (x >> 1) & 0x55555555; |
||||
x = (x & 0x33333333) + ((x >> 2) & 0x33333333); |
||||
x = (x + (x >> 4)) & 0x0F0F0F0F; |
||||
x += x >> 8; |
||||
return (x + (x >> 16)) & 0x3F; |
||||
} |
||||
|
||||
/**
|
||||
* Count number of bits set to one in x |
||||
* @param x value to count bits of |
||||
* @return the number of bits set to one in x |
||||
*/ |
||||
static av_always_inline av_const int av_popcount64_c(uint64_t x) |
||||
{ |
||||
return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32)); |
||||
} |
||||
|
||||
static av_always_inline av_const int av_parity_c(uint32_t v) |
||||
{ |
||||
return av_popcount(v) & 1; |
||||
} |
||||
|
||||
/**
|
||||
* Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form. |
||||
* |
||||
* @param val Output value, must be an lvalue of type uint32_t. |
||||
* @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++, 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. |
||||
* |
||||
* @warning ERROR should not contain a loop control statement which |
||||
* could interact with the internal while loop, and should force an |
||||
* exit from the macro code (e.g. through a goto or a return) in order |
||||
* to prevent undefined results. |
||||
*/ |
||||
#define GET_UTF8(val, GET_BYTE, ERROR)\ |
||||
val= (GET_BYTE);\
|
||||
{\
|
||||
uint32_t top = (val & 128) >> 1;\
|
||||
if ((val & 0xc0) == 0x80 || val >= 0xFE)\
|
||||
{ERROR}\
|
||||
while (val & top) {\
|
||||
unsigned int tmp = (GET_BYTE) - 128;\
|
||||
if(tmp>>6)\
|
||||
{ERROR}\
|
||||
val= (val<<6) + tmp;\
|
||||
top <<= 5;\
|
||||
}\
|
||||
val &= (top << 1) - 1;\
|
||||
} |
||||
|
||||
/**
|
||||
* Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form. |
||||
* |
||||
* @param val Output value, must be an lvalue of type uint32_t. |
||||
* @param GET_16BIT Expression returning two bytes of UTF-16 data converted |
||||
* to native byte order. Evaluated one or two times. |
||||
* @param ERROR Expression to be evaluated on invalid input, |
||||
* typically a goto statement. |
||||
*/ |
||||
#define GET_UTF16(val, GET_16BIT, ERROR)\ |
||||
val = (GET_16BIT);\
|
||||
{\
|
||||
unsigned int hi = val - 0xD800;\
|
||||
if (hi < 0x800) {\
|
||||
val = (GET_16BIT) - 0xDC00;\
|
||||
if (val > 0x3FFU || hi > 0x3FFU)\
|
||||
{ERROR}\
|
||||
val += (hi<<10) + 0x10000;\
|
||||
}\
|
||||
}\
|
||||
|
||||
/**
|
||||
* @def PUT_UTF8(val, tmp, PUT_BYTE) |
||||
* Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long). |
||||
* @param val is an input-only argument and should be of type uint32_t. It holds |
||||
* a UCS-4 encoded Unicode character that is to be converted to UTF-8. If |
||||
* val is given as a function it is executed only once. |
||||
* @param tmp is a temporary variable and should be of type uint8_t. It |
||||
* represents an intermediate value during conversion that is to be |
||||
* output by PUT_BYTE. |
||||
* @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination. |
||||
* It could be a function or a statement, and uses tmp as the input byte. |
||||
* For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be |
||||
* executed up to 4 times for values in the valid UTF-8 range and up to |
||||
* 7 times in the general case, depending on the length of the converted |
||||
* Unicode character. |
||||
*/ |
||||
#define PUT_UTF8(val, tmp, PUT_BYTE)\ |
||||
{\
|
||||
int bytes, shift;\
|
||||
uint32_t in = val;\
|
||||
if (in < 0x80) {\
|
||||
tmp = in;\
|
||||
PUT_BYTE\
|
||||
} else {\
|
||||
bytes = (av_log2(in) + 4) / 5;\
|
||||
shift = (bytes - 1) * 6;\
|
||||
tmp = (256 - (256 >> bytes)) | (in >> shift);\
|
||||
PUT_BYTE\
|
||||
while (shift >= 6) {\
|
||||
shift -= 6;\
|
||||
tmp = 0x80 | ((in >> shift) & 0x3f);\
|
||||
PUT_BYTE\
|
||||
}\
|
||||
}\
|
||||
} |
||||
|
||||
/**
|
||||
* @def PUT_UTF16(val, tmp, PUT_16BIT) |
||||
* Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes). |
||||
* @param val is an input-only argument and should be of type uint32_t. It holds |
||||
* a UCS-4 encoded Unicode character that is to be converted to UTF-16. If |
||||
* val is given as a function it is executed only once. |
||||
* @param tmp is a temporary variable and should be of type uint16_t. It |
||||
* represents an intermediate value during conversion that is to be |
||||
* output by PUT_16BIT. |
||||
* @param PUT_16BIT writes the converted UTF-16 data to any proper destination |
||||
* in desired endianness. It could be a function or a statement, and uses tmp |
||||
* as the input byte. For example, PUT_BYTE could be "*output++ = tmp;" |
||||
* PUT_BYTE will be executed 1 or 2 times depending on input character. |
||||
*/ |
||||
#define PUT_UTF16(val, tmp, PUT_16BIT)\ |
||||
{\
|
||||
uint32_t in = val;\
|
||||
if (in < 0x10000) {\
|
||||
tmp = in;\
|
||||
PUT_16BIT\
|
||||
} else {\
|
||||
tmp = 0xD800 | ((in - 0x10000) >> 10);\
|
||||
PUT_16BIT\
|
||||
tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
|
||||
PUT_16BIT\
|
||||
}\
|
||||
}\
|
||||
|
||||
|
||||
|
||||
#include "mem.h" |
||||
|
||||
#ifdef HAVE_AV_CONFIG_H |
||||
# include "internal.h" |
||||
#endif /* HAVE_AV_CONFIG_H */ |
||||
|
||||
#endif /* AVUTIL_COMMON_H */ |
||||
@ -0,0 +1,134 @@ |
||||
/*
|
||||
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard |
||||
* |
||||
* 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_CPU_H |
||||
#define AVUTIL_CPU_H |
||||
|
||||
#include <stddef.h> |
||||
|
||||
#define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */ |
||||
|
||||
/* lower 16 bits - CPU features */ |
||||
#define AV_CPU_FLAG_MMX 0x0001 ///< standard MMX
|
||||
#define AV_CPU_FLAG_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext
|
||||
#define AV_CPU_FLAG_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext
|
||||
#define AV_CPU_FLAG_3DNOW 0x0004 ///< AMD 3DNOW
|
||||
#define AV_CPU_FLAG_SSE 0x0008 ///< SSE functions
|
||||
#define AV_CPU_FLAG_SSE2 0x0010 ///< PIV SSE2 functions
|
||||
#define AV_CPU_FLAG_SSE2SLOW 0x40000000 ///< SSE2 supported, but usually not faster
|
||||
///< than regular MMX/SSE (e.g. Core1)
|
||||
#define AV_CPU_FLAG_3DNOWEXT 0x0020 ///< AMD 3DNowExt
|
||||
#define AV_CPU_FLAG_SSE3 0x0040 ///< Prescott SSE3 functions
|
||||
#define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster
|
||||
///< than regular MMX/SSE (e.g. Core1)
|
||||
#define AV_CPU_FLAG_SSSE3 0x0080 ///< Conroe SSSE3 functions
|
||||
#define AV_CPU_FLAG_SSSE3SLOW 0x4000000 ///< SSSE3 supported, but usually not faster
|
||||
#define AV_CPU_FLAG_ATOM 0x10000000 ///< Atom processor, some SSSE3 instructions are slower
|
||||
#define AV_CPU_FLAG_SSE4 0x0100 ///< Penryn SSE4.1 functions
|
||||
#define AV_CPU_FLAG_SSE42 0x0200 ///< Nehalem SSE4.2 functions
|
||||
#define AV_CPU_FLAG_AESNI 0x80000 ///< Advanced Encryption Standard functions
|
||||
#define AV_CPU_FLAG_AVX 0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used
|
||||
#define AV_CPU_FLAG_AVXSLOW 0x8000000 ///< AVX supported, but slow when using YMM registers (e.g. Bulldozer)
|
||||
#define AV_CPU_FLAG_XOP 0x0400 ///< Bulldozer XOP functions
|
||||
#define AV_CPU_FLAG_FMA4 0x0800 ///< Bulldozer FMA4 functions
|
||||
#define AV_CPU_FLAG_CMOV 0x1000 ///< supports cmov instruction
|
||||
#define AV_CPU_FLAG_AVX2 0x8000 ///< AVX2 functions: requires OS support even if YMM registers aren't used
|
||||
#define AV_CPU_FLAG_FMA3 0x10000 ///< Haswell FMA3 functions
|
||||
#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
|
||||
#define AV_CPU_FLAG_POWER8 0x0004 ///< ISA 2.07
|
||||
|
||||
#define AV_CPU_FLAG_ARMV5TE (1 << 0) |
||||
#define AV_CPU_FLAG_ARMV6 (1 << 1) |
||||
#define AV_CPU_FLAG_ARMV6T2 (1 << 2) |
||||
#define AV_CPU_FLAG_VFP (1 << 3) |
||||
#define AV_CPU_FLAG_VFPV3 (1 << 4) |
||||
#define AV_CPU_FLAG_NEON (1 << 5) |
||||
#define AV_CPU_FLAG_ARMV8 (1 << 6) |
||||
#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) |
||||
|
||||
// RISC-V extensions
|
||||
#define AV_CPU_FLAG_RVI (1 << 0) ///< I (full GPR bank)
|
||||
#define AV_CPU_FLAG_RVF (1 << 1) ///< F (single precision FP)
|
||||
#define AV_CPU_FLAG_RVD (1 << 2) ///< D (double precision FP)
|
||||
#define AV_CPU_FLAG_RVV_I32 (1 << 3) ///< Vectors of 8/16/32-bit int's */
|
||||
#define AV_CPU_FLAG_RVV_F32 (1 << 4) ///< Vectors of float's */
|
||||
#define AV_CPU_FLAG_RVV_I64 (1 << 5) ///< Vectors of 64-bit int's */
|
||||
#define AV_CPU_FLAG_RVV_F64 (1 << 6) ///< Vectors of double's
|
||||
#define AV_CPU_FLAG_RVB_BASIC (1 << 7) ///< Basic bit-manipulations
|
||||
|
||||
/**
|
||||
* Return the flags which specify extensions supported by the CPU. |
||||
* The returned value is affected by av_force_cpu_flags() if that was used |
||||
* before. So av_get_cpu_flags() can easily be used in an application to |
||||
* detect the enabled cpu flags. |
||||
*/ |
||||
int av_get_cpu_flags(void); |
||||
|
||||
/**
|
||||
* Disables cpu detection and forces the specified flags. |
||||
* -1 is a special case that disables forcing of specific flags. |
||||
*/ |
||||
void av_force_cpu_flags(int flags); |
||||
|
||||
/**
|
||||
* Parse CPU caps from a string and update the given AV_CPU_* flags based on that. |
||||
* |
||||
* @return negative on error. |
||||
*/ |
||||
int av_parse_cpu_caps(unsigned *flags, const char *s); |
||||
|
||||
/**
|
||||
* @return the number of logical CPU cores present. |
||||
*/ |
||||
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. |
||||
* |
||||
* Note that this is affected by the build configuration and the CPU flags mask, |
||||
* so e.g. if the CPU supports AVX, but libavutil has been built with |
||||
* --disable-avx or the AV_CPU_FLAG_AVX flag has been disabled through |
||||
* av_set_cpu_flags_mask(), then this function will behave as if AVX is not |
||||
* present. |
||||
*/ |
||||
size_t av_cpu_max_align(void); |
||||
|
||||
#endif /* AVUTIL_CPU_H */ |
||||
@ -0,0 +1,102 @@ |
||||
/*
|
||||
* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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 |
||||
* @ingroup lavu_crc32 |
||||
* Public header for CRC hash function implementation. |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_CRC_H |
||||
#define AVUTIL_CRC_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stddef.h> |
||||
#include "attributes.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_crc32 CRC |
||||
* @ingroup lavu_hash |
||||
* CRC (Cyclic Redundancy Check) hash function implementation. |
||||
* |
||||
* This module supports numerous CRC polynomials, in addition to the most |
||||
* widely used CRC-32-IEEE. See @ref AVCRCId for a list of available |
||||
* polynomials. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
typedef uint32_t AVCRC; |
||||
|
||||
typedef enum { |
||||
AV_CRC_8_ATM, |
||||
AV_CRC_16_ANSI, |
||||
AV_CRC_16_CCITT, |
||||
AV_CRC_32_IEEE, |
||||
AV_CRC_32_IEEE_LE, /*< reversed bitorder version of AV_CRC_32_IEEE */ |
||||
AV_CRC_16_ANSI_LE, /*< reversed bitorder version of AV_CRC_16_ANSI */ |
||||
AV_CRC_24_IEEE, |
||||
AV_CRC_8_EBU, |
||||
AV_CRC_MAX, /*< Not part of public API! Do not use outside libavutil. */ |
||||
}AVCRCId; |
||||
|
||||
/**
|
||||
* Initialize a CRC table. |
||||
* @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024 |
||||
* @param le If 1, the lowest bit represents the coefficient for the highest |
||||
* exponent of the corresponding polynomial (both for poly and |
||||
* actual CRC). |
||||
* If 0, you must swap the CRC parameter and the result of av_crc |
||||
* if you need the standard representation (can be simplified in |
||||
* most cases to e.g. bswap16): |
||||
* av_bswap32(crc << (32-bits)) |
||||
* @param bits number of bits for the CRC |
||||
* @param poly generator polynomial without the x**bits coefficient, in the |
||||
* representation as specified by le |
||||
* @param ctx_size size of ctx in bytes |
||||
* @return <0 on failure |
||||
*/ |
||||
int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size); |
||||
|
||||
/**
|
||||
* Get an initialized standard CRC table. |
||||
* @param crc_id ID of a standard CRC |
||||
* @return a pointer to the CRC table or NULL on failure |
||||
*/ |
||||
const AVCRC *av_crc_get_table(AVCRCId crc_id); |
||||
|
||||
/**
|
||||
* Calculate the CRC of a block. |
||||
* @param ctx initialized AVCRC array (see av_crc_init()) |
||||
* @param crc CRC of previous blocks if any or initial value for CRC |
||||
* @param buffer buffer whose CRC to calculate |
||||
* @param length length of the buffer |
||||
* @return CRC updated with the data from the given block |
||||
* |
||||
* @see av_crc_init() "le" parameter |
||||
*/ |
||||
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, |
||||
const uint8_t *buffer, size_t length) av_pure; |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_CRC_H */ |
||||
@ -0,0 +1,150 @@ |
||||
/*
|
||||
* Copyright (c) 2015 Kevin Wheatley <kevin.j.wheatley@gmail.com> |
||||
* Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com> |
||||
* Copyright (c) 2023 Leo Izen <leo.izen@gmail.com> |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_CSP_H |
||||
#define AVUTIL_CSP_H |
||||
|
||||
#include "pixfmt.h" |
||||
#include "rational.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* Colorspace value utility functions for libavutil. |
||||
* @ingroup lavu_math_csp |
||||
* @author Ronald S. Bultje <rsbultje@gmail.com> |
||||
* @author Leo Izen <leo.izen@gmail.com> |
||||
* @author Kevin Wheatley <kevin.j.wheatley@gmail.com> |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavu_math_csp Colorspace Utility |
||||
* @ingroup lavu_math |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Struct containing luma coefficients to be used for RGB to YUV/YCoCg, or similar |
||||
* calculations. |
||||
*/ |
||||
typedef struct AVLumaCoefficients { |
||||
AVRational cr, cg, cb; |
||||
} AVLumaCoefficients; |
||||
|
||||
/**
|
||||
* Struct containing chromaticity x and y values for the standard CIE 1931 |
||||
* chromaticity definition. |
||||
*/ |
||||
typedef struct AVCIExy { |
||||
AVRational x, y; |
||||
} AVCIExy; |
||||
|
||||
/**
|
||||
* Struct defining the red, green, and blue primary locations in terms of CIE |
||||
* 1931 chromaticity x and y. |
||||
*/ |
||||
typedef struct AVPrimaryCoefficients { |
||||
AVCIExy r, g, b; |
||||
} AVPrimaryCoefficients; |
||||
|
||||
/**
|
||||
* Struct defining white point location in terms of CIE 1931 chromaticity x |
||||
* and y. |
||||
*/ |
||||
typedef AVCIExy AVWhitepointCoefficients; |
||||
|
||||
/**
|
||||
* Struct that contains both white point location and primaries location, providing |
||||
* the complete description of a color gamut. |
||||
*/ |
||||
typedef struct AVColorPrimariesDesc { |
||||
AVWhitepointCoefficients wp; |
||||
AVPrimaryCoefficients prim; |
||||
} AVColorPrimariesDesc; |
||||
|
||||
/**
|
||||
* Function pointer representing a double -> double transfer function that performs |
||||
* an EOTF transfer inversion. This function outputs linear light. |
||||
*/ |
||||
typedef double (*av_csp_trc_function)(double); |
||||
|
||||
/**
|
||||
* Retrieves the Luma coefficients necessary to construct a conversion matrix |
||||
* from an enum constant describing the colorspace. |
||||
* @param csp An enum constant indicating YUV or similar colorspace. |
||||
* @return The Luma coefficients associated with that colorspace, or NULL |
||||
* if the constant is unknown to libavutil. |
||||
*/ |
||||
const AVLumaCoefficients *av_csp_luma_coeffs_from_avcsp(enum AVColorSpace csp); |
||||
|
||||
/**
|
||||
* Retrieves a complete gamut description from an enum constant describing the |
||||
* color primaries. |
||||
* @param prm An enum constant indicating primaries |
||||
* @return A description of the colorspace gamut associated with that enum |
||||
* constant, or NULL if the constant is unknown to libavutil. |
||||
*/ |
||||
const AVColorPrimariesDesc *av_csp_primaries_desc_from_id(enum AVColorPrimaries prm); |
||||
|
||||
/**
|
||||
* Detects which enum AVColorPrimaries constant corresponds to the given complete |
||||
* gamut description. |
||||
* @see enum AVColorPrimaries |
||||
* @param prm A description of the colorspace gamut |
||||
* @return The enum constant associated with this gamut, or |
||||
* AVCOL_PRI_UNSPECIFIED if no clear match can be idenitified. |
||||
*/ |
||||
enum AVColorPrimaries av_csp_primaries_id_from_desc(const AVColorPrimariesDesc *prm); |
||||
|
||||
/**
|
||||
* Determine a suitable 'gamma' value to match the supplied |
||||
* AVColorTransferCharacteristic. |
||||
* |
||||
* See Apple Technical Note TN2257 (https://developer.apple.com/library/mac/technotes/tn2257/_index.html)
|
||||
* |
||||
* This function returns the gamma exponent for the OETF. For example, sRGB is approximated |
||||
* by gamma 2.2, not by gamma 0.45455. |
||||
* |
||||
* @return Will return an approximation to the simple gamma function matching |
||||
* the supplied Transfer Characteristic, Will return 0.0 for any |
||||
* we cannot reasonably match against. |
||||
*/ |
||||
double av_csp_approximate_trc_gamma(enum AVColorTransferCharacteristic trc); |
||||
|
||||
/**
|
||||
* Determine the function needed to apply the given |
||||
* AVColorTransferCharacteristic to linear input. |
||||
* |
||||
* The function returned should expect a nominal domain and range of [0.0-1.0] |
||||
* values outside of this range maybe valid depending on the chosen |
||||
* characteristic function. |
||||
* |
||||
* @return Will return pointer to the function matching the |
||||
* supplied Transfer Characteristic. If unspecified will |
||||
* return NULL: |
||||
*/ |
||||
av_csp_trc_function av_csp_trc_func_from_id(enum AVColorTransferCharacteristic trc); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_CSP_H */ |
||||
@ -0,0 +1,81 @@ |
||||
/*
|
||||
* DES encryption/decryption |
||||
* Copyright (c) 2007 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_DES_H |
||||
#define AVUTIL_DES_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @defgroup lavu_des DES |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
typedef struct AVDES { |
||||
uint64_t round_keys[3][16]; |
||||
int triple_des; |
||||
} AVDES; |
||||
|
||||
/**
|
||||
* Allocate an AVDES context. |
||||
*/ |
||||
AVDES *av_des_alloc(void); |
||||
|
||||
/**
|
||||
* @brief Initializes an AVDES context. |
||||
* |
||||
* @param d pointer to a AVDES structure to initialize |
||||
* @param key pointer to the key to use |
||||
* @param key_bits must be 64 or 192 |
||||
* @param decrypt 0 for encryption/CBC-MAC, 1 for decryption |
||||
* @return zero on success, negative value otherwise |
||||
*/ |
||||
int av_des_init(struct AVDES *d, const uint8_t *key, int key_bits, int decrypt); |
||||
|
||||
/**
|
||||
* @brief Encrypts / decrypts using the DES algorithm. |
||||
* |
||||
* @param d pointer to the AVDES structure |
||||
* @param dst destination array, can be equal to src, must be 8-byte aligned |
||||
* @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL |
||||
* @param count number of 8 byte blocks |
||||
* @param iv initialization vector for CBC mode, if NULL then ECB will be used, |
||||
* must be 8-byte aligned |
||||
* @param decrypt 0 for encryption, 1 for decryption |
||||
*/ |
||||
void av_des_crypt(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); |
||||
|
||||
/**
|
||||
* @brief Calculates CBC-MAC using the DES algorithm. |
||||
* |
||||
* @param d pointer to the AVDES structure |
||||
* @param dst destination array, can be equal to src, must be 8-byte aligned |
||||
* @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL |
||||
* @param count number of 8 byte blocks |
||||
*/ |
||||
void av_des_mac(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_DES_H */ |
||||
@ -0,0 +1,108 @@ |
||||
/*
|
||||
* 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 nb_bboxes number of AVDetectionBBox structures to allocate |
||||
* @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 |
||||
@ -0,0 +1,241 @@ |
||||
/*
|
||||
* 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 |
||||
* Public dictionary API. |
||||
* @deprecated |
||||
* AVDictionary is provided for compatibility with libav. It is both in |
||||
* implementation as well as API inefficient. It does not scale and is |
||||
* extremely slow with large dictionaries. |
||||
* It is recommended that new code uses our tree container from tree.c/h |
||||
* where applicable, which uses AVL trees to achieve O(log n) performance. |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_DICT_H |
||||
#define AVUTIL_DICT_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @addtogroup lavu_dict AVDictionary |
||||
* @ingroup lavu_data |
||||
* |
||||
* @brief Simple key:value store |
||||
* |
||||
* @{ |
||||
* Dictionaries are used for storing key-value pairs. |
||||
* |
||||
* - To **create an AVDictionary**, simply pass an address of a NULL |
||||
* pointer to av_dict_set(). NULL can be used as an empty dictionary |
||||
* wherever a pointer to an AVDictionary is required. |
||||
* - To **insert an entry**, use av_dict_set(). |
||||
* - Use av_dict_get() to **retrieve an entry**. |
||||
* - To **iterate over all entries**, use av_dict_iterate(). |
||||
* - In order to **free the dictionary and all its contents**, use av_dict_free(). |
||||
* |
||||
@code |
||||
AVDictionary *d = NULL; // "create" an empty dictionary
|
||||
AVDictionaryEntry *t = NULL; |
||||
|
||||
av_dict_set(&d, "foo", "bar", 0); // add an entry
|
||||
|
||||
char *k = av_strdup("key"); // if your strings are already allocated,
|
||||
char *v = av_strdup("value"); // you can avoid copying them like this
|
||||
av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL); |
||||
|
||||
while ((t = av_dict_iterate(d, t))) { |
||||
<....> // iterate over all entries in d
|
||||
} |
||||
av_dict_free(&d); |
||||
@endcode |
||||
*/ |
||||
|
||||
/**
|
||||
* @name AVDictionary Flags |
||||
* Flags that influence behavior of the matching of keys or insertion to the dictionary. |
||||
* @{ |
||||
*/ |
||||
#define AV_DICT_MATCH_CASE 1 /**< Only get an entry with exact-case key match. Only relevant in av_dict_get(). */ |
||||
#define AV_DICT_IGNORE_SUFFIX 2 /**< Return first entry in a dictionary whose first part corresponds to the search key, |
||||
ignoring the suffix of the found key string. Only relevant in av_dict_get(). */ |
||||
#define AV_DICT_DONT_STRDUP_KEY 4 /**< Take ownership of a key that's been |
||||
allocated with av_malloc() or another memory allocation function. */ |
||||
#define AV_DICT_DONT_STRDUP_VAL 8 /**< Take ownership of a value that's been |
||||
allocated with av_malloc() or another memory allocation function. */ |
||||
#define AV_DICT_DONT_OVERWRITE 16 /**< Don't overwrite existing entries. */ |
||||
#define AV_DICT_APPEND 32 /**< If the entry already exists, append to it. Note that no |
||||
delimiter is added, the strings are simply concatenated. */ |
||||
#define AV_DICT_MULTIKEY 64 /**< Allow to store several equal keys in the dictionary */ |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
typedef struct AVDictionaryEntry { |
||||
char *key; |
||||
char *value; |
||||
} AVDictionaryEntry; |
||||
|
||||
typedef struct AVDictionary AVDictionary; |
||||
|
||||
/**
|
||||
* Get a dictionary entry with matching key. |
||||
* |
||||
* The returned entry key or value must not be changed, or it will |
||||
* cause undefined behavior. |
||||
* |
||||
* @param prev Set to the previous matching element to find the next. |
||||
* If set to NULL the first matching element is returned. |
||||
* @param key Matching key |
||||
* @param flags A collection of AV_DICT_* flags controlling how the |
||||
* entry is retrieved |
||||
* |
||||
* @return Found entry or NULL in case no matching entry was found in the dictionary |
||||
*/ |
||||
AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key, |
||||
const AVDictionaryEntry *prev, int flags); |
||||
|
||||
/**
|
||||
* Iterate over a dictionary |
||||
* |
||||
* Iterates through all entries in the dictionary. |
||||
* |
||||
* @warning The returned AVDictionaryEntry key/value must not be changed. |
||||
* |
||||
* @warning As av_dict_set() invalidates all previous entries returned |
||||
* by this function, it must not be called while iterating over the dict. |
||||
* |
||||
* Typical usage: |
||||
* @code |
||||
* const AVDictionaryEntry *e = NULL; |
||||
* while ((e = av_dict_iterate(m, e))) { |
||||
* // ...
|
||||
* } |
||||
* @endcode |
||||
* |
||||
* @param m The dictionary to iterate over |
||||
* @param prev Pointer to the previous AVDictionaryEntry, NULL initially |
||||
* |
||||
* @retval AVDictionaryEntry* The next element in the dictionary |
||||
* @retval NULL No more elements in the dictionary |
||||
*/ |
||||
const AVDictionaryEntry *av_dict_iterate(const AVDictionary *m, |
||||
const AVDictionaryEntry *prev); |
||||
|
||||
/**
|
||||
* Get number of entries in dictionary. |
||||
* |
||||
* @param m dictionary |
||||
* @return number of entries in dictionary |
||||
*/ |
||||
int av_dict_count(const AVDictionary *m); |
||||
|
||||
/**
|
||||
* Set the given entry in *pm, overwriting an existing entry. |
||||
* |
||||
* Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set, |
||||
* these arguments will be freed on error. |
||||
* |
||||
* @warning Adding a new entry to a dictionary invalidates all existing entries |
||||
* previously returned with av_dict_get() or av_dict_iterate(). |
||||
* |
||||
* @param pm Pointer to a pointer to a dictionary struct. If *pm is NULL |
||||
* a dictionary struct is allocated and put in *pm. |
||||
* @param key Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags) |
||||
* @param value Entry value to add to *pm (will be av_strduped or added as a new key depending on flags). |
||||
* Passing a NULL value will cause an existing entry to be deleted. |
||||
* |
||||
* @return >= 0 on success otherwise an error code <0 |
||||
*/ |
||||
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags); |
||||
|
||||
/**
|
||||
* Convenience wrapper for av_dict_set() that converts the value to a string |
||||
* and stores it. |
||||
* |
||||
* Note: If ::AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error. |
||||
*/ |
||||
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags); |
||||
|
||||
/**
|
||||
* Parse the key/value pairs list and add the parsed entries to a dictionary. |
||||
* |
||||
* In case of failure, all the successfully set entries are stored in |
||||
* *pm. You may need to manually free the created dictionary. |
||||
* |
||||
* @param key_val_sep A 0-terminated list of characters used to separate |
||||
* key from value |
||||
* @param pairs_sep A 0-terminated list of characters used to separate |
||||
* two pairs from each other |
||||
* @param flags Flags to use when adding to the dictionary. |
||||
* ::AV_DICT_DONT_STRDUP_KEY and ::AV_DICT_DONT_STRDUP_VAL |
||||
* are ignored since the key/value tokens will always |
||||
* be duplicated. |
||||
* |
||||
* @return 0 on success, negative AVERROR code on failure |
||||
*/ |
||||
int av_dict_parse_string(AVDictionary **pm, const char *str, |
||||
const char *key_val_sep, const char *pairs_sep, |
||||
int flags); |
||||
|
||||
/**
|
||||
* Copy entries from one AVDictionary struct into another. |
||||
* |
||||
* @note Metadata is read using the ::AV_DICT_IGNORE_SUFFIX flag |
||||
* |
||||
* @param dst Pointer to a pointer to a AVDictionary struct to copy into. If *dst is NULL, |
||||
* this function will allocate a struct for you and put it in *dst |
||||
* @param src Pointer to the source AVDictionary struct to copy items from. |
||||
* @param flags Flags to use when setting entries in *dst |
||||
* |
||||
* @return 0 on success, negative AVERROR code on failure. If dst was allocated |
||||
* by this function, callers should free the associated memory. |
||||
*/ |
||||
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags); |
||||
|
||||
/**
|
||||
* Free all the memory allocated for an AVDictionary struct |
||||
* and all keys and values. |
||||
*/ |
||||
void av_dict_free(AVDictionary **m); |
||||
|
||||
/**
|
||||
* Get dictionary entries as a string. |
||||
* |
||||
* Create a string containing dictionary's entries. |
||||
* Such string may be passed back to av_dict_parse_string(). |
||||
* @note String is escaped with backslashes ('\'). |
||||
* |
||||
* @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same. |
||||
* |
||||
* @param[in] m The dictionary |
||||
* @param[out] buffer Pointer to buffer that will be allocated with string containg entries. |
||||
* Buffer must be freed by the caller when is no longer needed. |
||||
* @param[in] key_val_sep Character used to separate key from value |
||||
* @param[in] pairs_sep Character used to separate two pairs from each other |
||||
* |
||||
* @return >= 0 on success, negative on error |
||||
*/ |
||||
int av_dict_get_string(const AVDictionary *m, char **buffer, |
||||
const char key_val_sep, const char pairs_sep); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_DICT_H */ |
||||
@ -0,0 +1,109 @@ |
||||
/*
|
||||
* Copyright (c) 2014 Vittorio Giovara <vittorio.giovara@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 |
||||
*/ |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavu_video_display |
||||
* Display matrix |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_DISPLAY_H |
||||
#define AVUTIL_DISPLAY_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @defgroup lavu_video_display Display transformation matrix functions |
||||
* @ingroup lavu_video |
||||
* |
||||
* The display transformation matrix specifies an affine transformation that |
||||
* should be applied to video frames for correct presentation. It is compatible |
||||
* with the matrices stored in the ISO/IEC 14496-12 container format. |
||||
* |
||||
* The data is a 3x3 matrix represented as a 9-element array: |
||||
* |
||||
* @code{.unparsed} |
||||
* | a b u | |
||||
* (a, b, u, c, d, v, x, y, w) -> | c d v | |
||||
* | x y w | |
||||
* @endcode |
||||
* |
||||
* All numbers are stored in native endianness, as 16.16 fixed-point values, |
||||
* except for u, v and w, which are stored as 2.30 fixed-point values. |
||||
* |
||||
* The transformation maps a point (p, q) in the source (pre-transformation) |
||||
* frame to the point (p', q') in the destination (post-transformation) frame as |
||||
* follows: |
||||
* |
||||
* @code{.unparsed} |
||||
* | a b u | |
||||
* (p, q, 1) . | c d v | = z * (p', q', 1) |
||||
* | x y w | |
||||
* @endcode |
||||
* |
||||
* The transformation can also be more explicitly written in components as |
||||
* follows: |
||||
* |
||||
* @code{.unparsed} |
||||
* p' = (a * p + c * q + x) / z; |
||||
* q' = (b * p + d * q + y) / z; |
||||
* z = u * p + v * q + w |
||||
* @endcode |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Extract the rotation component of the transformation matrix. |
||||
* |
||||
* @param matrix the transformation matrix |
||||
* @return the angle (in degrees) by which the transformation rotates the frame |
||||
* counterclockwise. The angle will be in range [-180.0, 180.0], |
||||
* or NaN if the matrix is singular. |
||||
* |
||||
* @note floating point numbers are inherently inexact, so callers are |
||||
* recommended to round the return value to nearest integer before use. |
||||
*/ |
||||
double av_display_rotation_get(const int32_t matrix[9]); |
||||
|
||||
/**
|
||||
* Initialize a transformation matrix describing a pure clockwise |
||||
* rotation by the specified angle (in degrees). |
||||
* |
||||
* @param[out] matrix a transformation matrix (will be fully overwritten |
||||
* by this function) |
||||
* @param angle rotation angle in degrees. |
||||
*/ |
||||
void av_display_rotation_set(int32_t matrix[9], double angle); |
||||
|
||||
/**
|
||||
* Flip the input matrix horizontally and/or vertically. |
||||
* |
||||
* @param[in,out] matrix a transformation matrix |
||||
* @param hflip whether the matrix should be flipped horizontally |
||||
* @param vflip whether the matrix should be flipped vertically |
||||
*/ |
||||
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_DISPLAY_H */ |
||||
@ -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 */ |
||||
@ -0,0 +1,115 @@ |
||||
/*
|
||||
* Copyright (c) 2014 Tim Walker <tdskywalker@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_DOWNMIX_INFO_H |
||||
#define AVUTIL_DOWNMIX_INFO_H |
||||
|
||||
#include "frame.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* audio downmix medatata |
||||
*/ |
||||
|
||||
/**
|
||||
* @addtogroup lavu_audio |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup downmix_info Audio downmix metadata |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Possible downmix types. |
||||
*/ |
||||
enum AVDownmixType { |
||||
AV_DOWNMIX_TYPE_UNKNOWN, /**< Not indicated. */ |
||||
AV_DOWNMIX_TYPE_LORO, /**< Lo/Ro 2-channel downmix (Stereo). */ |
||||
AV_DOWNMIX_TYPE_LTRT, /**< Lt/Rt 2-channel downmix, Dolby Surround compatible. */ |
||||
AV_DOWNMIX_TYPE_DPLII, /**< Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible. */ |
||||
AV_DOWNMIX_TYPE_NB /**< Number of downmix types. Not part of ABI. */ |
||||
}; |
||||
|
||||
/**
|
||||
* This structure describes optional metadata relevant to a downmix procedure. |
||||
* |
||||
* All fields are set by the decoder to the value indicated in the audio |
||||
* bitstream (if present), or to a "sane" default otherwise. |
||||
*/ |
||||
typedef struct AVDownmixInfo { |
||||
/**
|
||||
* Type of downmix preferred by the mastering engineer. |
||||
*/ |
||||
enum AVDownmixType preferred_downmix_type; |
||||
|
||||
/**
|
||||
* Absolute scale factor representing the nominal level of the center |
||||
* channel during a regular downmix. |
||||
*/ |
||||
double center_mix_level; |
||||
|
||||
/**
|
||||
* Absolute scale factor representing the nominal level of the center |
||||
* channel during an Lt/Rt compatible downmix. |
||||
*/ |
||||
double center_mix_level_ltrt; |
||||
|
||||
/**
|
||||
* Absolute scale factor representing the nominal level of the surround |
||||
* channels during a regular downmix. |
||||
*/ |
||||
double surround_mix_level; |
||||
|
||||
/**
|
||||
* Absolute scale factor representing the nominal level of the surround |
||||
* channels during an Lt/Rt compatible downmix. |
||||
*/ |
||||
double surround_mix_level_ltrt; |
||||
|
||||
/**
|
||||
* Absolute scale factor representing the level at which the LFE data is |
||||
* mixed into L/R channels during downmixing. |
||||
*/ |
||||
double lfe_mix_level; |
||||
} AVDownmixInfo; |
||||
|
||||
/**
|
||||
* Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing. |
||||
* |
||||
* If the side data is absent, it is created and added to the frame. |
||||
* |
||||
* @param frame the frame for which the side data is to be obtained or created |
||||
* |
||||
* @return the AVDownmixInfo structure to be edited by the caller, or NULL if |
||||
* the structure cannot be allocated. |
||||
*/ |
||||
AVDownmixInfo *av_downmix_info_update_side_data(AVFrame *frame); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_DOWNMIX_INFO_H */ |
||||
@ -0,0 +1,205 @@ |
||||
/**
|
||||
* 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_ENCRYPTION_INFO_H |
||||
#define AVUTIL_ENCRYPTION_INFO_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
typedef struct AVSubsampleEncryptionInfo { |
||||
/** The number of bytes that are clear. */ |
||||
unsigned int bytes_of_clear_data; |
||||
|
||||
/**
|
||||
* The number of bytes that are protected. If using pattern encryption, |
||||
* the pattern applies to only the protected bytes; if not using pattern |
||||
* encryption, all these bytes are encrypted. |
||||
*/ |
||||
unsigned int bytes_of_protected_data; |
||||
} AVSubsampleEncryptionInfo; |
||||
|
||||
/**
|
||||
* This describes encryption info for a packet. This contains frame-specific |
||||
* info for how to decrypt the packet before passing it to the decoder. |
||||
* |
||||
* The size of this struct is not part of the public ABI. |
||||
*/ |
||||
typedef struct AVEncryptionInfo { |
||||
/** The fourcc encryption scheme, in big-endian byte order. */ |
||||
uint32_t scheme; |
||||
|
||||
/**
|
||||
* Only used for pattern encryption. This is the number of 16-byte blocks |
||||
* that are encrypted. |
||||
*/ |
||||
uint32_t crypt_byte_block; |
||||
|
||||
/**
|
||||
* Only used for pattern encryption. This is the number of 16-byte blocks |
||||
* that are clear. |
||||
*/ |
||||
uint32_t skip_byte_block; |
||||
|
||||
/**
|
||||
* The ID of the key used to encrypt the packet. This should always be |
||||
* 16 bytes long, but may be changed in the future. |
||||
*/ |
||||
uint8_t *key_id; |
||||
uint32_t key_id_size; |
||||
|
||||
/**
|
||||
* The initialization vector. This may have been zero-filled to be the |
||||
* correct block size. This should always be 16 bytes long, but may be |
||||
* changed in the future. |
||||
*/ |
||||
uint8_t *iv; |
||||
uint32_t iv_size; |
||||
|
||||
/**
|
||||
* An array of subsample encryption info specifying how parts of the sample |
||||
* are encrypted. If there are no subsamples, then the whole sample is |
||||
* encrypted. |
||||
*/ |
||||
AVSubsampleEncryptionInfo *subsamples; |
||||
uint32_t subsample_count; |
||||
} AVEncryptionInfo; |
||||
|
||||
/**
|
||||
* This describes info used to initialize an encryption key system. |
||||
* |
||||
* The size of this struct is not part of the public ABI. |
||||
*/ |
||||
typedef struct AVEncryptionInitInfo { |
||||
/**
|
||||
* A unique identifier for the key system this is for, can be NULL if it |
||||
* is not known. This should always be 16 bytes, but may change in the |
||||
* future. |
||||
*/ |
||||
uint8_t* system_id; |
||||
uint32_t system_id_size; |
||||
|
||||
/**
|
||||
* An array of key IDs this initialization data is for. All IDs are the |
||||
* same length. Can be NULL if there are no known key IDs. |
||||
*/ |
||||
uint8_t** key_ids; |
||||
/** The number of key IDs. */ |
||||
uint32_t num_key_ids; |
||||
/**
|
||||
* The number of bytes in each key ID. This should always be 16, but may |
||||
* change in the future. |
||||
*/ |
||||
uint32_t key_id_size; |
||||
|
||||
/**
|
||||
* Key-system specific initialization data. This data is copied directly |
||||
* from the file and the format depends on the specific key system. This |
||||
* can be NULL if there is no initialization data; in that case, there |
||||
* will be at least one key ID. |
||||
*/ |
||||
uint8_t* data; |
||||
uint32_t data_size; |
||||
|
||||
/**
|
||||
* An optional pointer to the next initialization info in the list. |
||||
*/ |
||||
struct AVEncryptionInitInfo *next; |
||||
} AVEncryptionInitInfo; |
||||
|
||||
/**
|
||||
* Allocates an AVEncryptionInfo structure and sub-pointers to hold the given |
||||
* number of subsamples. This will allocate pointers for the key ID, IV, |
||||
* and subsample entries, set the size members, and zero-initialize the rest. |
||||
* |
||||
* @param subsample_count The number of subsamples. |
||||
* @param key_id_size The number of bytes in the key ID, should be 16. |
||||
* @param iv_size The number of bytes in the IV, should be 16. |
||||
* |
||||
* @return The new AVEncryptionInfo structure, or NULL on error. |
||||
*/ |
||||
AVEncryptionInfo *av_encryption_info_alloc(uint32_t subsample_count, uint32_t key_id_size, uint32_t iv_size); |
||||
|
||||
/**
|
||||
* Allocates an AVEncryptionInfo structure with a copy of the given data. |
||||
* @return The new AVEncryptionInfo structure, or NULL on error. |
||||
*/ |
||||
AVEncryptionInfo *av_encryption_info_clone(const AVEncryptionInfo *info); |
||||
|
||||
/**
|
||||
* Frees the given encryption info object. This MUST NOT be used to free the |
||||
* side-data data pointer, that should use normal side-data methods. |
||||
*/ |
||||
void av_encryption_info_free(AVEncryptionInfo *info); |
||||
|
||||
/**
|
||||
* Creates a copy of the AVEncryptionInfo that is contained in the given side |
||||
* data. The resulting object should be passed to av_encryption_info_free() |
||||
* when done. |
||||
* |
||||
* @return The new AVEncryptionInfo structure, or NULL on error. |
||||
*/ |
||||
AVEncryptionInfo *av_encryption_info_get_side_data(const uint8_t *side_data, size_t side_data_size); |
||||
|
||||
/**
|
||||
* Allocates and initializes side data that holds a copy of the given encryption |
||||
* info. The resulting pointer should be either freed using av_free or given |
||||
* to av_packet_add_side_data(). |
||||
* |
||||
* @return The new side-data pointer, or NULL. |
||||
*/ |
||||
uint8_t *av_encryption_info_add_side_data( |
||||
const AVEncryptionInfo *info, size_t *side_data_size); |
||||
|
||||
|
||||
/**
|
||||
* Allocates an AVEncryptionInitInfo structure and sub-pointers to hold the |
||||
* given sizes. This will allocate pointers and set all the fields. |
||||
* |
||||
* @return The new AVEncryptionInitInfo structure, or NULL on error. |
||||
*/ |
||||
AVEncryptionInitInfo *av_encryption_init_info_alloc( |
||||
uint32_t system_id_size, uint32_t num_key_ids, uint32_t key_id_size, uint32_t data_size); |
||||
|
||||
/**
|
||||
* Frees the given encryption init info object. This MUST NOT be used to free |
||||
* the side-data data pointer, that should use normal side-data methods. |
||||
*/ |
||||
void av_encryption_init_info_free(AVEncryptionInitInfo* info); |
||||
|
||||
/**
|
||||
* Creates a copy of the AVEncryptionInitInfo that is contained in the given |
||||
* side data. The resulting object should be passed to |
||||
* av_encryption_init_info_free() when done. |
||||
* |
||||
* @return The new AVEncryptionInitInfo structure, or NULL on error. |
||||
*/ |
||||
AVEncryptionInitInfo *av_encryption_init_info_get_side_data( |
||||
const uint8_t* side_data, size_t side_data_size); |
||||
|
||||
/**
|
||||
* Allocates and initializes side data that holds a copy of the given encryption |
||||
* init info. The resulting pointer should be either freed using av_free or |
||||
* given to av_packet_add_side_data(). |
||||
* |
||||
* @return The new side-data pointer, or NULL. |
||||
*/ |
||||
uint8_t *av_encryption_init_info_add_side_data( |
||||
const AVEncryptionInitInfo *info, size_t *side_data_size); |
||||
|
||||
#endif /* AVUTIL_ENCRYPTION_INFO_H */ |
||||
@ -0,0 +1,128 @@ |
||||
/*
|
||||
* 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 |
||||
* error code definitions |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_ERROR_H |
||||
#define AVUTIL_ERROR_H |
||||
|
||||
#include <errno.h> |
||||
#include <stddef.h> |
||||
|
||||
#include "macros.h" |
||||
|
||||
/**
|
||||
* @addtogroup lavu_error |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
|
||||
/* error handling */ |
||||
#if EDOM > 0 |
||||
#define AVERROR(e) (-(e)) ///< Returns a negative error code from a POSIX error code, to return from library functions.
|
||||
#define AVUNERROR(e) (-(e)) ///< Returns a POSIX error code from a library function error return value.
|
||||
#else |
||||
/* Some platforms have E* and errno already negated. */ |
||||
#define AVERROR(e) (e) |
||||
#define AVUNERROR(e) (e) |
||||
#endif |
||||
|
||||
#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d)) |
||||
|
||||
#define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F') ///< Bitstream filter not found
|
||||
#define AVERROR_BUG FFERRTAG( 'B','U','G','!') ///< Internal bug, also see AVERROR_BUG2
|
||||
#define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S') ///< Buffer too small
|
||||
#define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C') ///< Decoder not found
|
||||
#define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M') ///< Demuxer not found
|
||||
#define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C') ///< Encoder not found
|
||||
#define AVERROR_EOF FFERRTAG( 'E','O','F',' ') ///< End of file
|
||||
#define AVERROR_EXIT FFERRTAG( 'E','X','I','T') ///< Immediate exit was requested; the called function should not be restarted
|
||||
#define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ') ///< Generic error in an external library
|
||||
#define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L') ///< Filter not found
|
||||
#define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A') ///< Invalid data found when processing input
|
||||
#define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X') ///< Muxer not found
|
||||
#define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T') ///< Option not found
|
||||
#define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E') ///< Not yet implemented in FFmpeg, patches welcome
|
||||
#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O') ///< Protocol not found
|
||||
|
||||
#define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R') ///< Stream not found
|
||||
/**
|
||||
* This is semantically identical to AVERROR_BUG |
||||
* it has been introduced in Libav after our AVERROR_BUG and with a modified value. |
||||
*/ |
||||
#define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ') |
||||
#define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N') ///< Unknown error, typically from an external library
|
||||
#define AVERROR_EXPERIMENTAL (-0x2bb2afa8) ///< Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
|
||||
#define AVERROR_INPUT_CHANGED (-0x636e6701) ///< Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
|
||||
#define AVERROR_OUTPUT_CHANGED (-0x636e6702) ///< Output changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_INPUT_CHANGED)
|
||||
/* HTTP & RTSP errors */ |
||||
#define AVERROR_HTTP_BAD_REQUEST FFERRTAG(0xF8,'4','0','0') |
||||
#define AVERROR_HTTP_UNAUTHORIZED FFERRTAG(0xF8,'4','0','1') |
||||
#define AVERROR_HTTP_FORBIDDEN FFERRTAG(0xF8,'4','0','3') |
||||
#define AVERROR_HTTP_NOT_FOUND FFERRTAG(0xF8,'4','0','4') |
||||
#define AVERROR_HTTP_OTHER_4XX FFERRTAG(0xF8,'4','X','X') |
||||
#define AVERROR_HTTP_SERVER_ERROR FFERRTAG(0xF8,'5','X','X') |
||||
|
||||
#define AV_ERROR_MAX_STRING_SIZE 64 |
||||
|
||||
/**
|
||||
* Put a description of the AVERROR code errnum in errbuf. |
||||
* In case of failure the global variable errno is set to indicate the |
||||
* error. Even in case of failure av_strerror() will print a generic |
||||
* error message indicating the errnum provided to errbuf. |
||||
* |
||||
* @param errnum error code to describe |
||||
* @param errbuf buffer to which description is written |
||||
* @param errbuf_size the size in bytes of errbuf |
||||
* @return 0 on success, a negative value if a description for errnum |
||||
* cannot be found |
||||
*/ |
||||
int av_strerror(int errnum, char *errbuf, size_t errbuf_size); |
||||
|
||||
/**
|
||||
* Fill the provided buffer with a string containing an error string |
||||
* corresponding to the AVERROR code errnum. |
||||
* |
||||
* @param errbuf a buffer |
||||
* @param errbuf_size size in bytes of errbuf |
||||
* @param errnum error code to describe |
||||
* @return the buffer in input, filled with the error description |
||||
* @see av_strerror() |
||||
*/ |
||||
static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum) |
||||
{ |
||||
av_strerror(errnum, errbuf, errbuf_size); |
||||
return errbuf; |
||||
} |
||||
|
||||
/**
|
||||
* Convenience macro, the return value should be used only directly in |
||||
* function arguments but never stand-alone. |
||||
*/ |
||||
#define av_err2str(errnum) \ |
||||
av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum) |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_ERROR_H */ |
||||
@ -0,0 +1,140 @@ |
||||
/*
|
||||
* Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at> |
||||
* |
||||
* 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 |
||||
* simple arithmetic expression evaluator |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_EVAL_H |
||||
#define AVUTIL_EVAL_H |
||||
|
||||
typedef struct AVExpr AVExpr; |
||||
|
||||
/**
|
||||
* Parse and evaluate an expression. |
||||
* Note, this is significantly slower than av_expr_eval(). |
||||
* |
||||
* @param res a pointer to a double where is put the result value of |
||||
* the expression, or NAN in case of error |
||||
* @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)" |
||||
* @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0} |
||||
* @param const_values a zero terminated array of values for the identifiers from const_names |
||||
* @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers |
||||
* @param funcs1 NULL terminated array of function pointers for functions which take 1 argument |
||||
* @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers |
||||
* @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments |
||||
* @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 |
||||
* @param log_offset log level offset, can be used to silence error messages |
||||
* @param log_ctx parent logging context |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code otherwise |
||||
*/ |
||||
int av_expr_parse_and_eval(double *res, const char *s, |
||||
const char * const *const_names, const double *const_values, |
||||
const char * const *func1_names, double (* const *funcs1)(void *, double), |
||||
const char * const *func2_names, double (* const *funcs2)(void *, double, double), |
||||
void *opaque, int log_offset, void *log_ctx); |
||||
|
||||
/**
|
||||
* Parse an expression. |
||||
* |
||||
* @param expr a pointer where is put an AVExpr containing the parsed |
||||
* value in case of successful parsing, or NULL otherwise. |
||||
* The pointed to AVExpr must be freed with av_expr_free() by the user |
||||
* when it is not needed anymore. |
||||
* @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)" |
||||
* @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0} |
||||
* @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers |
||||
* @param funcs1 NULL terminated array of function pointers for functions which take 1 argument |
||||
* @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers |
||||
* @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments |
||||
* @param log_offset log level offset, can be used to silence error messages |
||||
* @param log_ctx parent logging context |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code otherwise |
||||
*/ |
||||
int av_expr_parse(AVExpr **expr, const char *s, |
||||
const char * const *const_names, |
||||
const char * const *func1_names, double (* const *funcs1)(void *, double), |
||||
const char * const *func2_names, double (* const *funcs2)(void *, double, double), |
||||
int log_offset, void *log_ctx); |
||||
|
||||
/**
|
||||
* Evaluate a previously parsed expression. |
||||
* |
||||
* @param e the AVExpr to evaluate |
||||
* @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names |
||||
* @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 |
||||
* @return the value of the expression |
||||
*/ |
||||
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 e the AVExpr to track variables in |
||||
* @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 e the AVExpr to track user provided functions in |
||||
* @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(). |
||||
*/ |
||||
void av_expr_free(AVExpr *e); |
||||
|
||||
/**
|
||||
* Parse the string in numstr and return its value as a double. If |
||||
* the string is empty, contains only whitespaces, or does not contain |
||||
* an initial substring that has the expected syntax for a |
||||
* floating-point number, no conversion is performed. In this case, |
||||
* returns a value of zero and the value returned in tail is the value |
||||
* of numstr. |
||||
* |
||||
* @param numstr a string representing a number, may contain one of |
||||
* the International System number postfixes, for example 'K', 'M', |
||||
* 'G'. If 'i' is appended after the postfix, powers of 2 are used |
||||
* instead of powers of 10. The 'B' postfix multiplies the value by |
||||
* 8, and can be appended after another postfix or used alone. This |
||||
* allows using for example 'KB', 'MiB', 'G' and 'B' as postfix. |
||||
* @param tail if non-NULL puts here the pointer to the char next |
||||
* after the last parsed character |
||||
*/ |
||||
double av_strtod(const char *numstr, char **tail); |
||||
|
||||
#endif /* AVUTIL_EVAL_H */ |
||||
@ -0,0 +1,5 @@ |
||||
/* Automatically generated by version.sh, do not manually edit! */ |
||||
#ifndef AVUTIL_FFVERSION_H |
||||
#define AVUTIL_FFVERSION_H |
||||
#define FFMPEG_VERSION "n6.0" |
||||
#endif /* AVUTIL_FFVERSION_H */ |
||||
@ -0,0 +1,448 @@ |
||||
/*
|
||||
* 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 |
||||
* @ingroup lavu_fifo |
||||
* A generic FIFO API |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_FIFO_H |
||||
#define AVUTIL_FIFO_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_fifo AVFifo |
||||
* @ingroup lavu_data |
||||
* |
||||
* @{ |
||||
* A generic FIFO API |
||||
*/ |
||||
|
||||
typedef struct AVFifo AVFifo; |
||||
|
||||
/**
|
||||
* Callback for writing or reading from a FIFO, passed to (and invoked from) the |
||||
* av_fifo_*_cb() functions. It may be invoked multiple times from a single |
||||
* av_fifo_*_cb() call and may process less data than the maximum size indicated |
||||
* by nb_elems. |
||||
* |
||||
* @param opaque the opaque pointer provided to the av_fifo_*_cb() function |
||||
* @param buf the buffer for reading or writing the data, depending on which |
||||
* av_fifo_*_cb function is called |
||||
* @param nb_elems On entry contains the maximum number of elements that can be |
||||
* read from / written into buf. On success, the callback should |
||||
* update it to contain the number of elements actually written. |
||||
* |
||||
* @return 0 on success, a negative error code on failure (will be returned from |
||||
* the invoking av_fifo_*_cb() function) |
||||
*/ |
||||
typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems); |
||||
|
||||
/**
|
||||
* Automatically resize the FIFO on writes, so that the data fits. This |
||||
* automatic resizing happens up to a limit that can be modified with |
||||
* av_fifo_auto_grow_limit(). |
||||
*/ |
||||
#define AV_FIFO_FLAG_AUTO_GROW (1 << 0) |
||||
|
||||
/**
|
||||
* Allocate and initialize an AVFifo with a given element size. |
||||
* |
||||
* @param elems initial number of elements that can be stored in the FIFO |
||||
* @param elem_size Size in bytes of a single element. Further operations on |
||||
* the returned FIFO will implicitly use this element size. |
||||
* @param flags a combination of AV_FIFO_FLAG_* |
||||
* |
||||
* @return newly-allocated AVFifo on success, a negative error code on failure |
||||
*/ |
||||
AVFifo *av_fifo_alloc2(size_t elems, size_t elem_size, |
||||
unsigned int flags); |
||||
|
||||
/**
|
||||
* @return Element size for FIFO operations. This element size is set at |
||||
* FIFO allocation and remains constant during its lifetime |
||||
*/ |
||||
size_t av_fifo_elem_size(const AVFifo *f); |
||||
|
||||
/**
|
||||
* Set the maximum size (in elements) to which the FIFO can be resized |
||||
* automatically. Has no effect unless AV_FIFO_FLAG_AUTO_GROW is used. |
||||
*/ |
||||
void av_fifo_auto_grow_limit(AVFifo *f, size_t max_elems); |
||||
|
||||
/**
|
||||
* @return number of elements available for reading from the given FIFO. |
||||
*/ |
||||
size_t av_fifo_can_read(const AVFifo *f); |
||||
|
||||
/**
|
||||
* @return Number of elements that can be written into the given FIFO without |
||||
* growing it. |
||||
* |
||||
* In other words, this number of elements or less is guaranteed to fit |
||||
* into the FIFO. More data may be written when the |
||||
* AV_FIFO_FLAG_AUTO_GROW flag was specified at FIFO creation, but this |
||||
* may involve memory allocation, which can fail. |
||||
*/ |
||||
size_t av_fifo_can_write(const AVFifo *f); |
||||
|
||||
/**
|
||||
* Enlarge an AVFifo. |
||||
* |
||||
* On success, the FIFO will be large enough to hold exactly |
||||
* inc + av_fifo_can_read() + av_fifo_can_write() |
||||
* elements. In case of failure, the old FIFO is kept unchanged. |
||||
* |
||||
* @param f AVFifo to resize |
||||
* @param inc number of elements to allocate for, in addition to the current |
||||
* allocated size |
||||
* @return a non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_grow2(AVFifo *f, size_t inc); |
||||
|
||||
/**
|
||||
* Write data into a FIFO. |
||||
* |
||||
* In case nb_elems > av_fifo_can_write(f) and the AV_FIFO_FLAG_AUTO_GROW flag |
||||
* was not specified at FIFO creation, nothing is written and an error |
||||
* is returned. |
||||
* |
||||
* Calling function is guaranteed to succeed if nb_elems <= av_fifo_can_write(f). |
||||
* |
||||
* @param f the FIFO buffer |
||||
* @param buf Data to be written. nb_elems * av_fifo_elem_size(f) bytes will be |
||||
* read from buf on success. |
||||
* @param nb_elems number of elements to write into FIFO |
||||
* |
||||
* @return a non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems); |
||||
|
||||
/**
|
||||
* Write data from a user-provided callback into a FIFO. |
||||
* |
||||
* @param f the FIFO buffer |
||||
* @param read_cb Callback supplying the data to the FIFO. May be called |
||||
* multiple times. |
||||
* @param opaque opaque user data to be provided to read_cb |
||||
* @param nb_elems Should point to the maximum number of elements that can be |
||||
* written. Will be updated to contain the number of elements |
||||
* actually written. |
||||
* |
||||
* @return non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_write_from_cb(AVFifo *f, AVFifoCB read_cb, |
||||
void *opaque, size_t *nb_elems); |
||||
|
||||
/**
|
||||
* Read data from a FIFO. |
||||
* |
||||
* In case nb_elems > av_fifo_can_read(f), nothing is read and an error |
||||
* is returned. |
||||
* |
||||
* @param f the FIFO buffer |
||||
* @param buf Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes |
||||
* will be written into buf on success. |
||||
* @param nb_elems number of elements to read from FIFO |
||||
* |
||||
* @return a non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems); |
||||
|
||||
/**
|
||||
* Feed data from a FIFO into a user-provided callback. |
||||
* |
||||
* @param f the FIFO buffer |
||||
* @param write_cb Callback the data will be supplied to. May be called |
||||
* multiple times. |
||||
* @param opaque opaque user data to be provided to write_cb |
||||
* @param nb_elems Should point to the maximum number of elements that can be |
||||
* read. Will be updated to contain the total number of elements |
||||
* actually sent to the callback. |
||||
* |
||||
* @return non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_read_to_cb(AVFifo *f, AVFifoCB write_cb, |
||||
void *opaque, size_t *nb_elems); |
||||
|
||||
/**
|
||||
* Read data from a FIFO without modifying FIFO state. |
||||
* |
||||
* Returns an error if an attempt is made to peek to nonexistent elements |
||||
* (i.e. if offset + nb_elems is larger than av_fifo_can_read(f)). |
||||
* |
||||
* @param f the FIFO buffer |
||||
* @param buf Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes |
||||
* will be written into buf. |
||||
* @param nb_elems number of elements to read from FIFO |
||||
* @param offset number of initial elements to skip. |
||||
* |
||||
* @return a non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_peek(AVFifo *f, void *buf, size_t nb_elems, size_t offset); |
||||
|
||||
/**
|
||||
* Feed data from a FIFO into a user-provided callback. |
||||
* |
||||
* @param f the FIFO buffer |
||||
* @param write_cb Callback the data will be supplied to. May be called |
||||
* multiple times. |
||||
* @param opaque opaque user data to be provided to write_cb |
||||
* @param nb_elems Should point to the maximum number of elements that can be |
||||
* read. Will be updated to contain the total number of elements |
||||
* actually sent to the callback. |
||||
* @param offset number of initial elements to skip; offset + *nb_elems must not |
||||
* be larger than av_fifo_can_read(f). |
||||
* |
||||
* @return a non-negative number on success, a negative error code on failure |
||||
*/ |
||||
int av_fifo_peek_to_cb(AVFifo *f, AVFifoCB write_cb, void *opaque, |
||||
size_t *nb_elems, size_t offset); |
||||
|
||||
/**
|
||||
* Discard the specified amount of data from an AVFifo. |
||||
* @param size number of elements to discard, MUST NOT be larger than |
||||
* av_fifo_can_read(f) |
||||
*/ |
||||
void av_fifo_drain2(AVFifo *f, size_t size); |
||||
|
||||
/*
|
||||
* Empty the AVFifo. |
||||
* @param f AVFifo to reset |
||||
*/ |
||||
void av_fifo_reset2(AVFifo *f); |
||||
|
||||
/**
|
||||
* Free an AVFifo and reset pointer to NULL. |
||||
* @param f Pointer to an AVFifo to free. *f == NULL is allowed. |
||||
*/ |
||||
void av_fifo_freep2(AVFifo **f); |
||||
|
||||
|
||||
#if FF_API_FIFO_OLD_API |
||||
typedef struct AVFifoBuffer { |
||||
uint8_t *buffer; |
||||
uint8_t *rptr, *wptr, *end; |
||||
uint32_t rndx, wndx; |
||||
} 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); |
||||
|
||||
/**
|
||||
* Initialize an AVFifoBuffer. |
||||
* @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); |
||||
|
||||
/**
|
||||
* Return the amount of data in bytes in the AVFifoBuffer, that is the |
||||
* 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); |
||||
|
||||
/**
|
||||
* Return the amount of space in bytes in the AVFifoBuffer, that is the |
||||
* 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); |
||||
|
||||
/**
|
||||
* Feed data at specific position from an AVFifoBuffer to a user-supplied callback. |
||||
* Similar as av_fifo_gereric_read but without discarding data. |
||||
* @param f AVFifoBuffer to read from |
||||
* @param offset offset from current read position |
||||
* @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)); |
||||
|
||||
/**
|
||||
* Feed data from an AVFifoBuffer to a user-supplied callback. |
||||
* Similar as av_fifo_gereric_read but without discarding data. |
||||
* @param f AVFifoBuffer to read from |
||||
* @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)); |
||||
|
||||
/**
|
||||
* Feed data from an AVFifoBuffer to a user-supplied callback. |
||||
* @param f AVFifoBuffer to read from |
||||
* @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)); |
||||
|
||||
/**
|
||||
* Feed data from a user-supplied callback to an AVFifoBuffer. |
||||
* @param f AVFifoBuffer to write to |
||||
* @param src data source; non-const since it may be used as a |
||||
* modifiable context by the function defined in func |
||||
* @param size number of bytes to write |
||||
* @param func generic write function; the first parameter is src, |
||||
* the second is dest_buf, the third is dest_buf_size. |
||||
* 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 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)); |
||||
|
||||
/**
|
||||
* Resize an AVFifoBuffer. |
||||
* In case of reallocation failure, the old FIFO is kept unchanged. |
||||
* |
||||
* @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); |
||||
|
||||
/**
|
||||
* Enlarge an AVFifoBuffer. |
||||
* In case of reallocation failure, the old FIFO is kept unchanged. |
||||
* The new fifo size may be larger than the requested 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. |
||||
* |
||||
* @param f AVFifoBuffer to peek at, f must be non-NULL |
||||
* @param offs an offset in bytes, its absolute value must be less |
||||
* 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; |
||||
if (ptr >= f->end) |
||||
ptr = f->buffer + (ptr - f->end); |
||||
else if (ptr < f->buffer) |
||||
ptr = f->end - (f->buffer - ptr); |
||||
return ptr; |
||||
} |
||||
#endif |
||||
#endif |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_FIFO_H */ |
||||
@ -0,0 +1,80 @@ |
||||
/*
|
||||
* 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_FILE_H |
||||
#define AVUTIL_FILE_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "version.h" |
||||
#include "attributes.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* Misc file utilities. |
||||
*/ |
||||
|
||||
/**
|
||||
* Read the file with name filename, and put its content in a newly |
||||
* allocated buffer or map it with mmap() when available. |
||||
* In case of success set *bufptr to the read or mmapped buffer, and |
||||
* *size to the size in bytes of the buffer in *bufptr. |
||||
* Unlike mmap this function succeeds with zero sized files, in this |
||||
* case *bufptr will be set to NULL and *size will be set to 0. |
||||
* The returned buffer must be released with av_file_unmap(). |
||||
* |
||||
* @param filename path to the file |
||||
* @param[out] bufptr pointee is set to the mapped or allocated buffer |
||||
* @param[out] size pointee is set to the size in bytes of the buffer |
||||
* @param log_offset loglevel offset used for logging |
||||
* @param log_ctx context used for logging |
||||
* @return a non negative number in case of success, a negative value |
||||
* corresponding to an AVERROR error code in case of failure |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, |
||||
int log_offset, void *log_ctx); |
||||
|
||||
/**
|
||||
* Unmap or free the buffer bufptr created by av_file_map(). |
||||
* |
||||
* @param bufptr the buffer previously created with av_file_map() |
||||
* @param size size in bytes of bufptr, must be the same as returned |
||||
* by av_file_map() |
||||
*/ |
||||
void av_file_unmap(uint8_t *bufptr, size_t size); |
||||
|
||||
#if FF_API_AV_FOPEN_UTF8 |
||||
/**
|
||||
* Wrapper to work around the lack of mkstemp() on mingw. |
||||
* Also, tries to create file in /tmp first, if possible. |
||||
* *prefix can be a character constant; *filename will be allocated internally. |
||||
* @return file descriptor of opened file (or negative value corresponding to an |
||||
* AVERROR code on error) |
||||
* and opened file name in **filename. |
||||
* @note On very old libcs it is necessary to set a secure umask before |
||||
* calling this, av_tempfile() can't call umask itself as it is used in |
||||
* libraries and could interfere with the calling application. |
||||
* @deprecated as fd numbers cannot be passed saftely between libs on some platforms |
||||
*/ |
||||
attribute_deprecated |
||||
int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx); |
||||
#endif |
||||
|
||||
#endif /* AVUTIL_FILE_H */ |
||||
@ -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 */ |
||||
@ -0,0 +1,964 @@ |
||||
/*
|
||||
* 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 |
||||
* @ingroup lavu_frame |
||||
* reference-counted frame API |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_FRAME_H |
||||
#define AVUTIL_FRAME_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "avutil.h" |
||||
#include "buffer.h" |
||||
#include "channel_layout.h" |
||||
#include "dict.h" |
||||
#include "rational.h" |
||||
#include "samplefmt.h" |
||||
#include "pixfmt.h" |
||||
#include "version.h" |
||||
|
||||
|
||||
/**
|
||||
* @defgroup lavu_frame AVFrame |
||||
* @ingroup lavu_data |
||||
* |
||||
* @{ |
||||
* AVFrame is an abstraction for reference-counted raw multimedia data. |
||||
*/ |
||||
|
||||
enum AVFrameSideDataType { |
||||
/**
|
||||
* The data is the AVPanScan struct defined in libavcodec. |
||||
*/ |
||||
AV_FRAME_DATA_PANSCAN, |
||||
/**
|
||||
* ATSC A53 Part 4 Closed Captions. |
||||
* A53 CC bitstream is stored as uint8_t in AVFrameSideData.data. |
||||
* The number of bytes of CC data is AVFrameSideData.size. |
||||
*/ |
||||
AV_FRAME_DATA_A53_CC, |
||||
/**
|
||||
* Stereoscopic 3d metadata. |
||||
* The data is the AVStereo3D struct defined in libavutil/stereo3d.h. |
||||
*/ |
||||
AV_FRAME_DATA_STEREO3D, |
||||
/**
|
||||
* The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h. |
||||
*/ |
||||
AV_FRAME_DATA_MATRIXENCODING, |
||||
/**
|
||||
* Metadata relevant to a downmix procedure. |
||||
* The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h. |
||||
*/ |
||||
AV_FRAME_DATA_DOWNMIX_INFO, |
||||
/**
|
||||
* ReplayGain information in the form of the AVReplayGain struct. |
||||
*/ |
||||
AV_FRAME_DATA_REPLAYGAIN, |
||||
/**
|
||||
* This side data contains a 3x3 transformation matrix describing an affine |
||||
* transformation that needs to be applied to the frame for correct |
||||
* presentation. |
||||
* |
||||
* See libavutil/display.h for a detailed description of the data. |
||||
*/ |
||||
AV_FRAME_DATA_DISPLAYMATRIX, |
||||
/**
|
||||
* Active Format Description data consisting of a single byte as specified |
||||
* in ETSI TS 101 154 using AVActiveFormatDescription enum. |
||||
*/ |
||||
AV_FRAME_DATA_AFD, |
||||
/**
|
||||
* Motion vectors exported by some codecs (on demand through the export_mvs |
||||
* flag set in the libavcodec AVCodecContext flags2 option). |
||||
* The data is the AVMotionVector struct defined in |
||||
* libavutil/motion_vector.h. |
||||
*/ |
||||
AV_FRAME_DATA_MOTION_VECTORS, |
||||
/**
|
||||
* Recommmends skipping the specified number of samples. This is exported |
||||
* only if the "skip_manual" AVOption is set in libavcodec. |
||||
* This has the same format as AV_PKT_DATA_SKIP_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_FRAME_DATA_SKIP_SAMPLES, |
||||
/**
|
||||
* This side data must be associated with an audio frame and corresponds to |
||||
* enum AVAudioServiceType defined in avcodec.h. |
||||
*/ |
||||
AV_FRAME_DATA_AUDIO_SERVICE_TYPE, |
||||
/**
|
||||
* Mastering display metadata associated with a video frame. The payload is |
||||
* an AVMasteringDisplayMetadata type and contains information about the |
||||
* mastering display color volume. |
||||
*/ |
||||
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA, |
||||
/**
|
||||
* The GOP timecode in 25 bit timecode format. Data format is 64-bit integer. |
||||
* This is set on the first frame of a GOP that has a temporal reference of 0. |
||||
*/ |
||||
AV_FRAME_DATA_GOP_TIMECODE, |
||||
|
||||
/**
|
||||
* The data represents the AVSphericalMapping structure defined in |
||||
* libavutil/spherical.h. |
||||
*/ |
||||
AV_FRAME_DATA_SPHERICAL, |
||||
|
||||
/**
|
||||
* Content light level (based on CTA-861.3). This payload contains data in |
||||
* the form of the AVContentLightMetadata struct. |
||||
*/ |
||||
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL, |
||||
|
||||
/**
|
||||
* The data contains an ICC profile as an opaque octet buffer following the |
||||
* format described by ISO 15076-1 with an optional name defined in the |
||||
* metadata key entry "name". |
||||
*/ |
||||
AV_FRAME_DATA_ICC_PROFILE, |
||||
|
||||
/**
|
||||
* 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 documentation of av_timecode_get_smpte_from_framenum() |
||||
* function in libavutil/timecode.h. |
||||
*/ |
||||
AV_FRAME_DATA_S12M_TIMECODE, |
||||
|
||||
/**
|
||||
* HDR dynamic metadata associated with a video frame. The payload is |
||||
* an AVDynamicHDRPlus type and contains information for color |
||||
* 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, |
||||
|
||||
/**
|
||||
* Ambient viewing environment metadata, as defined by H.274. |
||||
*/ |
||||
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT, |
||||
}; |
||||
|
||||
enum AVActiveFormatDescription { |
||||
AV_AFD_SAME = 8, |
||||
AV_AFD_4_3 = 9, |
||||
AV_AFD_16_9 = 10, |
||||
AV_AFD_14_9 = 11, |
||||
AV_AFD_4_3_SP_14_9 = 13, |
||||
AV_AFD_16_9_SP_14_9 = 14, |
||||
AV_AFD_SP_4_3 = 15, |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* Structure to hold side data for an AVFrame. |
||||
* |
||||
* sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added |
||||
* to the end with a minor bump. |
||||
*/ |
||||
typedef struct AVFrameSideData { |
||||
enum AVFrameSideDataType type; |
||||
uint8_t *data; |
||||
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. |
||||
* |
||||
* AVFrame must be allocated using av_frame_alloc(). Note that this only |
||||
* allocates the AVFrame itself, the buffers for the data must be managed |
||||
* through other means (see below). |
||||
* AVFrame must be freed with av_frame_free(). |
||||
* |
||||
* AVFrame is typically allocated once and then reused multiple times to hold |
||||
* different data (e.g. a single AVFrame to hold frames received from a |
||||
* decoder). In such a case, av_frame_unref() will free any references held by |
||||
* the frame and reset it to its original clean state before it |
||||
* is reused again. |
||||
* |
||||
* The data described by an AVFrame is usually reference counted through the |
||||
* AVBuffer API. The underlying buffer references are stored in AVFrame.buf / |
||||
* AVFrame.extended_buf. An AVFrame is considered to be reference counted if at |
||||
* least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case, |
||||
* every single data plane must be contained in one of the buffers in |
||||
* AVFrame.buf or AVFrame.extended_buf. |
||||
* There may be a single buffer for all the data, or one separate buffer for |
||||
* each plane, or anything in between. |
||||
* |
||||
* sizeof(AVFrame) is not a part of the public ABI, so new fields may be added |
||||
* to the end with a minor bump. |
||||
* |
||||
* Fields can be accessed through AVOptions, the name string used, matches the |
||||
* C structure field name for fields accessible through AVOptions. The AVClass |
||||
* for AVFrame can be obtained from avcodec_get_frame_class() |
||||
*/ |
||||
typedef struct AVFrame { |
||||
#define AV_NUM_DATA_POINTERS 8 |
||||
/**
|
||||
* pointer to the picture/channel planes. |
||||
* 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: 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, 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. |
||||
* |
||||
* For video the linesizes should be multiples of the CPUs alignment |
||||
* preference, this is 16 or 32 for modern desktop CPUs. |
||||
* Some code requires such alignment other code can be slower without |
||||
* correct alignment, for yet other it makes no difference. |
||||
* |
||||
* @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]; |
||||
|
||||
/**
|
||||
* pointers to the data planes/channels. |
||||
* |
||||
* For video, this should simply point to data[]. |
||||
* |
||||
* For planar audio, each channel has a separate data pointer, and |
||||
* linesize[0] contains the size of each channel buffer. |
||||
* For packed audio, there is just one data pointer, and linesize[0] |
||||
* contains the total size of the buffer for all channels. |
||||
* |
||||
* Note: Both data and extended_data should always be set in a valid frame, |
||||
* but for planar audio with more channels that can fit in data, |
||||
* extended_data must be used in order to access all channels. |
||||
*/ |
||||
uint8_t **extended_data; |
||||
|
||||
/**
|
||||
* @name Video dimensions |
||||
* Video frames only. The coded dimensions (in pixels) of the video frame, |
||||
* i.e. the size of the rectangle that contains some well-defined values. |
||||
* |
||||
* @note The part of the frame intended for display/presentation is further |
||||
* restricted by the @ref cropping "Cropping rectangle". |
||||
* @{ |
||||
*/ |
||||
int width, height; |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* number of audio samples (per channel) described by this frame |
||||
*/ |
||||
int nb_samples; |
||||
|
||||
/**
|
||||
* format of the frame, -1 if unknown or unset |
||||
* Values correspond to enum AVPixelFormat for video frames, |
||||
* enum AVSampleFormat for audio) |
||||
*/ |
||||
int format; |
||||
|
||||
/**
|
||||
* 1 -> keyframe, 0-> not |
||||
*/ |
||||
int key_frame; |
||||
|
||||
/**
|
||||
* Picture type of the frame. |
||||
*/ |
||||
enum AVPictureType pict_type; |
||||
|
||||
/**
|
||||
* Sample aspect ratio for the video frame, 0/1 if unknown/unspecified. |
||||
*/ |
||||
AVRational sample_aspect_ratio; |
||||
|
||||
/**
|
||||
* Presentation timestamp in time_base units (time when frame should be shown to user). |
||||
*/ |
||||
int64_t pts; |
||||
|
||||
/**
|
||||
* 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 |
||||
* only AVPacket.dts values without pts values. |
||||
*/ |
||||
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; |
||||
|
||||
#if FF_API_FRAME_PICTURE_NUMBER |
||||
/**
|
||||
* picture number in bitstream order |
||||
*/ |
||||
attribute_deprecated |
||||
int coded_picture_number; |
||||
/**
|
||||
* picture number in display order |
||||
*/ |
||||
attribute_deprecated |
||||
int display_picture_number; |
||||
#endif |
||||
|
||||
/**
|
||||
* quality (between 1 (good) and FF_LAMBDA_MAX (bad)) |
||||
*/ |
||||
int quality; |
||||
|
||||
/**
|
||||
* for some private data of the user |
||||
*/ |
||||
void *opaque; |
||||
|
||||
/**
|
||||
* When decoding, this signals how much the picture must be delayed. |
||||
* extra_delay = repeat_pict / (2*fps) |
||||
*/ |
||||
int repeat_pict; |
||||
|
||||
/**
|
||||
* The content of the picture is interlaced. |
||||
*/ |
||||
int interlaced_frame; |
||||
|
||||
/**
|
||||
* If the content is interlaced, is top field displayed first. |
||||
*/ |
||||
int top_field_first; |
||||
|
||||
/**
|
||||
* Tell user application that palette has changed from previous frame. |
||||
*/ |
||||
int palette_has_changed; |
||||
|
||||
#if FF_API_REORDERED_OPAQUE |
||||
/**
|
||||
* reordered opaque 64 bits (generally an integer or a double precision float |
||||
* PTS but can be anything). |
||||
* The user sets AVCodecContext.reordered_opaque to represent the input at |
||||
* that time, |
||||
* the decoder reorders values as needed and sets AVFrame.reordered_opaque |
||||
* to exactly one of the values provided by the user through AVCodecContext.reordered_opaque |
||||
* |
||||
* @deprecated Use AV_CODEC_FLAG_COPY_OPAQUE instead |
||||
*/ |
||||
attribute_deprecated |
||||
int64_t reordered_opaque; |
||||
#endif |
||||
|
||||
/**
|
||||
* Sample rate of the audio data. |
||||
*/ |
||||
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. 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 |
||||
* AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in |
||||
* this array. Then the extra AVBufferRef pointers are stored in the |
||||
* extended_buf array. |
||||
*/ |
||||
AVBufferRef *buf[AV_NUM_DATA_POINTERS]; |
||||
|
||||
/**
|
||||
* For planar audio which requires more than AV_NUM_DATA_POINTERS |
||||
* AVBufferRef pointers, this array will hold all the references which |
||||
* cannot fit into AVFrame.buf. |
||||
* |
||||
* Note that this is different from AVFrame.extended_data, which always |
||||
* contains all the pointers. This array only contains the extra pointers, |
||||
* which cannot fit into AVFrame.buf. |
||||
* |
||||
* This array is always allocated using av_malloc() by whoever constructs |
||||
* the frame. It is freed in av_frame_unref(). |
||||
*/ |
||||
AVBufferRef **extended_buf; |
||||
/**
|
||||
* Number of elements in extended_buf. |
||||
*/ |
||||
int nb_extended_buf; |
||||
|
||||
AVFrameSideData **side_data; |
||||
int nb_side_data; |
||||
|
||||
/**
|
||||
* @defgroup lavu_frame_flags AV_FRAME_FLAGS |
||||
* @ingroup lavu_frame |
||||
* Flags describing additional frame properties. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* The frame data may be corrupted, e.g. due to decoding errors. |
||||
*/ |
||||
#define AV_FRAME_FLAG_CORRUPT (1 << 0) |
||||
/**
|
||||
* A flag to mark the frames which need to be decoded, but shouldn't be output. |
||||
*/ |
||||
#define AV_FRAME_FLAG_DISCARD (1 << 2) |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* Frame flags, a combination of @ref lavu_frame_flags |
||||
*/ |
||||
int flags; |
||||
|
||||
/**
|
||||
* MPEG vs JPEG YUV range. |
||||
* - encoding: Set by user |
||||
* - decoding: Set by libavcodec |
||||
*/ |
||||
enum AVColorRange color_range; |
||||
|
||||
enum AVColorPrimaries color_primaries; |
||||
|
||||
enum AVColorTransferCharacteristic color_trc; |
||||
|
||||
/**
|
||||
* YUV colorspace type. |
||||
* - encoding: Set by user |
||||
* - decoding: Set by libavcodec |
||||
*/ |
||||
enum AVColorSpace colorspace; |
||||
|
||||
enum AVChromaLocation chroma_location; |
||||
|
||||
/**
|
||||
* frame timestamp estimated using various heuristics, in stream time base |
||||
* - encoding: unused |
||||
* - decoding: set by libavcodec, read by user. |
||||
*/ |
||||
int64_t best_effort_timestamp; |
||||
|
||||
/**
|
||||
* reordered pos from the last AVPacket that has been input into the decoder |
||||
* - encoding: unused |
||||
* - decoding: Read by user. |
||||
*/ |
||||
int64_t pkt_pos; |
||||
|
||||
#if FF_API_PKT_DURATION |
||||
/**
|
||||
* duration of the corresponding packet, expressed in |
||||
* AVStream->time_base units, 0 if unknown. |
||||
* - encoding: unused |
||||
* - decoding: Read by user. |
||||
* |
||||
* @deprecated use duration instead |
||||
*/ |
||||
attribute_deprecated |
||||
int64_t pkt_duration; |
||||
#endif |
||||
|
||||
/**
|
||||
* metadata. |
||||
* - encoding: Set by user. |
||||
* - decoding: Set by libavcodec. |
||||
*/ |
||||
AVDictionary *metadata; |
||||
|
||||
/**
|
||||
* decode error flags of the frame, set to a combination of |
||||
* FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there |
||||
* were errors during the decoding. |
||||
* - encoding: unused |
||||
* - decoding: set by libavcodec, read by user. |
||||
*/ |
||||
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 |
||||
* frame. |
||||
* It is set to a negative value if unknown. |
||||
* - encoding: unused |
||||
* - decoding: set by libavcodec, read by user. |
||||
*/ |
||||
int pkt_size; |
||||
|
||||
/**
|
||||
* For hwaccel-format frames, this should be a reference to the |
||||
* AVHWFramesContext describing the frame. |
||||
*/ |
||||
AVBufferRef *hw_frames_ctx; |
||||
|
||||
/**
|
||||
* 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 frame is unreferenced. av_frame_copy_props() calls create a new |
||||
* reference with av_buffer_ref() for the target frame's opaque_ref field. |
||||
* |
||||
* This is unrelated to the opaque field, although it serves a similar |
||||
* purpose. |
||||
*/ |
||||
AVBufferRef *opaque_ref; |
||||
|
||||
/**
|
||||
* @anchor cropping |
||||
* @name Cropping |
||||
* Video frames only. The number of pixels to discard from the the |
||||
* top/bottom/left/right border of the frame to obtain the sub-rectangle of |
||||
* the frame intended for presentation. |
||||
* @{ |
||||
*/ |
||||
size_t crop_top; |
||||
size_t crop_bottom; |
||||
size_t crop_left; |
||||
size_t crop_right; |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* AVBufferRef for internal use by a single libav* library. |
||||
* Must not be used to transfer data between libraries. |
||||
* Has to be NULL when ownership of the frame leaves the respective library. |
||||
* |
||||
* Code outside the FFmpeg libs should never check or change the contents of the buffer ref. |
||||
* |
||||
* FFmpeg calls av_buffer_unref() on it when the frame is unreferenced. |
||||
* av_frame_copy_props() calls create a new reference with av_buffer_ref() |
||||
* for the target frame's private_ref field. |
||||
*/ |
||||
AVBufferRef *private_ref; |
||||
|
||||
/**
|
||||
* Channel layout of the audio data. |
||||
*/ |
||||
AVChannelLayout ch_layout; |
||||
|
||||
/**
|
||||
* Duration of the frame, in the same units as pts. 0 if unknown. |
||||
*/ |
||||
int64_t duration; |
||||
} AVFrame; |
||||
|
||||
|
||||
/**
|
||||
* Allocate an AVFrame and set its fields to default values. The resulting |
||||
* struct must be freed using av_frame_free(). |
||||
* |
||||
* @return An AVFrame filled with default values or NULL on failure. |
||||
* |
||||
* @note this only allocates the AVFrame itself, not the data buffers. Those |
||||
* must be allocated through other means, e.g. with av_frame_get_buffer() or |
||||
* manually. |
||||
*/ |
||||
AVFrame *av_frame_alloc(void); |
||||
|
||||
/**
|
||||
* Free the frame and any dynamically allocated objects in it, |
||||
* e.g. extended_data. If the frame is reference counted, it will be |
||||
* unreferenced first. |
||||
* |
||||
* @param frame frame to be freed. The pointer will be set to NULL. |
||||
*/ |
||||
void av_frame_free(AVFrame **frame); |
||||
|
||||
/**
|
||||
* Set up a new reference to the data described by the source frame. |
||||
* |
||||
* Copy frame properties from src to dst and create a new reference for each |
||||
* AVBufferRef from src. |
||||
* |
||||
* If src is not reference counted, new buffers are allocated and the data is |
||||
* copied. |
||||
* |
||||
* @warning: dst MUST have been either unreferenced with av_frame_unref(dst), |
||||
* or newly allocated with av_frame_alloc() before calling this |
||||
* function, or undefined behavior will occur. |
||||
* |
||||
* @return 0 on success, a negative AVERROR on error |
||||
*/ |
||||
int av_frame_ref(AVFrame *dst, const AVFrame *src); |
||||
|
||||
/**
|
||||
* Create a new frame that references the same data as src. |
||||
* |
||||
* This is a shortcut for av_frame_alloc()+av_frame_ref(). |
||||
* |
||||
* @return newly created AVFrame on success, NULL on error. |
||||
*/ |
||||
AVFrame *av_frame_clone(const AVFrame *src); |
||||
|
||||
/**
|
||||
* Unreference all the buffers referenced by frame and reset the frame fields. |
||||
*/ |
||||
void av_frame_unref(AVFrame *frame); |
||||
|
||||
/**
|
||||
* Move everything contained in src to dst and reset src. |
||||
* |
||||
* @warning: dst is not unreferenced, but directly overwritten without reading |
||||
* or deallocating its contents. Call av_frame_unref(dst) manually |
||||
* before calling this function to ensure that no memory is leaked. |
||||
*/ |
||||
void av_frame_move_ref(AVFrame *dst, AVFrame *src); |
||||
|
||||
/**
|
||||
* Allocate new buffer(s) for audio or video data. |
||||
* |
||||
* 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 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. |
||||
* For planar formats, one buffer will be allocated for each plane. |
||||
* |
||||
* @warning: if frame already has been allocated, calling this function will |
||||
* leak memory. In addition, undefined behavior can occur in certain |
||||
* cases. |
||||
* |
||||
* @param frame frame in which to store the new buffers. |
||||
* @param align Required buffer size alignment. If equal to 0, alignment will be |
||||
* chosen automatically for the current CPU. It is highly |
||||
* recommended to pass 0 here unless you know what you are doing. |
||||
* |
||||
* @return 0 on success, a negative AVERROR on error. |
||||
*/ |
||||
int av_frame_get_buffer(AVFrame *frame, int align); |
||||
|
||||
/**
|
||||
* Check if the frame data is writable. |
||||
* |
||||
* @return A positive value if the frame data is writable (which is true if and |
||||
* only if each of the underlying buffers has only one reference, namely the one |
||||
* stored in this frame). Return 0 otherwise. |
||||
* |
||||
* If 1 is returned the answer is valid until av_buffer_ref() is called on any |
||||
* of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly). |
||||
* |
||||
* @see av_frame_make_writable(), av_buffer_is_writable() |
||||
*/ |
||||
int av_frame_is_writable(AVFrame *frame); |
||||
|
||||
/**
|
||||
* Ensure that the frame data is writable, avoiding data copy if possible. |
||||
* |
||||
* Do nothing if the frame is writable, allocate new buffers and copy the data |
||||
* if it is not. Non-refcounted frames behave as non-writable, i.e. a copy |
||||
* is always made. |
||||
* |
||||
* @return 0 on success, a negative AVERROR on error. |
||||
* |
||||
* @see av_frame_is_writable(), av_buffer_is_writable(), |
||||
* av_buffer_make_writable() |
||||
*/ |
||||
int av_frame_make_writable(AVFrame *frame); |
||||
|
||||
/**
|
||||
* Copy the frame data from src to dst. |
||||
* |
||||
* This function does not allocate anything, dst must be already initialized and |
||||
* allocated with the same parameters as src. |
||||
* |
||||
* This function only copies the frame data (i.e. the contents of the data / |
||||
* extended data arrays), not any other properties. |
||||
* |
||||
* @return >= 0 on success, a negative AVERROR on error. |
||||
*/ |
||||
int av_frame_copy(AVFrame *dst, const AVFrame *src); |
||||
|
||||
/**
|
||||
* Copy only "metadata" fields from src to dst. |
||||
* |
||||
* Metadata for the purpose of this function are those fields that do not affect |
||||
* the data layout in the buffers. E.g. pts, sample rate (for audio) or sample |
||||
* aspect ratio (for video), but not width/height or channel layout. |
||||
* Side data is also copied. |
||||
*/ |
||||
int av_frame_copy_props(AVFrame *dst, const AVFrame *src); |
||||
|
||||
/**
|
||||
* Get the buffer reference a given data plane is stored in. |
||||
* |
||||
* @param frame the frame to get the plane's buffer from |
||||
* @param plane index of the data plane of interest in frame->extended_data. |
||||
* |
||||
* @return the buffer reference that contains the plane or NULL if the input |
||||
* frame is not valid. |
||||
*/ |
||||
AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane); |
||||
|
||||
/**
|
||||
* Add a new side data to a frame. |
||||
* |
||||
* @param frame a frame to which the side data should be added |
||||
* @param type type of the added side data |
||||
* @param size size of the side data |
||||
* |
||||
* @return newly added side data on success, NULL on error |
||||
*/ |
||||
AVFrameSideData *av_frame_new_side_data(AVFrame *frame, |
||||
enum AVFrameSideDataType type, |
||||
size_t size); |
||||
|
||||
/**
|
||||
* Add a new side data to a frame from an existing AVBufferRef |
||||
* |
||||
* @param frame a frame to which the side data should be added |
||||
* @param type the type of the added side data |
||||
* @param buf an AVBufferRef to add as side data. The ownership of |
||||
* the reference is transferred to the frame. |
||||
* |
||||
* @return newly added side data on success, NULL on error. On failure |
||||
* the frame is unchanged and the AVBufferRef remains owned by |
||||
* the caller. |
||||
*/ |
||||
AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame, |
||||
enum AVFrameSideDataType type, |
||||
AVBufferRef *buf); |
||||
|
||||
/**
|
||||
* @return a pointer to the side data of a given type on success, NULL if there |
||||
* is no side data with such type in this frame. |
||||
*/ |
||||
AVFrameSideData *av_frame_get_side_data(const AVFrame *frame, |
||||
enum AVFrameSideDataType type); |
||||
|
||||
/**
|
||||
* Remove and free all side data instances of the given type. |
||||
*/ |
||||
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type); |
||||
|
||||
|
||||
/**
|
||||
* Flags for frame cropping. |
||||
*/ |
||||
enum { |
||||
/**
|
||||
* Apply the maximum possible cropping, even if it requires setting the |
||||
* AVFrame.data[] entries to unaligned pointers. Passing unaligned data |
||||
* to FFmpeg API is generally not allowed, and causes undefined behavior |
||||
* (such as crashes). You can pass unaligned data only to FFmpeg APIs that |
||||
* are explicitly documented to accept it. Use this flag only if you |
||||
* absolutely know what you are doing. |
||||
*/ |
||||
AV_FRAME_CROP_UNALIGNED = 1 << 0, |
||||
}; |
||||
|
||||
/**
|
||||
* Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ |
||||
* crop_bottom fields. If cropping is successful, the function will adjust the |
||||
* data pointers and the width/height fields, and set the crop fields to 0. |
||||
* |
||||
* In all cases, the cropping boundaries will be rounded to the inherent |
||||
* alignment of the pixel format. In some cases, such as for opaque hwaccel |
||||
* formats, the left/top cropping is ignored. The crop fields are set to 0 even |
||||
* if the cropping was rounded or ignored. |
||||
* |
||||
* @param frame the frame which should be cropped |
||||
* @param flags Some combination of AV_FRAME_CROP_* flags, or 0. |
||||
* |
||||
* @return >= 0 on success, a negative AVERROR on error. If the cropping fields |
||||
* were invalid, AVERROR(ERANGE) is returned, and nothing is changed. |
||||
*/ |
||||
int av_frame_apply_cropping(AVFrame *frame, int flags); |
||||
|
||||
/**
|
||||
* @return a string identifying the side data type |
||||
*/ |
||||
const char *av_frame_side_data_name(enum AVFrameSideDataType type); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_FRAME_H */ |
||||
@ -0,0 +1,86 @@ |
||||
/*
|
||||
* 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_GETENV_UTF8_H |
||||
#define AVUTIL_GETENV_UTF8_H |
||||
|
||||
#include <stdlib.h> |
||||
|
||||
#include "config.h" |
||||
#include "mem.h" |
||||
|
||||
#if HAVE_GETENV && defined(_WIN32) |
||||
|
||||
#include "libavutil/wchar_filename.h" |
||||
|
||||
static inline char *getenv_utf8(const char *varname) |
||||
{ |
||||
wchar_t *varname_w, *var_w; |
||||
char *var; |
||||
|
||||
if (utf8towchar(varname, &varname_w)) |
||||
return NULL; |
||||
if (!varname_w) |
||||
return NULL; |
||||
|
||||
var_w = _wgetenv(varname_w); |
||||
av_free(varname_w); |
||||
|
||||
if (!var_w) |
||||
return NULL; |
||||
if (wchartoutf8(var_w, &var)) |
||||
return NULL; |
||||
|
||||
return var; |
||||
|
||||
// No CP_ACP fallback compared to other *_utf8() functions:
|
||||
// non UTF-8 strings must not be returned.
|
||||
} |
||||
|
||||
static inline void freeenv_utf8(char *var) |
||||
{ |
||||
av_free(var); |
||||
} |
||||
|
||||
static inline char *getenv_dup(const char *varname) |
||||
{ |
||||
return getenv_utf8(varname); |
||||
} |
||||
|
||||
#else |
||||
|
||||
static inline char *getenv_utf8(const char *varname) |
||||
{ |
||||
return getenv(varname); |
||||
} |
||||
|
||||
static inline void freeenv_utf8(char *var) |
||||
{ |
||||
} |
||||
|
||||
static inline char *getenv_dup(const char *varname) |
||||
{ |
||||
char *var = getenv(varname); |
||||
if (!var) |
||||
return NULL; |
||||
return av_strdup(var); |
||||
} |
||||
|
||||
#endif // HAVE_GETENV && defined(_WIN32)
|
||||
|
||||
#endif // AVUTIL_GETENV_UTF8_H
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue