parent
f76cacb349
commit
1d0c9af7d8
File diff suppressed because it is too large
Load Diff
@ -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 */ |
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,325 @@ |
||||
/*
|
||||
* 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" |
||||
|
||||
/**
|
||||
* @addtogroup lavc_core |
||||
* @{ |
||||
*/ |
||||
|
||||
typedef struct AVBSFInternal AVBSFInternal; |
||||
|
||||
/**
|
||||
* 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 libavcodec internal data. Must not be touched by the caller in any |
||||
* way. |
||||
*/ |
||||
AVBSFInternal *internal; |
||||
|
||||
/**
|
||||
* 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; |
||||
|
||||
/*****************************************************************
|
||||
* No fields below this line are part of the public API. They |
||||
* may not be used outside of libavcodec and can be changed and |
||||
* removed at will. |
||||
* New public fields should be added right above. |
||||
***************************************************************** |
||||
*/ |
||||
|
||||
int priv_data_size; |
||||
int (*init)(AVBSFContext *ctx); |
||||
int (*filter)(AVBSFContext *ctx, AVPacket *pkt); |
||||
void (*close)(AVBSFContext *ctx); |
||||
void (*flush)(AVBSFContext *ctx); |
||||
} AVBitStreamFilter; |
||||
|
||||
/**
|
||||
* @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 ctx a pointer into which the pointer to the newly-allocated context |
||||
* will be written. It must be freed with av_bsf_free() after the |
||||
* filtering is done. |
||||
* |
||||
* @return 0 on success, a negative AVERROR code on failure |
||||
*/ |
||||
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx); |
||||
|
||||
/**
|
||||
* Prepare the filter for use, after all the parameters and options have been |
||||
* set. |
||||
*/ |
||||
int av_bsf_init(AVBSFContext *ctx); |
||||
|
||||
/**
|
||||
* Submit a packet for filtering. |
||||
* |
||||
* After sending each packet, the filter must be completely drained by calling |
||||
* av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or |
||||
* AVERROR_EOF. |
||||
* |
||||
* @param pkt the packet to filter. The bitstream filter will take ownership of |
||||
* the packet and reset the contents of pkt. pkt is not touched if an error occurs. |
||||
* If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero), |
||||
* it signals the end of the stream (i.e. no more non-empty packets will be sent; |
||||
* sending more empty packets does nothing) and will cause the filter to output |
||||
* any packets it may have buffered internally. |
||||
* |
||||
* @return 0 on success. AVERROR(EAGAIN) if packets need to be retrieved from the |
||||
* filter (using av_bsf_receive_packet()) before new input can be consumed. Another |
||||
* negative AVERROR value if an error occurs. |
||||
*/ |
||||
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt); |
||||
|
||||
/**
|
||||
* Retrieve a filtered packet. |
||||
* |
||||
* @param[out] pkt this struct will be filled with the contents of the filtered |
||||
* packet. It is owned by the caller and must be freed using |
||||
* av_packet_unref() when it is no longer needed. |
||||
* This parameter should be "clean" (i.e. freshly allocated |
||||
* with av_packet_alloc() or unreffed with av_packet_unref()) |
||||
* when this function is called. If this function returns |
||||
* successfully, the contents of pkt will be completely |
||||
* overwritten by the returned data. On failure, pkt is not |
||||
* touched. |
||||
* |
||||
* @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the |
||||
* filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there |
||||
* will be no further output from the filter. Another negative AVERROR value if |
||||
* an error occurs. |
||||
* |
||||
* @note one input packet may result in several output packets, so after sending |
||||
* a packet with av_bsf_send_packet(), this function needs to be called |
||||
* repeatedly until it stops returning 0. It is also possible for a filter to |
||||
* output fewer packets than were sent to it, so this function may return |
||||
* AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call. |
||||
*/ |
||||
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt); |
||||
|
||||
/**
|
||||
* Reset the internal bitstream filter state. Should be called e.g. when seeking. |
||||
*/ |
||||
void av_bsf_flush(AVBSFContext *ctx); |
||||
|
||||
/**
|
||||
* Free a bitstream filter context and everything associated with it; write NULL |
||||
* into the supplied pointer. |
||||
*/ |
||||
void av_bsf_free(AVBSFContext **ctx); |
||||
|
||||
/**
|
||||
* Get the AVClass for AVBSFContext. It can be used in combination with |
||||
* AV_OPT_SEARCH_FAKE_OBJ for examining options. |
||||
* |
||||
* @see av_opt_find(). |
||||
*/ |
||||
const AVClass *av_bsf_get_class(void); |
||||
|
||||
/**
|
||||
* Structure for chain/list of bitstream filters. |
||||
* Empty list can be allocated by av_bsf_list_alloc(). |
||||
*/ |
||||
typedef struct AVBSFList AVBSFList; |
||||
|
||||
/**
|
||||
* Allocate empty list of bitstream filters. |
||||
* The list must be later freed by av_bsf_list_free() |
||||
* or finalized by av_bsf_list_finalize(). |
||||
* |
||||
* @return Pointer to @ref AVBSFList on success, NULL in case of failure |
||||
*/ |
||||
AVBSFList *av_bsf_list_alloc(void); |
||||
|
||||
/**
|
||||
* Free list of bitstream filters. |
||||
* |
||||
* @param lst Pointer to pointer returned by av_bsf_list_alloc() |
||||
*/ |
||||
void av_bsf_list_free(AVBSFList **lst); |
||||
|
||||
/**
|
||||
* Append bitstream filter to the list of bitstream filters. |
||||
* |
||||
* @param lst List to append to |
||||
* @param bsf Filter context to be appended |
||||
* |
||||
* @return >=0 on success, negative AVERROR in case of failure |
||||
*/ |
||||
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf); |
||||
|
||||
/**
|
||||
* Construct new bitstream filter context given it's name and options |
||||
* and append it to the list of bitstream filters. |
||||
* |
||||
* @param lst List to append to |
||||
* @param bsf_name Name of the bitstream filter |
||||
* @param options Options for the bitstream filter, can be set to NULL |
||||
* |
||||
* @return >=0 on success, negative AVERROR in case of failure |
||||
*/ |
||||
int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options); |
||||
/**
|
||||
* Finalize list of bitstream filters. |
||||
* |
||||
* This function will transform @ref AVBSFList to single @ref AVBSFContext, |
||||
* so the whole chain of bitstream filters can be treated as single filter |
||||
* freshly allocated by av_bsf_alloc(). |
||||
* If the call is successful, @ref AVBSFList structure is freed and lst |
||||
* will be set to NULL. In case of failure, caller is responsible for |
||||
* freeing the structure by av_bsf_list_free() |
||||
* |
||||
* @param lst Filter list structure to be transformed |
||||
* @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure |
||||
* representing the chain of bitstream filters |
||||
* |
||||
* @return >=0 on success, negative AVERROR in case of failure |
||||
*/ |
||||
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf); |
||||
|
||||
/**
|
||||
* Parse string describing list of bitstream filters and create single |
||||
* @ref AVBSFContext describing the whole chain of bitstream filters. |
||||
* Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly |
||||
* allocated by av_bsf_alloc(). |
||||
* |
||||
* @param str String describing chain of bitstream filters in format |
||||
* `bsf1[=opt1=val1:opt2=val2][,bsf2]` |
||||
* @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure |
||||
* representing the chain of bitstream filters |
||||
* |
||||
* @return >=0 on success, negative AVERROR in case of failure |
||||
*/ |
||||
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf); |
||||
|
||||
/**
|
||||
* Get null/pass-through bitstream filter. |
||||
* |
||||
* @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter |
||||
* |
||||
* @return |
||||
*/ |
||||
int av_bsf_get_null_filter(AVBSFContext **bsf); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif // AVCODEC_BSF_H
|
@ -0,0 +1,480 @@ |
||||
/*
|
||||
* AVCodec public API |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_CODEC_H |
||||
#define AVCODEC_CODEC_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "libavutil/avutil.h" |
||||
#include "libavutil/hwcontext.h" |
||||
#include "libavutil/log.h" |
||||
#include "libavutil/pixfmt.h" |
||||
#include "libavutil/rational.h" |
||||
#include "libavutil/samplefmt.h" |
||||
|
||||
#include "libavcodec/codec_id.h" |
||||
#include "libavcodec/version.h" |
||||
|
||||
/**
|
||||
* @addtogroup lavc_core |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Decoder can use draw_horiz_band callback. |
||||
*/ |
||||
#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0) |
||||
/**
|
||||
* Codec uses get_buffer() or get_encode_buffer() for allocating buffers and |
||||
* supports custom allocators. |
||||
* If not set, it might not use get_buffer() or get_encode_buffer() at all, or |
||||
* use operations that assume the buffer was allocated by |
||||
* avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer. |
||||
*/ |
||||
#define AV_CODEC_CAP_DR1 (1 << 1) |
||||
#define AV_CODEC_CAP_TRUNCATED (1 << 3) |
||||
/**
|
||||
* Encoder or decoder requires flushing with NULL input at the end in order to |
||||
* give the complete and correct output. |
||||
* |
||||
* NOTE: If this flag is not set, the codec is guaranteed to never be fed with |
||||
* with NULL data. The user can still send NULL data to the public encode |
||||
* or decode function, but libavcodec will not pass it along to the codec |
||||
* unless this flag is set. |
||||
* |
||||
* Decoders: |
||||
* The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL, |
||||
* avpkt->size=0 at the end to get the delayed data until the decoder no longer |
||||
* returns frames. |
||||
* |
||||
* Encoders: |
||||
* The encoder needs to be fed with NULL data at the end of encoding until the |
||||
* encoder no longer returns data. |
||||
* |
||||
* NOTE: For encoders implementing the AVCodec.encode2() function, setting this |
||||
* flag also means that the encoder must set the pts and duration for |
||||
* each output packet. If this flag is not set, the pts and duration will |
||||
* be determined by libavcodec from the input frame. |
||||
*/ |
||||
#define AV_CODEC_CAP_DELAY (1 << 5) |
||||
/**
|
||||
* Codec can be fed a final frame with a smaller size. |
||||
* This can be used to prevent truncation of the last audio samples. |
||||
*/ |
||||
#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6) |
||||
|
||||
/**
|
||||
* Codec can output multiple frames per AVPacket |
||||
* Normally demuxers return one frame at a time, demuxers which do not do |
||||
* are connected to a parser to split what they return into proper frames. |
||||
* This flag is reserved to the very rare category of codecs which have a |
||||
* bitstream that cannot be split into frames without timeconsuming |
||||
* operations like full decoding. Demuxers carrying such bitstreams thus |
||||
* may return multiple frames in a packet. This has many disadvantages like |
||||
* prohibiting stream copy in many cases thus it should only be considered |
||||
* as a last resort. |
||||
*/ |
||||
#define AV_CODEC_CAP_SUBFRAMES (1 << 8) |
||||
/**
|
||||
* Codec is experimental and is thus avoided in favor of non experimental |
||||
* encoders |
||||
*/ |
||||
#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9) |
||||
/**
|
||||
* Codec should fill in channel configuration and samplerate instead of container |
||||
*/ |
||||
#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10) |
||||
/**
|
||||
* Codec supports frame-level multithreading. |
||||
*/ |
||||
#define AV_CODEC_CAP_FRAME_THREADS (1 << 12) |
||||
/**
|
||||
* Codec supports slice-based (or partition-based) multithreading. |
||||
*/ |
||||
#define AV_CODEC_CAP_SLICE_THREADS (1 << 13) |
||||
/**
|
||||
* Codec supports changed parameters at any point. |
||||
*/ |
||||
#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14) |
||||
/**
|
||||
* Codec supports multithreading through a method other than slice- or |
||||
* frame-level multithreading. Typically this marks wrappers around |
||||
* multithreading-capable external libraries. |
||||
*/ |
||||
#define AV_CODEC_CAP_OTHER_THREADS (1 << 15) |
||||
#if FF_API_AUTO_THREADS |
||||
#define AV_CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_OTHER_THREADS |
||||
#endif |
||||
/**
|
||||
* Audio encoder supports receiving a different number of samples in each call. |
||||
*/ |
||||
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16) |
||||
/**
|
||||
* Decoder is not a preferred choice for probing. |
||||
* This indicates that the decoder is not a good choice for probing. |
||||
* It could for example be an expensive to spin up hardware decoder, |
||||
* or it could simply not provide a lot of useful information about |
||||
* the stream. |
||||
* A decoder marked with this flag should only be used as last resort |
||||
* choice for probing. |
||||
*/ |
||||
#define AV_CODEC_CAP_AVOID_PROBING (1 << 17) |
||||
|
||||
#if FF_API_UNUSED_CODEC_CAPS |
||||
/**
|
||||
* Deprecated and unused. Use AVCodecDescriptor.props instead |
||||
*/ |
||||
#define AV_CODEC_CAP_INTRA_ONLY 0x40000000 |
||||
/**
|
||||
* Deprecated and unused. Use AVCodecDescriptor.props instead |
||||
*/ |
||||
#define AV_CODEC_CAP_LOSSLESS 0x80000000 |
||||
#endif |
||||
|
||||
/**
|
||||
* Codec is backed by a hardware implementation. Typically used to |
||||
* identify a non-hwaccel hardware decoder. For information about hwaccels, use |
||||
* avcodec_get_hw_config() instead. |
||||
*/ |
||||
#define AV_CODEC_CAP_HARDWARE (1 << 18) |
||||
|
||||
/**
|
||||
* Codec is potentially backed by a hardware implementation, but not |
||||
* necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the |
||||
* implementation provides some sort of internal fallback. |
||||
*/ |
||||
#define AV_CODEC_CAP_HYBRID (1 << 19) |
||||
|
||||
/**
|
||||
* This codec takes the reordered_opaque field from input AVFrames |
||||
* and returns it in the corresponding field in AVCodecContext after |
||||
* encoding. |
||||
*/ |
||||
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20) |
||||
|
||||
/**
|
||||
* This encoder can be flushed using avcodec_flush_buffers(). If this flag is |
||||
* not set, the encoder must be closed and reopened to ensure that no frames |
||||
* remain pending. |
||||
*/ |
||||
#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21) |
||||
|
||||
/**
|
||||
* AVProfile. |
||||
*/ |
||||
typedef struct AVProfile { |
||||
int profile; |
||||
const char *name; ///< short name for the profile
|
||||
} AVProfile; |
||||
|
||||
typedef struct AVCodecDefault AVCodecDefault; |
||||
|
||||
struct AVCodecContext; |
||||
struct AVSubtitle; |
||||
struct AVPacket; |
||||
|
||||
/**
|
||||
* AVCodec. |
||||
*/ |
||||
typedef struct AVCodec { |
||||
/**
|
||||
* Name of the codec implementation. |
||||
* The name is globally unique among encoders and among decoders (but an |
||||
* encoder and a decoder can share the same name). |
||||
* This is the primary way to find a codec from the user perspective. |
||||
*/ |
||||
const char *name; |
||||
/**
|
||||
* Descriptive name for the codec, meant to be more human readable than name. |
||||
* You should use the NULL_IF_CONFIG_SMALL() macro to define it. |
||||
*/ |
||||
const char *long_name; |
||||
enum AVMediaType type; |
||||
enum AVCodecID id; |
||||
/**
|
||||
* Codec capabilities. |
||||
* see AV_CODEC_CAP_* |
||||
*/ |
||||
int capabilities; |
||||
const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
|
||||
const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
|
||||
const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
|
||||
const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
|
||||
const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
|
||||
uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
|
||||
const AVClass *priv_class; ///< AVClass for the private context
|
||||
const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
|
||||
|
||||
/**
|
||||
* Group name of the codec implementation. |
||||
* This is a short symbolic name of the wrapper backing this codec. A |
||||
* wrapper uses some kind of external implementation for the codec, such |
||||
* as an external library, or a codec implementation provided by the OS or |
||||
* the hardware. |
||||
* If this field is NULL, this is a builtin, libavcodec native codec. |
||||
* If non-NULL, this will be the suffix in AVCodec.name in most cases |
||||
* (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>"). |
||||
*/ |
||||
const char *wrapper_name; |
||||
|
||||
/*****************************************************************
|
||||
* No fields below this line are part of the public API. They |
||||
* may not be used outside of libavcodec and can be changed and |
||||
* removed at will. |
||||
* New public fields should be added right above. |
||||
***************************************************************** |
||||
*/ |
||||
int priv_data_size; |
||||
#if FF_API_NEXT |
||||
struct AVCodec *next; |
||||
#endif |
||||
/**
|
||||
* @name Frame-level threading support functions |
||||
* @{ |
||||
*/ |
||||
/**
|
||||
* Copy necessary context variables from a previous thread context to the current one. |
||||
* If not defined, the next thread will start automatically; otherwise, the codec |
||||
* must call ff_thread_finish_setup(). |
||||
* |
||||
* dst and src will (rarely) point to the same context, in which case memcpy should be skipped. |
||||
*/ |
||||
int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src); |
||||
/** @} */ |
||||
|
||||
/**
|
||||
* Private codec-specific defaults. |
||||
*/ |
||||
const AVCodecDefault *defaults; |
||||
|
||||
/**
|
||||
* Initialize codec static data, called from av_codec_iterate(). |
||||
* |
||||
* This is not intended for time consuming operations as it is |
||||
* run for every codec regardless of that codec being used. |
||||
*/ |
||||
void (*init_static_data)(struct AVCodec *codec); |
||||
|
||||
int (*init)(struct AVCodecContext *); |
||||
int (*encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, |
||||
const struct AVSubtitle *sub); |
||||
/**
|
||||
* Encode data to an AVPacket. |
||||
* |
||||
* @param avctx codec context |
||||
* @param avpkt output AVPacket |
||||
* @param[in] frame AVFrame containing the raw data to be encoded |
||||
* @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a |
||||
* non-empty packet was returned in avpkt. |
||||
* @return 0 on success, negative error code on failure |
||||
*/ |
||||
int (*encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, |
||||
const struct AVFrame *frame, int *got_packet_ptr); |
||||
/**
|
||||
* Decode picture or subtitle data. |
||||
* |
||||
* @param avctx codec context |
||||
* @param outdata codec type dependent output struct |
||||
* @param[out] got_frame_ptr decoder sets to 0 or 1 to indicate that a |
||||
* non-empty frame or subtitle was returned in |
||||
* outdata. |
||||
* @param[in] avpkt AVPacket containing the data to be decoded |
||||
* @return amount of bytes read from the packet on success, negative error |
||||
* code on failure |
||||
*/ |
||||
int (*decode)(struct AVCodecContext *avctx, void *outdata, |
||||
int *got_frame_ptr, struct AVPacket *avpkt); |
||||
int (*close)(struct AVCodecContext *); |
||||
/**
|
||||
* Encode API with decoupled frame/packet dataflow. This function is called |
||||
* to get one output packet. It should call ff_encode_get_frame() to obtain |
||||
* input data. |
||||
*/ |
||||
int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt); |
||||
|
||||
/**
|
||||
* Decode API with decoupled packet/frame dataflow. This function is called |
||||
* to get one output frame. It should call ff_decode_get_packet() to obtain |
||||
* input data. |
||||
*/ |
||||
int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame); |
||||
/**
|
||||
* Flush buffers. |
||||
* Will be called when seeking |
||||
*/ |
||||
void (*flush)(struct AVCodecContext *); |
||||
/**
|
||||
* Internal codec capabilities. |
||||
* See FF_CODEC_CAP_* in internal.h |
||||
*/ |
||||
int caps_internal; |
||||
|
||||
/**
|
||||
* Decoding only, a comma-separated list of bitstream filters to apply to |
||||
* packets before decoding. |
||||
*/ |
||||
const char *bsfs; |
||||
|
||||
/**
|
||||
* Array of pointers to hardware configurations supported by the codec, |
||||
* or NULL if no hardware supported. The array is terminated by a NULL |
||||
* pointer. |
||||
* |
||||
* The user can only access this field via avcodec_get_hw_config(). |
||||
*/ |
||||
const struct AVCodecHWConfigInternal *const *hw_configs; |
||||
|
||||
/**
|
||||
* List of supported codec_tags, terminated by FF_CODEC_TAGS_END. |
||||
*/ |
||||
const uint32_t *codec_tags; |
||||
} AVCodec; |
||||
|
||||
/**
|
||||
* Iterate over all registered codecs. |
||||
* |
||||
* @param opaque a pointer where libavcodec will store the iteration state. Must |
||||
* point to NULL to start the iteration. |
||||
* |
||||
* @return the next registered codec or NULL when the iteration is |
||||
* finished |
||||
*/ |
||||
const AVCodec *av_codec_iterate(void **opaque); |
||||
|
||||
/**
|
||||
* Find a registered decoder with a matching codec ID. |
||||
* |
||||
* @param id AVCodecID of the requested decoder |
||||
* @return A decoder if one was found, NULL otherwise. |
||||
*/ |
||||
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. |
||||
*/ |
||||
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. |
||||
*/ |
||||
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. |
||||
*/ |
||||
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); |
||||
|
||||
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,592 @@ |
||||
/*
|
||||
* 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" |
||||
|
||||
/**
|
||||
* @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 = 0x8000, |
||||
AV_CODEC_ID_AVRP, |
||||
AV_CODEC_ID_012V, |
||||
AV_CODEC_ID_AVUI, |
||||
AV_CODEC_ID_AYUV, |
||||
AV_CODEC_ID_TARGA_Y216, |
||||
AV_CODEC_ID_V308, |
||||
AV_CODEC_ID_V408, |
||||
AV_CODEC_ID_YUV4, |
||||
AV_CODEC_ID_AVRN, |
||||
AV_CODEC_ID_CPIA, |
||||
AV_CODEC_ID_XFACE, |
||||
AV_CODEC_ID_SNOW, |
||||
AV_CODEC_ID_SMVJPEG, |
||||
AV_CODEC_ID_APNG, |
||||
AV_CODEC_ID_DAALA, |
||||
AV_CODEC_ID_CFHD, |
||||
AV_CODEC_ID_TRUEMOTION2RT, |
||||
AV_CODEC_ID_M101, |
||||
AV_CODEC_ID_MAGICYUV, |
||||
AV_CODEC_ID_SHEERVIDEO, |
||||
AV_CODEC_ID_YLC, |
||||
AV_CODEC_ID_PSD, |
||||
AV_CODEC_ID_PIXLET, |
||||
AV_CODEC_ID_SPEEDHQ, |
||||
AV_CODEC_ID_FMVC, |
||||
AV_CODEC_ID_SCPR, |
||||
AV_CODEC_ID_CLEARVIDEO, |
||||
AV_CODEC_ID_XPM, |
||||
AV_CODEC_ID_AV1, |
||||
AV_CODEC_ID_BITPACKED, |
||||
AV_CODEC_ID_MSCC, |
||||
AV_CODEC_ID_SRGC, |
||||
AV_CODEC_ID_SVG, |
||||
AV_CODEC_ID_GDV, |
||||
AV_CODEC_ID_FITS, |
||||
AV_CODEC_ID_IMM4, |
||||
AV_CODEC_ID_PROSUMER, |
||||
AV_CODEC_ID_MWSC, |
||||
AV_CODEC_ID_WCMV, |
||||
AV_CODEC_ID_RASC, |
||||
AV_CODEC_ID_HYMT, |
||||
AV_CODEC_ID_ARBC, |
||||
AV_CODEC_ID_AGM, |
||||
AV_CODEC_ID_LSCR, |
||||
AV_CODEC_ID_VP4, |
||||
AV_CODEC_ID_IMM5, |
||||
AV_CODEC_ID_MVDV, |
||||
AV_CODEC_ID_MVHA, |
||||
AV_CODEC_ID_CDTOONS, |
||||
AV_CODEC_ID_MV30, |
||||
AV_CODEC_ID_NOTCHLC, |
||||
AV_CODEC_ID_PFM, |
||||
AV_CODEC_ID_MOBICLIP, |
||||
AV_CODEC_ID_PHOTOCD, |
||||
AV_CODEC_ID_IPU, |
||||
AV_CODEC_ID_ARGO, |
||||
AV_CODEC_ID_CRI, |
||||
AV_CODEC_ID_SIMBIOSIS_IMX, |
||||
AV_CODEC_ID_SGA_VIDEO, |
||||
|
||||
/* 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 = 0x10800, |
||||
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 = 0x11800, |
||||
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, |
||||
|
||||
/* 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 = 0x14800, |
||||
AV_CODEC_ID_GREMLIN_DPCM, |
||||
AV_CODEC_ID_DERF_DPCM, |
||||
|
||||
/* audio codecs */ |
||||
AV_CODEC_ID_MP2 = 0x15000, |
||||
AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
|
||||
AV_CODEC_ID_AAC, |
||||
AV_CODEC_ID_AC3, |
||||
AV_CODEC_ID_DTS, |
||||
AV_CODEC_ID_VORBIS, |
||||
AV_CODEC_ID_DVAUDIO, |
||||
AV_CODEC_ID_WMAV1, |
||||
AV_CODEC_ID_WMAV2, |
||||
AV_CODEC_ID_MACE3, |
||||
AV_CODEC_ID_MACE6, |
||||
AV_CODEC_ID_VMDAUDIO, |
||||
AV_CODEC_ID_FLAC, |
||||
AV_CODEC_ID_MP3ADU, |
||||
AV_CODEC_ID_MP3ON4, |
||||
AV_CODEC_ID_SHORTEN, |
||||
AV_CODEC_ID_ALAC, |
||||
AV_CODEC_ID_WESTWOOD_SND1, |
||||
AV_CODEC_ID_GSM, ///< as in Berlin toast format
|
||||
AV_CODEC_ID_QDM2, |
||||
AV_CODEC_ID_COOK, |
||||
AV_CODEC_ID_TRUESPEECH, |
||||
AV_CODEC_ID_TTA, |
||||
AV_CODEC_ID_SMACKAUDIO, |
||||
AV_CODEC_ID_QCELP, |
||||
AV_CODEC_ID_WAVPACK, |
||||
AV_CODEC_ID_DSICINAUDIO, |
||||
AV_CODEC_ID_IMC, |
||||
AV_CODEC_ID_MUSEPACK7, |
||||
AV_CODEC_ID_MLP, |
||||
AV_CODEC_ID_GSM_MS, /* as found in WAV */ |
||||
AV_CODEC_ID_ATRAC3, |
||||
AV_CODEC_ID_APE, |
||||
AV_CODEC_ID_NELLYMOSER, |
||||
AV_CODEC_ID_MUSEPACK8, |
||||
AV_CODEC_ID_SPEEX, |
||||
AV_CODEC_ID_WMAVOICE, |
||||
AV_CODEC_ID_WMAPRO, |
||||
AV_CODEC_ID_WMALOSSLESS, |
||||
AV_CODEC_ID_ATRAC3P, |
||||
AV_CODEC_ID_EAC3, |
||||
AV_CODEC_ID_SIPR, |
||||
AV_CODEC_ID_MP1, |
||||
AV_CODEC_ID_TWINVQ, |
||||
AV_CODEC_ID_TRUEHD, |
||||
AV_CODEC_ID_MP4ALS, |
||||
AV_CODEC_ID_ATRAC1, |
||||
AV_CODEC_ID_BINKAUDIO_RDFT, |
||||
AV_CODEC_ID_BINKAUDIO_DCT, |
||||
AV_CODEC_ID_AAC_LATM, |
||||
AV_CODEC_ID_QDMC, |
||||
AV_CODEC_ID_CELT, |
||||
AV_CODEC_ID_G723_1, |
||||
AV_CODEC_ID_G729, |
||||
AV_CODEC_ID_8SVX_EXP, |
||||
AV_CODEC_ID_8SVX_FIB, |
||||
AV_CODEC_ID_BMV_AUDIO, |
||||
AV_CODEC_ID_RALF, |
||||
AV_CODEC_ID_IAC, |
||||
AV_CODEC_ID_ILBC, |
||||
AV_CODEC_ID_OPUS, |
||||
AV_CODEC_ID_COMFORT_NOISE, |
||||
AV_CODEC_ID_TAK, |
||||
AV_CODEC_ID_METASOUND, |
||||
AV_CODEC_ID_PAF_AUDIO, |
||||
AV_CODEC_ID_ON2AVC, |
||||
AV_CODEC_ID_DSS_SP, |
||||
AV_CODEC_ID_CODEC2, |
||||
|
||||
AV_CODEC_ID_FFWAVESYNTH = 0x15800, |
||||
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, |
||||
|
||||
/* 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 = 0x17800, |
||||
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 = 0x18800, |
||||
AV_CODEC_ID_XBIN, |
||||
AV_CODEC_ID_IDF, |
||||
AV_CODEC_ID_OTF, |
||||
AV_CODEC_ID_SMPTE_KLV, |
||||
AV_CODEC_ID_DVD_NAV, |
||||
AV_CODEC_ID_TIMED_ID3, |
||||
AV_CODEC_ID_BIN_DATA, |
||||
|
||||
|
||||
AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
|
||||
|
||||
AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
|
||||
* stream (only used by libavformat) */ |
||||
AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
|
||||
* stream (only used by libavformat) */ |
||||
AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
|
||||
AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
|
||||
}; |
||||
|
||||
/**
|
||||
* Get the type of the given codec. |
||||
*/ |
||||
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id); |
||||
|
||||
/**
|
||||
* Get the name of a codec. |
||||
* @return a static string identifying the codec; never NULL |
||||
*/ |
||||
const char *avcodec_get_name(enum AVCodecID id); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif // AVCODEC_CODEC_ID_H
|
@ -0,0 +1,229 @@ |
||||
/*
|
||||
* 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/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; |
||||
|
||||
/**
|
||||
* 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. |
||||
*/ |
||||
uint64_t channel_layout; |
||||
/**
|
||||
* Audio only. The number of audio channels. |
||||
*/ |
||||
int channels; |
||||
/**
|
||||
* 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; |
||||
} 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); |
||||
|
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#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,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,83 @@ |
||||
/*
|
||||
* 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" |
||||
#include "avcodec.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,101 @@ |
||||
/*
|
||||
* 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) 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 |
||||
*/ |
||||
int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time); |
||||
|
||||
#endif /* AVCODEC_MEDIACODEC_H */ |
@ -0,0 +1,774 @@ |
||||
/*
|
||||
* 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 "libavcodec/version.h" |
||||
|
||||
/**
|
||||
* @defgroup lavc_packet AVPacket |
||||
* |
||||
* Types and functions for working with AVPacket. |
||||
* @{ |
||||
*/ |
||||
enum AVPacketSideDataType { |
||||
/**
|
||||
* An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE |
||||
* bytes worth of palette. This side data signals that a new palette is |
||||
* present. |
||||
*/ |
||||
AV_PKT_DATA_PALETTE, |
||||
|
||||
/**
|
||||
* The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format |
||||
* that the extradata buffer was changed and the receiving side should |
||||
* act upon it appropriately. The new extradata is embedded in the side |
||||
* data buffer and should be immediately used for processing the current |
||||
* frame or packet. |
||||
*/ |
||||
AV_PKT_DATA_NEW_EXTRADATA, |
||||
|
||||
/**
|
||||
* An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows: |
||||
* @code |
||||
* u32le param_flags |
||||
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) |
||||
* s32le channel_count |
||||
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) |
||||
* u64le channel_layout |
||||
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) |
||||
* s32le sample_rate |
||||
* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) |
||||
* s32le width |
||||
* s32le height |
||||
* @endcode |
||||
*/ |
||||
AV_PKT_DATA_PARAM_CHANGE, |
||||
|
||||
/**
|
||||
* An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of |
||||
* structures with info about macroblocks relevant to splitting the |
||||
* packet into smaller packets on macroblock edges (e.g. as for RFC 2190). |
||||
* That is, it does not necessarily contain info about all macroblocks, |
||||
* as long as the distance between macroblocks in the info is smaller |
||||
* than the target payload size. |
||||
* Each MB info structure is 12 bytes, and is laid out as follows: |
||||
* @code |
||||
* u32le bit offset from the start of the packet |
||||
* u8 current quantizer at the start of the macroblock |
||||
* u8 GOB number |
||||
* u16le macroblock address within the GOB |
||||
* u8 horizontal MV predictor |
||||
* u8 vertical MV predictor |
||||
* u8 horizontal MV predictor for block number 3 |
||||
* u8 vertical MV predictor for block number 3 |
||||
* @endcode |
||||
*/ |
||||
AV_PKT_DATA_H263_MB_INFO, |
||||
|
||||
/**
|
||||
* This side data should be associated with an audio stream and contains |
||||
* ReplayGain information in form of the AVReplayGain struct. |
||||
*/ |
||||
AV_PKT_DATA_REPLAYGAIN, |
||||
|
||||
/**
|
||||
* This side data contains a 3x3 transformation matrix describing an affine |
||||
* transformation that needs to be applied to the decoded video frames for |
||||
* correct presentation. |
||||
* |
||||
* See libavutil/display.h for a detailed description of the data. |
||||
*/ |
||||
AV_PKT_DATA_DISPLAYMATRIX, |
||||
|
||||
/**
|
||||
* This side data should be associated with a video stream and contains |
||||
* Stereoscopic 3D information in form of the AVStereo3D struct. |
||||
*/ |
||||
AV_PKT_DATA_STEREO3D, |
||||
|
||||
/**
|
||||
* This side data should be associated with an audio stream and corresponds |
||||
* to enum AVAudioServiceType. |
||||
*/ |
||||
AV_PKT_DATA_AUDIO_SERVICE_TYPE, |
||||
|
||||
/**
|
||||
* This side data contains quality related information from the encoder. |
||||
* @code |
||||
* u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad). |
||||
* u8 picture type |
||||
* u8 error count |
||||
* u16 reserved |
||||
* u64le[error count] sum of squared differences between encoder in and output |
||||
* @endcode |
||||
*/ |
||||
AV_PKT_DATA_QUALITY_STATS, |
||||
|
||||
/**
|
||||
* This side data contains an integer value representing the stream index |
||||
* of a "fallback" track. A fallback track indicates an alternate |
||||
* track to use when the current track can not be decoded for some reason. |
||||
* e.g. no decoder available for codec. |
||||
*/ |
||||
AV_PKT_DATA_FALLBACK_TRACK, |
||||
|
||||
/**
|
||||
* This side data corresponds to the AVCPBProperties struct. |
||||
*/ |
||||
AV_PKT_DATA_CPB_PROPERTIES, |
||||
|
||||
/**
|
||||
* Recommmends skipping the specified number of samples |
||||
* @code |
||||
* u32le number of samples to skip from start of this packet |
||||
* u32le number of samples to skip from end of this packet |
||||
* u8 reason for start skip |
||||
* u8 reason for end skip (0=padding silence, 1=convergence) |
||||
* @endcode |
||||
*/ |
||||
AV_PKT_DATA_SKIP_SAMPLES, |
||||
|
||||
/**
|
||||
* An AV_PKT_DATA_JP_DUALMONO side data packet indicates that |
||||
* the packet may contain "dual mono" audio specific to Japanese DTV |
||||
* and if it is true, recommends only the selected channel to be used. |
||||
* @code |
||||
* u8 selected channels (0=mail/left, 1=sub/right, 2=both) |
||||
* @endcode |
||||
*/ |
||||
AV_PKT_DATA_JP_DUALMONO, |
||||
|
||||
/**
|
||||
* A list of zero terminated key/value strings. There is no end marker for |
||||
* the list, so it is required to rely on the side data size to stop. |
||||
*/ |
||||
AV_PKT_DATA_STRINGS_METADATA, |
||||
|
||||
/**
|
||||
* Subtitle event position |
||||
* @code |
||||
* u32le x1 |
||||
* u32le y1 |
||||
* u32le x2 |
||||
* u32le y2 |
||||
* @endcode |
||||
*/ |
||||
AV_PKT_DATA_SUBTITLE_POSITION, |
||||
|
||||
/**
|
||||
* Data found in BlockAdditional element of matroska container. There is |
||||
* no end marker for the data, so it is required to rely on the side data |
||||
* size to recognize the end. 8 byte id (as found in BlockAddId) followed |
||||
* by data. |
||||
*/ |
||||
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, |
||||
|
||||
/**
|
||||
* The optional first identifier line of a WebVTT cue. |
||||
*/ |
||||
AV_PKT_DATA_WEBVTT_IDENTIFIER, |
||||
|
||||
/**
|
||||
* The optional settings (rendering instructions) that immediately |
||||
* follow the timestamp specifier of a WebVTT cue. |
||||
*/ |
||||
AV_PKT_DATA_WEBVTT_SETTINGS, |
||||
|
||||
/**
|
||||
* A list of zero terminated key/value strings. There is no end marker for |
||||
* the list, so it is required to rely on the side data size to stop. This |
||||
* side data includes updated metadata which appeared in the stream. |
||||
*/ |
||||
AV_PKT_DATA_METADATA_UPDATE, |
||||
|
||||
/**
|
||||
* MPEGTS stream ID as uint8_t, this is required to pass the stream ID |
||||
* information from the demuxer to the corresponding muxer. |
||||
*/ |
||||
AV_PKT_DATA_MPEGTS_STREAM_ID, |
||||
|
||||
/**
|
||||
* Mastering display metadata (based on SMPTE-2086:2014). This metadata |
||||
* should be associated with a video stream and contains data in the form |
||||
* of the AVMasteringDisplayMetadata struct. |
||||
*/ |
||||
AV_PKT_DATA_MASTERING_DISPLAY_METADATA, |
||||
|
||||
/**
|
||||
* This side data should be associated with a video stream and corresponds |
||||
* to the AVSphericalMapping structure. |
||||
*/ |
||||
AV_PKT_DATA_SPHERICAL, |
||||
|
||||
/**
|
||||
* Content light level (based on CTA-861.3). This metadata should be |
||||
* associated with a video stream and contains data in the form of the |
||||
* AVContentLightMetadata struct. |
||||
*/ |
||||
AV_PKT_DATA_CONTENT_LIGHT_LEVEL, |
||||
|
||||
/**
|
||||
* ATSC A53 Part 4 Closed Captions. This metadata should be associated with |
||||
* a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data. |
||||
* The number of bytes of CC data is AVPacketSideData.size. |
||||
*/ |
||||
AV_PKT_DATA_A53_CC, |
||||
|
||||
/**
|
||||
* This side data is encryption initialization data. |
||||
* The format is not part of ABI, use av_encryption_init_info_* methods to |
||||
* access. |
||||
*/ |
||||
AV_PKT_DATA_ENCRYPTION_INIT_INFO, |
||||
|
||||
/**
|
||||
* This side data contains encryption info for how to decrypt the packet. |
||||
* The format is not part of ABI, use av_encryption_info_* methods to access. |
||||
*/ |
||||
AV_PKT_DATA_ENCRYPTION_INFO, |
||||
|
||||
/**
|
||||
* Active Format Description data consisting of a single byte as specified |
||||
* in ETSI TS 101 154 using AVActiveFormatDescription enum. |
||||
*/ |
||||
AV_PKT_DATA_AFD, |
||||
|
||||
/**
|
||||
* Producer Reference Time data corresponding to the AVProducerReferenceTime struct, |
||||
* usually exported by some encoders (on demand through the prft flag set in the |
||||
* AVCodecContext export_side_data field). |
||||
*/ |
||||
AV_PKT_DATA_PRFT, |
||||
|
||||
/**
|
||||
* ICC profile data consisting of an opaque octet buffer following the |
||||
* format described by ISO 15076-1. |
||||
*/ |
||||
AV_PKT_DATA_ICC_PROFILE, |
||||
|
||||
/**
|
||||
* DOVI configuration |
||||
* ref: |
||||
* dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2 |
||||
* dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3 |
||||
* Tags are stored in struct AVDOVIDecoderConfigurationRecord. |
||||
*/ |
||||
AV_PKT_DATA_DOVI_CONF, |
||||
|
||||
/**
|
||||
* Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t |
||||
* where the first uint32_t describes how many (1-3) of the other timecodes are used. |
||||
* The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum() |
||||
* function in libavutil/timecode.h. |
||||
*/ |
||||
AV_PKT_DATA_S12M_TIMECODE, |
||||
|
||||
/**
|
||||
* 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; |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int size; |
||||
#else |
||||
size_t size; |
||||
#endif |
||||
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
|
||||
|
||||
#if FF_API_CONVERGENCE_DURATION |
||||
/**
|
||||
* @deprecated Same as the duration field, but as int64_t. This was required |
||||
* for Matroska subtitles, whose duration values could overflow when the |
||||
* duration field was still an int. |
||||
*/ |
||||
attribute_deprecated |
||||
int64_t convergence_duration; |
||||
#endif |
||||
} 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 { |
||||
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001, |
||||
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002, |
||||
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); |
||||
|
||||
#if FF_API_AVPACKET_OLD_API |
||||
/**
|
||||
* @warning This is a hack - the packet memory allocation stuff is broken. The |
||||
* packet is allocated if it was not really allocated. |
||||
* |
||||
* @deprecated Use av_packet_ref or av_packet_make_refcounted |
||||
*/ |
||||
attribute_deprecated |
||||
int av_dup_packet(AVPacket *pkt); |
||||
/**
|
||||
* Copy packet, including contents |
||||
* |
||||
* @return 0 on success, negative AVERROR on fail |
||||
* |
||||
* @deprecated Use av_packet_ref |
||||
*/ |
||||
attribute_deprecated |
||||
int av_copy_packet(AVPacket *dst, const AVPacket *src); |
||||
|
||||
/**
|
||||
* Copy packet side data |
||||
* |
||||
* @return 0 on success, negative AVERROR on fail |
||||
* |
||||
* @deprecated Use av_packet_copy_props |
||||
*/ |
||||
attribute_deprecated |
||||
int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src); |
||||
|
||||
/**
|
||||
* Free a packet. |
||||
* |
||||
* @deprecated Use av_packet_unref |
||||
* |
||||
* @param pkt packet to free |
||||
*/ |
||||
attribute_deprecated |
||||
void av_free_packet(AVPacket *pkt); |
||||
#endif |
||||
/**
|
||||
* 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, |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int size); |
||||
#else |
||||
size_t size); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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, |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int size); |
||||
#else |
||||
size_t size); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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, |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int *size); |
||||
#else |
||||
size_t *size); |
||||
#endif |
||||
|
||||
#if FF_API_MERGE_SD_API |
||||
attribute_deprecated |
||||
int av_packet_merge_side_data(AVPacket *pkt); |
||||
|
||||
attribute_deprecated |
||||
int av_packet_split_side_data(AVPacket *pkt); |
||||
#endif |
||||
|
||||
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 |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size); |
||||
#else |
||||
uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size); |
||||
#endif |
||||
/**
|
||||
* 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 |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict); |
||||
#else |
||||
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, |
||||
AVDictionary **dict); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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,107 @@ |
||||
/*
|
||||
* 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 <mfx/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. |
||||
*/ |
||||
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,86 @@ |
||||
/*
|
||||
* Video Acceleration API (shared data between FFmpeg and the video player) |
||||
* HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1 |
||||
* |
||||
* Copyright (C) 2008-2009 Splitted-Desktop Systems |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_VAAPI_H |
||||
#define AVCODEC_VAAPI_H |
||||
|
||||
/**
|
||||
* @file |
||||
* @ingroup lavc_codec_hwaccel_vaapi |
||||
* Public libavcodec VA API header. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include "libavutil/attributes.h" |
||||
#include "version.h" |
||||
|
||||
#if FF_API_STRUCT_VAAPI_CONTEXT |
||||
|
||||
/**
|
||||
* @defgroup lavc_codec_hwaccel_vaapi VA API Decoding |
||||
* @ingroup lavc_codec_hwaccel |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* This structure is used to share data between the FFmpeg library and |
||||
* the client video application. |
||||
* This shall be zero-allocated and available as |
||||
* AVCodecContext.hwaccel_context. All user members can be set once |
||||
* during initialization or through each AVCodecContext.get_buffer() |
||||
* function call. In any case, they must be valid prior to calling |
||||
* decoding functions. |
||||
* |
||||
* Deprecated: use AVCodecContext.hw_frames_ctx instead. |
||||
*/ |
||||
struct attribute_deprecated vaapi_context { |
||||
/**
|
||||
* Window system dependent data |
||||
* |
||||
* - encoding: unused |
||||
* - decoding: Set by user |
||||
*/ |
||||
void *display; |
||||
|
||||
/**
|
||||
* Configuration ID |
||||
* |
||||
* - encoding: unused |
||||
* - decoding: Set by user |
||||
*/ |
||||
uint32_t config_id; |
||||
|
||||
/**
|
||||
* Context ID (video decode pipeline) |
||||
* |
||||
* - encoding: unused |
||||
* - decoding: Set by user |
||||
*/ |
||||
uint32_t context_id; |
||||
}; |
||||
|
||||
/* @} */ |
||||
|
||||
#endif /* FF_API_STRUCT_VAAPI_CONTEXT */ |
||||
|
||||
#endif /* AVCODEC_VAAPI_H */ |
@ -0,0 +1,176 @@ |
||||
/*
|
||||
* 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" |
||||
#include "version.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); |
||||
|
||||
#if FF_API_VDPAU_PROFILE |
||||
/**
|
||||
* Get a decoder profile that should be used for initializing a VDPAU decoder. |
||||
* Should be called from the AVCodecContext.get_format() callback. |
||||
* |
||||
* @deprecated Use av_vdpau_bind_context() instead. |
||||
* |
||||
* @param avctx the codec context being used for decoding the stream |
||||
* @param profile a pointer into which the result will be written on success. |
||||
* The contents of profile are undefined if this function returns |
||||
* an error. |
||||
* |
||||
* @return 0 on success (non-negative), a negative AVERROR on failure. |
||||
*/ |
||||
attribute_deprecated |
||||
int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile); |
||||
#endif |
||||
|
||||
/* @}*/ |
||||
|
||||
#endif /* AVCODEC_VDPAU_H */ |
@ -0,0 +1,172 @@ |
||||
/*
|
||||
* 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" |
||||
|
||||
#define LIBAVCODEC_VERSION_MAJOR 58 |
||||
#define LIBAVCODEC_VERSION_MINOR 134 |
||||
#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) |
||||
|
||||
/**
|
||||
* FF_API_* defines may be placed below to indicate public API that will be |
||||
* dropped at a future version bump. The defines themselves are not part of |
||||
* the public API and may change, break or disappear at any time. |
||||
* |
||||
* @note, when bumping the major version it is recommended to manually |
||||
* disable each FF_API_* in its own commit instead of disabling them all |
||||
* at once through the bump. This improves the git bisect-ability of the change. |
||||
*/ |
||||
|
||||
#ifndef FF_API_AVCTX_TIMEBASE |
||||
#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_CODED_FRAME |
||||
#define FF_API_CODED_FRAME (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_SIDEDATA_ONLY_PKT |
||||
#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_VDPAU_PROFILE |
||||
#define FF_API_VDPAU_PROFILE (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_CONVERGENCE_DURATION |
||||
#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_AVPICTURE |
||||
#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_AVPACKET_OLD_API |
||||
#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_RTP_CALLBACK |
||||
#define FF_API_RTP_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_VBV_DELAY |
||||
#define FF_API_VBV_DELAY (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_CODER_TYPE |
||||
#define FF_API_CODER_TYPE (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_STAT_BITS |
||||
#define FF_API_STAT_BITS (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_PRIVATE_OPT |
||||
#define FF_API_PRIVATE_OPT (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_ASS_TIMING |
||||
#define FF_API_ASS_TIMING (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OLD_BSF |
||||
#define FF_API_OLD_BSF (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_COPY_CONTEXT |
||||
#define FF_API_COPY_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_GET_CONTEXT_DEFAULTS |
||||
#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_NVENC_OLD_NAME |
||||
#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_STRUCT_VAAPI_CONTEXT |
||||
#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_MERGE_SD_API |
||||
#define FF_API_MERGE_SD_API (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_TAG_STRING |
||||
#define FF_API_TAG_STRING (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_GETCHROMA |
||||
#define FF_API_GETCHROMA (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_CODEC_GET_SET |
||||
#define FF_API_CODEC_GET_SET (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_USER_VISIBLE_AVHWACCEL |
||||
#define FF_API_USER_VISIBLE_AVHWACCEL (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_LOCKMGR |
||||
#define FF_API_LOCKMGR (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_NEXT |
||||
#define FF_API_NEXT (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_UNSANITIZED_BITRATES |
||||
#define FF_API_UNSANITIZED_BITRATES (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OPENH264_SLICE_MODE |
||||
#define FF_API_OPENH264_SLICE_MODE (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OPENH264_CABAC |
||||
#define FF_API_OPENH264_CABAC (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_UNUSED_CODEC_CAPS |
||||
#define FF_API_UNUSED_CODEC_CAPS (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_AVPRIV_PUT_BITS |
||||
#define FF_API_AVPRIV_PUT_BITS (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OLD_ENCDEC |
||||
#define FF_API_OLD_ENCDEC (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_AVCODEC_PIX_FMT |
||||
#define FF_API_AVCODEC_PIX_FMT (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_MPV_RC_STRATEGY |
||||
#define FF_API_MPV_RC_STRATEGY (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_PARSER_CHANGE |
||||
#define FF_API_PARSER_CHANGE (LIBAVCODEC_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_THREAD_SAFE_CALLBACKS |
||||
#define FF_API_THREAD_SAFE_CALLBACKS (LIBAVCODEC_VERSION_MAJOR < 60) |
||||
#endif |
||||
#ifndef FF_API_DEBUG_MV |
||||
#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 60) |
||||
#endif |
||||
#ifndef FF_API_GET_FRAME_CLASS |
||||
#define FF_API_GET_FRAME_CLASS (LIBAVCODEC_VERSION_MAJOR < 60) |
||||
#endif |
||||
#ifndef FF_API_AUTO_THREADS |
||||
#define FF_API_AUTO_THREADS (LIBAVCODEC_VERSION_MAJOR < 60) |
||||
#endif |
||||
#ifndef FF_API_INIT_PACKET |
||||
#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 60) |
||||
#endif |
||||
|
||||
#endif /* AVCODEC_VERSION_H */ |
@ -0,0 +1,127 @@ |
||||
/*
|
||||
* 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. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#define Picture QuickdrawPicture |
||||
#include <VideoToolbox/VideoToolbox.h> |
||||
#undef Picture |
||||
|
||||
#include "libavcodec/avcodec.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. |
||||
* Created and freed the caller. |
||||
*/ |
||||
VTDecompressionSessionRef session; |
||||
|
||||
/**
|
||||
* The output callback that must be passed to the session. |
||||
* Set by av_videottoolbox_default_init() |
||||
*/ |
||||
VTDecompressionOutputCallback output_callback; |
||||
|
||||
/**
|
||||
* 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. |
||||
* Set by the caller. |
||||
*/ |
||||
CMVideoFormatDescriptionRef cm_fmt_desc; |
||||
|
||||
/**
|
||||
* CoreMedia codec type that Videotoolbox will use to create the decompression session. |
||||
* Set by the caller. |
||||
*/ |
||||
int cm_codec_type; |
||||
} AVVideotoolboxContext; |
||||
|
||||
/**
|
||||
* 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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
void av_videotoolbox_default_free(AVCodecContext *avctx); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#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,170 @@ |
||||
/*
|
||||
* 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. |
||||
*/ |
||||
|
||||
#include <X11/extensions/XvMC.h> |
||||
|
||||
#include "libavutil/attributes.h" |
||||
#include "version.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 */ |
File diff suppressed because it is too large
Load Diff
@ -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 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_channel_layout(), |
||||
* - av_buffersink_get_sample_rate(). |
||||
* |
||||
* 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), |
||||
* - channel_layouts (int64_t), |
||||
* - 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 neither channel_layouts nor channel_counts is set, |
||||
* all valid channel layouts are accepted, but channel counts without a |
||||
* layout are not, unless all_channel_counts is set. |
||||
* Also, channel_layouts must not contain a channel layout already accepted |
||||
* by a value in channel_counts; for example, if channel_counts contains 2, |
||||
* then channel_layouts must not contain stereo. |
||||
*/ |
||||
|
||||
/**
|
||||
* 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 |
||||
|
||||
#if FF_API_BUFFERSINK_ALLOC |
||||
/**
|
||||
* Deprecated and unused struct to use for initializing a buffersink context. |
||||
*/ |
||||
typedef struct AVBufferSinkParams { |
||||
const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
|
||||
} AVBufferSinkParams; |
||||
|
||||
/**
|
||||
* Create an AVBufferSinkParams structure. |
||||
* |
||||
* Must be freed with av_free(). |
||||
*/ |
||||
attribute_deprecated |
||||
AVBufferSinkParams *av_buffersink_params_alloc(void); |
||||
|
||||
/**
|
||||
* Deprecated and unused struct to use for initializing an abuffersink context. |
||||
*/ |
||||
typedef struct AVABufferSinkParams { |
||||
const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
|
||||
const int64_t *channel_layouts; ///< list of allowed channel layouts, terminated by -1
|
||||
const int *channel_counts; ///< list of allowed channel counts, terminated by -1
|
||||
int all_channel_counts; ///< if not 0, accept any channel count or layout
|
||||
int *sample_rates; ///< list of allowed sample rates, terminated by -1
|
||||
} AVABufferSinkParams; |
||||
|
||||
/**
|
||||
* Create an AVABufferSinkParams structure. |
||||
* |
||||
* Must be freed with av_free(). |
||||
*/ |
||||
attribute_deprecated |
||||
AVABufferSinkParams *av_abuffersink_params_alloc(void); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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); |
||||
uint64_t av_buffersink_get_channel_layout (const AVFilterContext *ctx); |
||||
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,209 @@ |
||||
/*
|
||||
* 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; |
||||
|
||||
/**
|
||||
* Audio only, the audio channel layout |
||||
*/ |
||||
uint64_t channel_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,75 @@ |
||||
/*
|
||||
* 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" |
||||
|
||||
#define LIBAVFILTER_VERSION_MAJOR 7 |
||||
#define LIBAVFILTER_VERSION_MINOR 110 |
||||
#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) |
||||
|
||||
/**
|
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef FF_API_OLD_FILTER_OPTS_ERROR |
||||
#define FF_API_OLD_FILTER_OPTS_ERROR (LIBAVFILTER_VERSION_MAJOR < 8) |
||||
#endif |
||||
#ifndef FF_API_LAVR_OPTS |
||||
#define FF_API_LAVR_OPTS (LIBAVFILTER_VERSION_MAJOR < 8) |
||||
#endif |
||||
#ifndef FF_API_FILTER_GET_SET |
||||
#define FF_API_FILTER_GET_SET (LIBAVFILTER_VERSION_MAJOR < 8) |
||||
#endif |
||||
#ifndef FF_API_SWS_PARAM_OPTION |
||||
#define FF_API_SWS_PARAM_OPTION (LIBAVFILTER_VERSION_MAJOR < 8) |
||||
#endif |
||||
#ifndef FF_API_NEXT |
||||
#define FF_API_NEXT (LIBAVFILTER_VERSION_MAJOR < 8) |
||||
#endif |
||||
#ifndef FF_API_FILTER_LINK_SET_CLOSED |
||||
#define FF_API_FILTER_LINK_SET_CLOSED (LIBAVFILTER_VERSION_MAJOR < 8) |
||||
#endif |
||||
#ifndef FF_API_BUFFERSINK_ALLOC |
||||
#define FF_API_BUFFERSINK_ALLOC (LIBAVFILTER_VERSION_MAJOR < 9) |
||||
#endif |
||||
|
||||
#endif /* AVFILTER_VERSION_H */ |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,888 @@ |
||||
/*
|
||||
* 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 "libavutil/common.h" |
||||
#include "libavutil/dict.h" |
||||
#include "libavutil/log.h" |
||||
|
||||
#include "libavformat/version.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; |
||||
|
||||
typedef struct AVIODirContext { |
||||
struct URLContext *url_context; |
||||
} AVIODirContext; |
||||
|
||||
/**
|
||||
* 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 fields can be added to the end with minor version bumps. |
||||
* Removal, reordering and changes to existing 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 write_flag; /**< true if open for writing */ |
||||
int max_packet_size; |
||||
unsigned long checksum; |
||||
unsigned char *checksum_ptr; |
||||
unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size); |
||||
int error; /**< contains the error code or 0 if no error happened */ |
||||
/**
|
||||
* Pause or resume playback for network streaming protocols - e.g. MMS. |
||||
*/ |
||||
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; |
||||
|
||||
/**
|
||||
* max filesize, used to limit allocations |
||||
* This field is internal to libavformat and access from outside is not allowed. |
||||
*/ |
||||
int64_t maxsize; |
||||
|
||||
/**
|
||||
* avio_read and avio_write should if possible be satisfied directly |
||||
* instead of going through a buffer, and avio_seek will always |
||||
* call the underlying seek function directly. |
||||
*/ |
||||
int direct; |
||||
|
||||
/**
|
||||
* Bytes read statistic |
||||
* This field is internal to libavformat and access from outside is not allowed. |
||||
*/ |
||||
int64_t bytes_read; |
||||
|
||||
/**
|
||||
* seek statistic |
||||
* This field is internal to libavformat and access from outside is not allowed. |
||||
*/ |
||||
int seek_count; |
||||
|
||||
/**
|
||||
* writeout statistic |
||||
* This field is internal to libavformat and access from outside is not allowed. |
||||
*/ |
||||
int writeout_count; |
||||
|
||||
/**
|
||||
* Original buffer size |
||||
* used internally after probing and ensure seekback to reset the buffer size |
||||
* This field is internal to libavformat and access from outside is not allowed. |
||||
*/ |
||||
int orig_buffer_size; |
||||
|
||||
/**
|
||||
* Threshold to favor readahead over seek. |
||||
* This is current internal only, do not use from outside. |
||||
*/ |
||||
int short_seek_threshold; |
||||
|
||||
/**
|
||||
* ',' separated list of allowed protocols. |
||||
*/ |
||||
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; |
||||
|
||||
/**
|
||||
* Internal, not meant to be used from outside of AVIOContext. |
||||
*/ |
||||
enum AVIODataMarkerType current_type; |
||||
int64_t last_time; |
||||
|
||||
/**
|
||||
* A callback that is used instead of short_seek_threshold. |
||||
* This is current internal only, do not use from outside. |
||||
*/ |
||||
int (*short_seek_get)(void *opaque); |
||||
|
||||
int64_t written; |
||||
|
||||
/**
|
||||
* 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; |
||||
|
||||
/**
|
||||
* Try to buffer at least this amount of data before flushing it |
||||
*/ |
||||
int min_packet_size; |
||||
} 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); |
||||
|
||||
/**
|
||||
* Move or rename a resource. |
||||
* |
||||
* @note url_src and url_dst should share the same protocol and authority. |
||||
* |
||||
* @param url_src url to resource to be moved |
||||
* @param url_dst new url to resource if the operation succeeded |
||||
* @return >=0 on success or negative on error. |
||||
*/ |
||||
int avpriv_io_move(const char *url_src, const char *url_dst); |
||||
|
||||
/**
|
||||
* Delete a resource. |
||||
* |
||||
* @param url resource to be deleted. |
||||
* @return >=0 on success or negative on error. |
||||
*/ |
||||
int avpriv_io_delete(const char *url); |
||||
|
||||
/**
|
||||
* Open directory for reading. |
||||
* |
||||
* @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 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. |
||||
* @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,123 @@ |
||||
/*
|
||||
* 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" |
||||
|
||||
// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
|
||||
// Also please add any ticket numbers that you believe might be affected here
|
||||
#define LIBAVFORMAT_VERSION_MAJOR 58 |
||||
#define LIBAVFORMAT_VERSION_MINOR 76 |
||||
#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) |
||||
|
||||
/**
|
||||
* FF_API_* defines may be placed below to indicate public API that will be |
||||
* dropped at a future version bump. The defines themselves are not part of |
||||
* the public API and may change, break or disappear at any time. |
||||
* |
||||
* @note, when bumping the major version it is recommended to manually |
||||
* disable each FF_API_* in its own commit instead of disabling them all |
||||
* at once through the bump. This improves the git bisect-ability of the change. |
||||
* |
||||
*/ |
||||
#ifndef FF_API_COMPUTE_PKT_FIELDS2 |
||||
#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OLD_OPEN_CALLBACKS |
||||
#define FF_API_OLD_OPEN_CALLBACKS (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_LAVF_AVCTX |
||||
#define FF_API_LAVF_AVCTX (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_HTTP_USER_AGENT |
||||
#define FF_API_HTTP_USER_AGENT (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_HLS_WRAP |
||||
#define FF_API_HLS_WRAP (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_HLS_USE_LOCALTIME |
||||
#define FF_API_HLS_USE_LOCALTIME (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_LAVF_KEEPSIDE_FLAG |
||||
#define FF_API_LAVF_KEEPSIDE_FLAG (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OLD_ROTATE_API |
||||
#define FF_API_OLD_ROTATE_API (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_FORMAT_GET_SET |
||||
#define FF_API_FORMAT_GET_SET (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OLD_AVIO_EOF_0 |
||||
#define FF_API_OLD_AVIO_EOF_0 (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_LAVF_FFSERVER |
||||
#define FF_API_LAVF_FFSERVER (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_FORMAT_FILENAME |
||||
#define FF_API_FORMAT_FILENAME (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_OLD_RTSP_OPTIONS |
||||
#define FF_API_OLD_RTSP_OPTIONS (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_NEXT |
||||
#define FF_API_NEXT (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_DASH_MIN_SEG_DURATION |
||||
#define FF_API_DASH_MIN_SEG_DURATION (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_LAVF_MP4A_LATM |
||||
#define FF_API_LAVF_MP4A_LATM (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_AVIOFORMAT |
||||
#define FF_API_AVIOFORMAT (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_DEMUXER_OPEN |
||||
#define FF_API_DEMUXER_OPEN (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_CHAPTER_ID_INT |
||||
#define FF_API_CHAPTER_ID_INT (LIBAVFORMAT_VERSION_MAJOR < 59) |
||||
#endif |
||||
#ifndef FF_API_LAVF_PRIV_OPT |
||||
#define FF_API_LAVF_PRIV_OPT (LIBAVFORMAT_VERSION_MAJOR < 60) |
||||
#endif |
||||
|
||||
|
||||
#ifndef FF_API_R_FRAME_RATE |
||||
#define FF_API_R_FRAME_RATE 1 |
||||
#endif |
||||
#endif /* AVFORMAT_VERSION_H */ |
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* 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" |
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_adler32 Adler-32 |
||||
* @ingroup lavu_hash |
||||
* Adler-32 hash function implementation. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#if FF_API_CRYPTO_SIZE_T |
||||
typedef unsigned long AVAdler; |
||||
#else |
||||
typedef uint32_t AVAdler; |
||||
#endif |
||||
|
||||
/**
|
||||
* 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, |
||||
#if FF_API_CRYPTO_SIZE_T |
||||
unsigned int len) av_pure; |
||||
#else |
||||
size_t len) av_pure; |
||||
#endif |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_ADLER32_H */ |
@ -0,0 +1,65 @@ |
||||
/*
|
||||
* 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" |
||||
#include "version.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 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 count number of 16 byte blocks |
||||
* @param dst destination array, can be equal to src |
||||
* @param src source array, can be equal to dst |
||||
* @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,88 @@ |
||||
/*
|
||||
* 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 |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "version.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 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. |
||||
*/ |
||||
void av_aes_ctr_free(struct AVAESCTR *a); |
||||
|
||||
/**
|
||||
* Process a buffer using a previously initialized 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,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) |
||||
# 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,187 @@ |
||||
/*
|
||||
* 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 "avutil.h" |
||||
#include "fifo.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 "avutil.h" |
||||
#include "log.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 0 |
||||
#endif /* AVUTIL_AVCONFIG_H */ |
@ -0,0 +1,437 @@ |
||||
/*
|
||||
* 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 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); |
||||
|
||||
#if FF_API_D2STR |
||||
/**
|
||||
* Convert a number to an av_malloced string. |
||||
* @deprecated use av_asprintf() with "%f" or a more specific format |
||||
*/ |
||||
attribute_deprecated |
||||
char *av_d2str(double d); |
||||
#endif |
||||
|
||||
/**
|
||||
* Unescape the given string until a non escaped terminating char, |
||||
* 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,365 @@ |
||||
/*
|
||||
* 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) |
||||
|
||||
/**
|
||||
* Open a file using a UTF-8 filename. |
||||
* The API of this function matches POSIX fopen(), errors are returned through |
||||
* errno. |
||||
*/ |
||||
FILE *av_fopen_utf8(const char *path, const char *mode); |
||||
|
||||
/**
|
||||
* 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,219 @@ |
||||
/*
|
||||
* 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 |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_BPRINT_H |
||||
#define AVUTIL_BPRINT_H |
||||
|
||||
#include <stdarg.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "avstring.h" |
||||
|
||||
/**
|
||||
* 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, buf->len can be greater than buf->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 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]; |
||||
) |
||||
|
||||
/**
|
||||
* Convenience macros for special values for av_bprint_init() size_max |
||||
* parameter. |
||||
*/ |
||||
#define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1) |
||||
#define AV_BPRINT_SIZE_AUTOMATIC 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,109 @@ |
||||
/*
|
||||
* 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_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,353 @@ |
||||
/*
|
||||
* 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> |
||||
|
||||
#include "version.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. |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int size; |
||||
#else |
||||
size_t size; |
||||
#endif |
||||
} AVBufferRef; |
||||
|
||||
/**
|
||||
* Allocate an AVBuffer of the given size using av_malloc(). |
||||
* |
||||
* @return an AVBufferRef of given size or NULL when out of memory |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
AVBufferRef *av_buffer_alloc(int size); |
||||
#else |
||||
AVBufferRef *av_buffer_alloc(size_t size); |
||||
#endif |
||||
|
||||
/**
|
||||
* Same as av_buffer_alloc(), except the returned buffer will be initialized |
||||
* to zero. |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
AVBufferRef *av_buffer_allocz(int size); |
||||
#else |
||||
AVBufferRef *av_buffer_allocz(size_t size); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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. |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
AVBufferRef *av_buffer_create(uint8_t *data, int size, |
||||
#else |
||||
AVBufferRef *av_buffer_create(uint8_t *data, size_t size, |
||||
#endif |
||||
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(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. |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int av_buffer_realloc(AVBufferRef **buf, int size); |
||||
#else |
||||
int av_buffer_realloc(AVBufferRef **buf, size_t size); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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, 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. |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size)); |
||||
#else |
||||
AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size)); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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. |
||||
*/ |
||||
#if FF_API_BUFFER_SIZE_T |
||||
AVBufferPool *av_buffer_pool_init2(int size, void *opaque, |
||||
AVBufferRef* (*alloc)(void *opaque, int size), |
||||
#else |
||||
AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque, |
||||
AVBufferRef* (*alloc)(void *opaque, size_t size), |
||||
#endif |
||||
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(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 |
||||
* @paran 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,238 @@ |
||||
/*
|
||||
* 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> |
||||
|
||||
/**
|
||||
* @file |
||||
* audio channel layout utility functions |
||||
*/ |
||||
|
||||
/**
|
||||
* @addtogroup lavu_audio |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @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 0x00000001 |
||||
#define AV_CH_FRONT_RIGHT 0x00000002 |
||||
#define AV_CH_FRONT_CENTER 0x00000004 |
||||
#define AV_CH_LOW_FREQUENCY 0x00000008 |
||||
#define AV_CH_BACK_LEFT 0x00000010 |
||||
#define AV_CH_BACK_RIGHT 0x00000020 |
||||
#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040 |
||||
#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080 |
||||
#define AV_CH_BACK_CENTER 0x00000100 |
||||
#define AV_CH_SIDE_LEFT 0x00000200 |
||||
#define AV_CH_SIDE_RIGHT 0x00000400 |
||||
#define AV_CH_TOP_CENTER 0x00000800 |
||||
#define AV_CH_TOP_FRONT_LEFT 0x00001000 |
||||
#define AV_CH_TOP_FRONT_CENTER 0x00002000 |
||||
#define AV_CH_TOP_FRONT_RIGHT 0x00004000 |
||||
#define AV_CH_TOP_BACK_LEFT 0x00008000 |
||||
#define AV_CH_TOP_BACK_CENTER 0x00010000 |
||||
#define AV_CH_TOP_BACK_RIGHT 0x00020000 |
||||
#define AV_CH_STEREO_LEFT 0x20000000 ///< Stereo downmix.
|
||||
#define AV_CH_STEREO_RIGHT 0x40000000 ///< See AV_CH_STEREO_LEFT.
|
||||
#define AV_CH_WIDE_LEFT 0x0000000080000000ULL |
||||
#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL |
||||
#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL |
||||
#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL |
||||
#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL |
||||
#define AV_CH_TOP_SIDE_LEFT 0x0000001000000000ULL |
||||
#define AV_CH_TOP_SIDE_RIGHT 0x0000002000000000ULL |
||||
#define AV_CH_BOTTOM_FRONT_CENTER 0x0000004000000000ULL |
||||
#define AV_CH_BOTTOM_FRONT_LEFT 0x0000008000000000ULL |
||||
#define AV_CH_BOTTOM_FRONT_RIGHT 0x0000010000000000ULL |
||||
|
||||
/** 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. */ |
||||
#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL |
||||
|
||||
/**
|
||||
* @} |
||||
* @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_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT) |
||||
#define AV_CH_LAYOUT_HEXADECAGONAL (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT) |
||||
#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT) |
||||
#define AV_CH_LAYOUT_22POINT2 (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_LOW_FREQUENCY_2|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_CENTER|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_SIDE_LEFT|AV_CH_TOP_SIDE_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_BOTTOM_FRONT_CENTER|AV_CH_BOTTOM_FRONT_LEFT|AV_CH_BOTTOM_FRONT_RIGHT) |
||||
|
||||
enum AVMatrixEncoding { |
||||
AV_MATRIX_ENCODING_NONE, |
||||
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 |
||||
}; |
||||
|
||||
/**
|
||||
* 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" |
||||
*/ |
||||
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. |
||||
*/ |
||||
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 |
||||
*/ |
||||
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout); |
||||
|
||||
struct AVBPrint; |
||||
/**
|
||||
* Append a description of a channel layout to a bprint buffer. |
||||
*/ |
||||
void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout); |
||||
|
||||
/**
|
||||
* Return the number of channels in the channel layout. |
||||
*/ |
||||
int av_get_channel_layout_nb_channels(uint64_t channel_layout); |
||||
|
||||
/**
|
||||
* Return default channel layout for a given number of channels. |
||||
*/ |
||||
int64_t av_get_default_channel_layout(int nb_channels); |
||||
|
||||
/**
|
||||
* Get the index of a channel in channel_layout. |
||||
* |
||||
* @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. |
||||
*/ |
||||
int av_get_channel_layout_channel_index(uint64_t channel_layout, |
||||
uint64_t channel); |
||||
|
||||
/**
|
||||
* Get the channel with the given index in channel_layout. |
||||
*/ |
||||
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. |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
int av_get_standard_channel_layout(unsigned index, uint64_t *layout, |
||||
const char **name); |
||||
|
||||
/**
|
||||
* @} |
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_CHANNEL_LAYOUT_H */ |
@ -0,0 +1,608 @@ |
||||
/*
|
||||
* 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" |
||||
#include "version.h" |
||||
#include "libavutil/avconfig.h" |
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
# define AV_NE(be, le) (be) |
||||
#else |
||||
# define AV_NE(be, le) (le) |
||||
#endif |
||||
|
||||
//rounded division & shift
|
||||
#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) |
||||
/* assume b>0 */ |
||||
#define ROUNDED_DIV(a,b) (((a)>=0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) |
||||
/* 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)) |
||||
|
||||
/**
|
||||
* Comparator. |
||||
* For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0 |
||||
* if x == y. This is useful for instance in a qsort comparator callback. |
||||
* Furthermore, compilers are able to optimize this to branchless code, and |
||||
* there is no risk of overflow with signed types. |
||||
* As with many macros, this evaluates its argument multiple times, it thus |
||||
* must not have a side-effect. |
||||
*/ |
||||
#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y))) |
||||
|
||||
#define FFMAX(a,b) ((a) > (b) ? (a) : (b)) |
||||
#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c) |
||||
#define FFMIN(a,b) ((a) > (b) ? (b) : (a)) |
||||
#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c) |
||||
|
||||
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) |
||||
#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) |
||||
|
||||
/* 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. |
||||
* @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 |
||||
if (a < amin) return amin; |
||||
else if (a > amax) return amax; |
||||
else return a; |
||||
} |
||||
|
||||
/**
|
||||
* Clip a double 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 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 |
||||
if (a < amin) return amin; |
||||
else if (a > amax) return amax; |
||||
else return a; |
||||
} |
||||
|
||||
/** 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; |
||||
} |
||||
|
||||
#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24)) |
||||
#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24)) |
||||
|
||||
/**
|
||||
* Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form. |
||||
* |
||||
* @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,133 @@ |
||||
/*
|
||||
* 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> |
||||
|
||||
#include "attributes.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_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) |
||||
|
||||
/**
|
||||
* 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); |
||||
|
||||
/**
|
||||
* Set a mask on flags returned by av_get_cpu_flags(). |
||||
* This function is mainly useful for testing. |
||||
* Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible |
||||
*/ |
||||
attribute_deprecated void av_set_cpu_flags_mask(int mask); |
||||
|
||||
/**
|
||||
* Parse CPU flags from a string. |
||||
* |
||||
* The returned flags contain the specified flags as well as related unspecified flags. |
||||
* |
||||
* This function exists only for compatibility with libav. |
||||
* Please use av_parse_cpu_caps() when possible. |
||||
* @return a combination of AV_CPU_* flags, negative on error. |
||||
*/ |
||||
attribute_deprecated |
||||
int av_parse_cpu_flags(const char *s); |
||||
|
||||
/**
|
||||
* Parse CPU caps from a string and update the given AV_CPU_* flags based on that. |
||||
* |
||||
* @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); |
||||
|
||||
/**
|
||||
* 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,100 @@ |
||||
/*
|
||||
* 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" |
||||
#include "version.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 crc CRC of previous blocks if any or initial value for CRC |
||||
* @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,77 @@ |
||||
/*
|
||||
* 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 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 count number of 8 byte blocks |
||||
* @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 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 count number of 8 byte blocks |
||||
* @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 |
||||
*/ |
||||
void av_des_mac(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_DES_H */ |
@ -0,0 +1,200 @@ |
||||
/*
|
||||
* 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> |
||||
|
||||
#include "version.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. |
||||
* Use av_dict_get() to retrieve an entry or iterate over all |
||||
* entries and finally av_dict_free() to free the dictionary |
||||
* and all its contents. |
||||
* |
||||
@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_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) { |
||||
<....> // iterate over all entries in d
|
||||
} |
||||
av_dict_free(&d); |
||||
@endcode |
||||
*/ |
||||
|
||||
#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. |
||||
* |
||||
* To iterate through all the dictionary entries, you can set the matching key |
||||
* to the null string "" and set the AV_DICT_IGNORE_SUFFIX flag. |
||||
* |
||||
* @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); |
||||
|
||||
/**
|
||||
* 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. |
||||
* |
||||
* @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 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. |
||||
* @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL, |
||||
* this function will allocate a struct for you and put it in *dst |
||||
* @param src pointer to source AVDictionary struct |
||||
* @param flags flags to use when setting entries in *dst |
||||
* @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag |
||||
* @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 ('\'). |
||||
* |
||||
* @param[in] m 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 |
||||
* @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same. |
||||
*/ |
||||
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,114 @@ |
||||
/*
|
||||
* 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 |
||||
* Display matrix |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_DISPLAY_H |
||||
#define AVUTIL_DISPLAY_H |
||||
|
||||
#include <stdint.h> |
||||
#include "common.h" |
||||
|
||||
/**
|
||||
* @addtogroup lavu_video |
||||
* @{ |
||||
* |
||||
* @defgroup lavu_video_display Display transformation matrix functions |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @addtogroup lavu_video_display |
||||
* 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 counterclockwise |
||||
* rotation by the specified angle (in degrees). |
||||
* |
||||
* @param matrix an allocated 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 matrix an allocated 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,70 @@ |
||||
/*
|
||||
* 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> |
||||
|
||||
/*
|
||||
* 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); |
||||
|
||||
#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,126 @@ |
||||
/*
|
||||
* 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> |
||||
|
||||
/**
|
||||
* @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,137 @@ |
||||
/*
|
||||
* 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 |
||||
|
||||
#include "avutil.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_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_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 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 counter a zero-initialized array where the count of each variable will be stored |
||||
* @param size size of array |
||||
* @return 0 on success, a negative value indicates that no expression or array was passed |
||||
* or size was zero |
||||
*/ |
||||
int av_expr_count_vars(AVExpr *e, unsigned *counter, int size); |
||||
|
||||
/**
|
||||
* Track the presence of user provided functions and their number of occurrences |
||||
* in a parsed expression. |
||||
* |
||||
* @param counter a zero-initialized array where the count of each function will be stored |
||||
* if you passed 5 functions with 2 arguments to av_expr_parse() |
||||
* then for arg=2 this will use upto 5 entries. |
||||
* @param size size of array |
||||
* @param arg number of arguments the counted functions have |
||||
* @return 0 on success, a negative value indicates that no expression or array was passed |
||||
* or size was zero |
||||
*/ |
||||
int av_expr_count_func(AVExpr *e, unsigned *counter, int size, int arg); |
||||
|
||||
/**
|
||||
* Free a parsed expression previously created with av_expr_parse(). |
||||
*/ |
||||
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 "4.4.2" |
||||
#endif /* AVUTIL_FFVERSION_H */ |
@ -0,0 +1,179 @@ |
||||
/*
|
||||
* 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 very simple circular buffer FIFO implementation |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_FIFO_H |
||||
#define AVUTIL_FIFO_H |
||||
|
||||
#include <stdint.h> |
||||
#include "avutil.h" |
||||
#include "attributes.h" |
||||
|
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size); |
||||
|
||||
/**
|
||||
* Free an AVFifoBuffer. |
||||
* @param f AVFifoBuffer to free |
||||
*/ |
||||
void av_fifo_free(AVFifoBuffer *f); |
||||
|
||||
/**
|
||||
* Free an AVFifoBuffer and reset pointer to NULL. |
||||
* @param f AVFifoBuffer to free |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
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 |
||||
*/ |
||||
void av_fifo_drain(AVFifoBuffer *f, int size); |
||||
|
||||
/**
|
||||
* 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(). |
||||
*/ |
||||
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 /* AVUTIL_FIFO_H */ |
@ -0,0 +1,71 @@ |
||||
/*
|
||||
* 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 <stdint.h> |
||||
|
||||
#include "avutil.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 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 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); |
||||
|
||||
/**
|
||||
* 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 |
||||
*/ |
||||
int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx); |
||||
|
||||
#endif /* AVUTIL_FILE_H */ |
@ -0,0 +1,168 @@ |
||||
/*
|
||||
* 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, |
||||
}; |
||||
|
||||
/**
|
||||
* 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 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. |
||||
*/ |
||||
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; |
||||
} 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,997 @@ |
||||
/*
|
||||
* 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 "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, |
||||
|
||||
#if FF_API_FRAME_QP |
||||
/**
|
||||
* Implementation-specific description of the format of AV_FRAME_QP_TABLE_DATA. |
||||
* The contents of this side data are undocumented and internal; use |
||||
* av_frame_set_qp_table() and av_frame_get_qp_table() to access this in a |
||||
* meaningful way instead. |
||||
*/ |
||||
AV_FRAME_DATA_QP_TABLE_PROPERTIES, |
||||
|
||||
/**
|
||||
* Raw QP table data. Its format is described by |
||||
* AV_FRAME_DATA_QP_TABLE_PROPERTIES. Use av_frame_set_qp_table() and |
||||
* av_frame_get_qp_table() to access this instead. |
||||
*/ |
||||
AV_FRAME_DATA_QP_TABLE_DATA, |
||||
#endif |
||||
|
||||
/**
|
||||
* Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t |
||||
* where the first uint32_t describes how many (1-3) of the other timecodes are used. |
||||
* The timecode format is described in the 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, |
||||
}; |
||||
|
||||
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; |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int size; |
||||
#else |
||||
size_t size; |
||||
#endif |
||||
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 |
||||
* |
||||
* Some decoders access areas outside 0,0 - width,height, please |
||||
* see avcodec_align_dimensions2(). Some filters and swscale can read |
||||
* up to 16 bytes beyond the planes, if these filters are to be used, |
||||
* then 16 extra bytes must be allocated. |
||||
* |
||||
* NOTE: Except for hwaccel formats, pointers not needed by the format |
||||
* MUST be set to NULL. |
||||
*/ |
||||
uint8_t *data[AV_NUM_DATA_POINTERS]; |
||||
|
||||
/**
|
||||
* For video, size in bytes of each picture line. |
||||
* For audio, size in bytes of each plane. |
||||
* |
||||
* For 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. |
||||
*/ |
||||
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; |
||||
|
||||
#if FF_API_PKT_PTS |
||||
/**
|
||||
* PTS copied from the AVPacket that was decoded to produce this frame. |
||||
* @deprecated use the pts field instead |
||||
*/ |
||||
attribute_deprecated |
||||
int64_t pkt_pts; |
||||
#endif |
||||
|
||||
/**
|
||||
* DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used) |
||||
* This is also the Presentation time of this AVFrame calculated from |
||||
* only AVPacket.dts values without pts values. |
||||
*/ |
||||
int64_t pkt_dts; |
||||
|
||||
/**
|
||||
* picture number in bitstream order |
||||
*/ |
||||
int coded_picture_number; |
||||
/**
|
||||
* picture number in display order |
||||
*/ |
||||
int display_picture_number; |
||||
|
||||
/**
|
||||
* quality (between 1 (good) and FF_LAMBDA_MAX (bad)) |
||||
*/ |
||||
int quality; |
||||
|
||||
/**
|
||||
* for some private data of the user |
||||
*/ |
||||
void *opaque; |
||||
|
||||
#if FF_API_ERROR_FRAME |
||||
/**
|
||||
* @deprecated unused |
||||
*/ |
||||
attribute_deprecated |
||||
uint64_t error[AV_NUM_DATA_POINTERS]; |
||||
#endif |
||||
|
||||
/**
|
||||
* When decoding, this signals how much the picture must be delayed. |
||||
* extra_delay = repeat_pict / (2*fps) |
||||
*/ |
||||
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; |
||||
|
||||
/**
|
||||
* 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 |
||||
*/ |
||||
int64_t reordered_opaque; |
||||
|
||||
/**
|
||||
* Sample rate of the audio data. |
||||
*/ |
||||
int sample_rate; |
||||
|
||||
/**
|
||||
* Channel layout of the audio data. |
||||
*/ |
||||
uint64_t channel_layout; |
||||
|
||||
/**
|
||||
* AVBuffer references backing the data for this frame. If all elements of |
||||
* this array are NULL, then this frame is not reference counted. This array |
||||
* must be filled contiguously -- if buf[i] is non-NULL then buf[j] must |
||||
* also be non-NULL for all j < i. |
||||
* |
||||
* 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; |
||||
|
||||
/**
|
||||
* duration of the corresponding packet, expressed in |
||||
* AVStream->time_base units, 0 if unknown. |
||||
* - encoding: unused |
||||
* - decoding: Read by user. |
||||
*/ |
||||
int64_t pkt_duration; |
||||
|
||||
/**
|
||||
* 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 |
||||
|
||||
/**
|
||||
* number of audio channels, only used for audio. |
||||
* - encoding: unused |
||||
* - decoding: Read by user. |
||||
*/ |
||||
int channels; |
||||
|
||||
/**
|
||||
* 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; |
||||
|
||||
#if FF_API_FRAME_QP |
||||
/**
|
||||
* QP table |
||||
*/ |
||||
attribute_deprecated |
||||
int8_t *qscale_table; |
||||
/**
|
||||
* QP store stride |
||||
*/ |
||||
attribute_deprecated |
||||
int qstride; |
||||
|
||||
attribute_deprecated |
||||
int qscale_type; |
||||
|
||||
attribute_deprecated |
||||
AVBufferRef *qp_table_buf; |
||||
#endif |
||||
/**
|
||||
* For hwaccel-format frames, this should be a reference to the |
||||
* AVHWFramesContext describing the frame. |
||||
*/ |
||||
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; |
||||
} AVFrame; |
||||
|
||||
#if FF_API_FRAME_GET_SET |
||||
/**
|
||||
* Accessors for some AVFrame fields. These used to be provided for ABI |
||||
* compatibility, and do not need to be used anymore. |
||||
*/ |
||||
attribute_deprecated |
||||
int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val); |
||||
attribute_deprecated |
||||
int64_t av_frame_get_pkt_duration (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_pkt_duration (AVFrame *frame, int64_t val); |
||||
attribute_deprecated |
||||
int64_t av_frame_get_pkt_pos (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_pkt_pos (AVFrame *frame, int64_t val); |
||||
attribute_deprecated |
||||
int64_t av_frame_get_channel_layout (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_channel_layout (AVFrame *frame, int64_t val); |
||||
attribute_deprecated |
||||
int av_frame_get_channels (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_channels (AVFrame *frame, int val); |
||||
attribute_deprecated |
||||
int av_frame_get_sample_rate (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_sample_rate (AVFrame *frame, int val); |
||||
attribute_deprecated |
||||
AVDictionary *av_frame_get_metadata (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_metadata (AVFrame *frame, AVDictionary *val); |
||||
attribute_deprecated |
||||
int av_frame_get_decode_error_flags (const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_decode_error_flags (AVFrame *frame, int val); |
||||
attribute_deprecated |
||||
int av_frame_get_pkt_size(const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_pkt_size(AVFrame *frame, int val); |
||||
#if FF_API_FRAME_QP |
||||
attribute_deprecated |
||||
int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type); |
||||
attribute_deprecated |
||||
int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type); |
||||
#endif |
||||
attribute_deprecated |
||||
enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val); |
||||
attribute_deprecated |
||||
enum AVColorRange av_frame_get_color_range(const AVFrame *frame); |
||||
attribute_deprecated |
||||
void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val); |
||||
#endif |
||||
|
||||
/**
|
||||
* Get the name of a colorspace. |
||||
* @return a static string identifying the colorspace; can be NULL. |
||||
*/ |
||||
const char *av_get_colorspace_name(enum AVColorSpace val); |
||||
|
||||
/**
|
||||
* 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 channel_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. |
||||
* |
||||
* @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 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, |
||||
#if FF_API_BUFFER_SIZE_T |
||||
int size); |
||||
#else |
||||
size_t size); |
||||
#endif |
||||
|
||||
/**
|
||||
* 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,270 @@ |
||||
/*
|
||||
* Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de> |
||||
* |
||||
* 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_hash_generic |
||||
* Generic hashing API |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HASH_H |
||||
#define AVUTIL_HASH_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_hash Hash Functions |
||||
* @ingroup lavu_crypto |
||||
* Hash functions useful in multimedia. |
||||
* |
||||
* Hash functions are widely used in multimedia, from error checking and |
||||
* concealment to internal regression testing. libavutil has efficient |
||||
* implementations of a variety of hash functions that may be useful for |
||||
* FFmpeg and other multimedia applications. |
||||
* |
||||
* @{ |
||||
* |
||||
* @defgroup lavu_hash_generic Generic Hashing API |
||||
* An abstraction layer for all hash functions supported by libavutil. |
||||
* |
||||
* If your application needs to support a wide range of different hash |
||||
* functions, then the Generic Hashing API is for you. It provides a generic, |
||||
* reusable API for @ref lavu_hash "all hash functions" implemented in libavutil. |
||||
* If you just need to use one particular hash function, use the @ref lavu_hash |
||||
* "individual hash" directly. |
||||
* |
||||
* @section Sample Code |
||||
* |
||||
* A basic template for using the Generic Hashing API follows: |
||||
* |
||||
* @code |
||||
* struct AVHashContext *ctx = NULL; |
||||
* const char *hash_name = NULL; |
||||
* uint8_t *output_buf = NULL; |
||||
* |
||||
* // Select from a string returned by av_hash_names()
|
||||
* hash_name = ...; |
||||
* |
||||
* // Allocate a hash context
|
||||
* ret = av_hash_alloc(&ctx, hash_name); |
||||
* if (ret < 0) |
||||
* return ret; |
||||
* |
||||
* // Initialize the hash context
|
||||
* av_hash_init(ctx); |
||||
* |
||||
* // Update the hash context with data
|
||||
* while (data_left) { |
||||
* av_hash_update(ctx, data, size); |
||||
* } |
||||
* |
||||
* // Now we have no more data, so it is time to finalize the hash and get the
|
||||
* // output. But we need to first allocate an output buffer. Note that you can
|
||||
* // use any memory allocation function, including malloc(), not just
|
||||
* // av_malloc().
|
||||
* output_buf = av_malloc(av_hash_get_size(ctx)); |
||||
* if (!output_buf) |
||||
* return AVERROR(ENOMEM); |
||||
* |
||||
* // Finalize the hash context.
|
||||
* // You can use any of the av_hash_final*() functions provided, for other
|
||||
* // output formats. If you do so, be sure to adjust the memory allocation
|
||||
* // above. See the function documentation below for the exact amount of extra
|
||||
* // memory needed.
|
||||
* av_hash_final(ctx, output_buffer); |
||||
* |
||||
* // Free the context
|
||||
* av_hash_freep(&ctx); |
||||
* @endcode |
||||
* |
||||
* @section Hash Function-Specific Information |
||||
* If the CRC32 hash is selected, the #AV_CRC_32_IEEE polynomial will be |
||||
* used. |
||||
* |
||||
* If the Murmur3 hash is selected, the default seed will be used. See @ref |
||||
* lavu_murmur3_seedinfo "Murmur3" for more information. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @example ffhash.c |
||||
* This example is a simple command line application that takes one or more |
||||
* arguments. It demonstrates a typical use of the hashing API with allocation, |
||||
* initialization, updating, and finalizing. |
||||
*/ |
||||
|
||||
struct AVHashContext; |
||||
|
||||
/**
|
||||
* Allocate a hash context for the algorithm specified by name. |
||||
* |
||||
* @return >= 0 for success, a negative error code for failure |
||||
* |
||||
* @note The context is not initialized after a call to this function; you must |
||||
* call av_hash_init() to do so. |
||||
*/ |
||||
int av_hash_alloc(struct AVHashContext **ctx, const char *name); |
||||
|
||||
/**
|
||||
* Get the names of available hash algorithms. |
||||
* |
||||
* This function can be used to enumerate the algorithms. |
||||
* |
||||
* @param[in] i Index of the hash algorithm, starting from 0 |
||||
* @return Pointer to a static string or `NULL` if `i` is out of range |
||||
*/ |
||||
const char *av_hash_names(int i); |
||||
|
||||
/**
|
||||
* Get the name of the algorithm corresponding to the given hash context. |
||||
*/ |
||||
const char *av_hash_get_name(const struct AVHashContext *ctx); |
||||
|
||||
/**
|
||||
* Maximum value that av_hash_get_size() will currently return. |
||||
* |
||||
* You can use this if you absolutely want or need to use static allocation for |
||||
* the output buffer and are fine with not supporting hashes newly added to |
||||
* libavutil without recompilation. |
||||
* |
||||
* @warning |
||||
* Adding new hashes with larger sizes, and increasing the macro while doing |
||||
* so, will not be considered an ABI change. To prevent your code from |
||||
* overflowing a buffer, either dynamically allocate the output buffer with |
||||
* av_hash_get_size(), or limit your use of the Hashing API to hashes that are |
||||
* already in FFmpeg during the time of compilation. |
||||
*/ |
||||
#define AV_HASH_MAX_SIZE 64 |
||||
|
||||
/**
|
||||
* Get the size of the resulting hash value in bytes. |
||||
* |
||||
* The maximum value this function will currently return is available as macro |
||||
* #AV_HASH_MAX_SIZE. |
||||
* |
||||
* @param[in] ctx Hash context |
||||
* @return Size of the hash value in bytes |
||||
*/ |
||||
int av_hash_get_size(const struct AVHashContext *ctx); |
||||
|
||||
/**
|
||||
* Initialize or reset a hash context. |
||||
* |
||||
* @param[in,out] ctx Hash context |
||||
*/ |
||||
void av_hash_init(struct AVHashContext *ctx); |
||||
|
||||
/**
|
||||
* Update a hash context with additional data. |
||||
* |
||||
* @param[in,out] ctx Hash context |
||||
* @param[in] src Data to be added to the hash context |
||||
* @param[in] len Size of the additional data |
||||
*/ |
||||
#if FF_API_CRYPTO_SIZE_T |
||||
void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, int len); |
||||
#else |
||||
void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, size_t len); |
||||
#endif |
||||
|
||||
/**
|
||||
* Finalize a hash context and compute the actual hash value. |
||||
* |
||||
* The minimum size of `dst` buffer is given by av_hash_get_size() or |
||||
* #AV_HASH_MAX_SIZE. The use of the latter macro is discouraged. |
||||
* |
||||
* It is not safe to update or finalize a hash context again, if it has already |
||||
* been finalized. |
||||
* |
||||
* @param[in,out] ctx Hash context |
||||
* @param[out] dst Where the final hash value will be stored |
||||
* |
||||
* @see av_hash_final_bin() provides an alternative API |
||||
*/ |
||||
void av_hash_final(struct AVHashContext *ctx, uint8_t *dst); |
||||
|
||||
/**
|
||||
* Finalize a hash context and store the actual hash value in a buffer. |
||||
* |
||||
* It is not safe to update or finalize a hash context again, if it has already |
||||
* been finalized. |
||||
* |
||||
* If `size` is smaller than the hash size (given by av_hash_get_size()), the |
||||
* hash is truncated; if size is larger, the buffer is padded with 0. |
||||
* |
||||
* @param[in,out] ctx Hash context |
||||
* @param[out] dst Where the final hash value will be stored |
||||
* @param[in] size Number of bytes to write to `dst` |
||||
*/ |
||||
void av_hash_final_bin(struct AVHashContext *ctx, uint8_t *dst, int size); |
||||
|
||||
/**
|
||||
* Finalize a hash context and store the hexadecimal representation of the |
||||
* actual hash value as a string. |
||||
* |
||||
* It is not safe to update or finalize a hash context again, if it has already |
||||
* been finalized. |
||||
* |
||||
* The string is always 0-terminated. |
||||
* |
||||
* If `size` is smaller than `2 * hash_size + 1`, where `hash_size` is the |
||||
* value returned by av_hash_get_size(), the string will be truncated. |
||||
* |
||||
* @param[in,out] ctx Hash context |
||||
* @param[out] dst Where the string will be stored |
||||
* @param[in] size Maximum number of bytes to write to `dst` |
||||
*/ |
||||
void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size); |
||||
|
||||
/**
|
||||
* Finalize a hash context and store the Base64 representation of the |
||||
* actual hash value as a string. |
||||
* |
||||
* It is not safe to update or finalize a hash context again, if it has already |
||||
* been finalized. |
||||
* |
||||
* The string is always 0-terminated. |
||||
* |
||||
* If `size` is smaller than AV_BASE64_SIZE(hash_size), where `hash_size` is |
||||
* the value returned by av_hash_get_size(), the string will be truncated. |
||||
* |
||||
* @param[in,out] ctx Hash context |
||||
* @param[out] dst Where the final hash value will be stored |
||||
* @param[in] size Maximum number of bytes to write to `dst` |
||||
*/ |
||||
void av_hash_final_b64(struct AVHashContext *ctx, uint8_t *dst, int size); |
||||
|
||||
/**
|
||||
* Free hash context and set hash context pointer to `NULL`. |
||||
* |
||||
* @param[in,out] ctx Pointer to hash context |
||||
*/ |
||||
void av_hash_freep(struct AVHashContext **ctx); |
||||
|
||||
/**
|
||||
* @} |
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_HASH_H */ |
@ -0,0 +1,343 @@ |
||||
/*
|
||||
* Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com> |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HDR_DYNAMIC_METADATA_H |
||||
#define AVUTIL_HDR_DYNAMIC_METADATA_H |
||||
|
||||
#include "frame.h" |
||||
#include "rational.h" |
||||
|
||||
/**
|
||||
* Option for overlapping elliptical pixel selectors in an image. |
||||
*/ |
||||
enum AVHDRPlusOverlapProcessOption { |
||||
AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING = 0, |
||||
AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING = 1, |
||||
}; |
||||
|
||||
/**
|
||||
* Represents the percentile at a specific percentage in |
||||
* a distribution. |
||||
*/ |
||||
typedef struct AVHDRPlusPercentile { |
||||
/**
|
||||
* The percentage value corresponding to a specific percentile linearized |
||||
* RGB value in the processing window in the scene. The value shall be in |
||||
* the range of 0 to100, inclusive. |
||||
*/ |
||||
uint8_t percentage; |
||||
|
||||
/**
|
||||
* The linearized maxRGB value at a specific percentile in the processing |
||||
* window in the scene. The value shall be in the range of 0 to 1, inclusive |
||||
* and in multiples of 0.00001. |
||||
*/ |
||||
AVRational percentile; |
||||
} AVHDRPlusPercentile; |
||||
|
||||
/**
|
||||
* Color transform parameters at a processing window in a dynamic metadata for |
||||
* SMPTE 2094-40. |
||||
*/ |
||||
typedef struct AVHDRPlusColorTransformParams { |
||||
/**
|
||||
* The relative x coordinate of the top left pixel of the processing |
||||
* window. The value shall be in the range of 0 and 1, inclusive and |
||||
* in multiples of 1/(width of Picture - 1). The value 1 corresponds |
||||
* to the absolute coordinate of width of Picture - 1. The value for |
||||
* first processing window shall be 0. |
||||
*/ |
||||
AVRational window_upper_left_corner_x; |
||||
|
||||
/**
|
||||
* The relative y coordinate of the top left pixel of the processing |
||||
* window. The value shall be in the range of 0 and 1, inclusive and |
||||
* in multiples of 1/(height of Picture - 1). The value 1 corresponds |
||||
* to the absolute coordinate of height of Picture - 1. The value for |
||||
* first processing window shall be 0. |
||||
*/ |
||||
AVRational window_upper_left_corner_y; |
||||
|
||||
/**
|
||||
* The relative x coordinate of the bottom right pixel of the processing |
||||
* window. The value shall be in the range of 0 and 1, inclusive and |
||||
* in multiples of 1/(width of Picture - 1). The value 1 corresponds |
||||
* to the absolute coordinate of width of Picture - 1. The value for |
||||
* first processing window shall be 1. |
||||
*/ |
||||
AVRational window_lower_right_corner_x; |
||||
|
||||
/**
|
||||
* The relative y coordinate of the bottom right pixel of the processing |
||||
* window. The value shall be in the range of 0 and 1, inclusive and |
||||
* in multiples of 1/(height of Picture - 1). The value 1 corresponds |
||||
* to the absolute coordinate of height of Picture - 1. The value for |
||||
* first processing window shall be 1. |
||||
*/ |
||||
AVRational window_lower_right_corner_y; |
||||
|
||||
/**
|
||||
* The x coordinate of the center position of the concentric internal and |
||||
* external ellipses of the elliptical pixel selector in the processing |
||||
* window. The value shall be in the range of 0 to (width of Picture - 1), |
||||
* inclusive and in multiples of 1 pixel. |
||||
*/ |
||||
uint16_t center_of_ellipse_x; |
||||
|
||||
/**
|
||||
* The y coordinate of the center position of the concentric internal and |
||||
* external ellipses of the elliptical pixel selector in the processing |
||||
* window. The value shall be in the range of 0 to (height of Picture - 1), |
||||
* inclusive and in multiples of 1 pixel. |
||||
*/ |
||||
uint16_t center_of_ellipse_y; |
||||
|
||||
/**
|
||||
* The clockwise rotation angle in degree of arc with respect to the |
||||
* positive direction of the x-axis of the concentric internal and external |
||||
* ellipses of the elliptical pixel selector in the processing window. The |
||||
* value shall be in the range of 0 to 180, inclusive and in multiples of 1. |
||||
*/ |
||||
uint8_t rotation_angle; |
||||
|
||||
/**
|
||||
* The semi-major axis value of the internal ellipse of the elliptical pixel |
||||
* selector in amount of pixels in the processing window. The value shall be |
||||
* in the range of 1 to 65535, inclusive and in multiples of 1 pixel. |
||||
*/ |
||||
uint16_t semimajor_axis_internal_ellipse; |
||||
|
||||
/**
|
||||
* The semi-major axis value of the external ellipse of the elliptical pixel |
||||
* selector in amount of pixels in the processing window. The value |
||||
* shall not be less than semimajor_axis_internal_ellipse of the current |
||||
* processing window. The value shall be in the range of 1 to 65535, |
||||
* inclusive and in multiples of 1 pixel. |
||||
*/ |
||||
uint16_t semimajor_axis_external_ellipse; |
||||
|
||||
/**
|
||||
* The semi-minor axis value of the external ellipse of the elliptical pixel |
||||
* selector in amount of pixels in the processing window. The value shall be |
||||
* in the range of 1 to 65535, inclusive and in multiples of 1 pixel. |
||||
*/ |
||||
uint16_t semiminor_axis_external_ellipse; |
||||
|
||||
/**
|
||||
* Overlap process option indicates one of the two methods of combining |
||||
* rendered pixels in the processing window in an image with at least one |
||||
* elliptical pixel selector. For overlapping elliptical pixel selectors |
||||
* in an image, overlap_process_option shall have the same value. |
||||
*/ |
||||
enum AVHDRPlusOverlapProcessOption overlap_process_option; |
||||
|
||||
/**
|
||||
* The maximum of the color components of linearized RGB values in the |
||||
* processing window in the scene. The values should be in the range of 0 to |
||||
* 1, inclusive and in multiples of 0.00001. maxscl[ 0 ], maxscl[ 1 ], and |
||||
* maxscl[ 2 ] are corresponding to R, G, B color components respectively. |
||||
*/ |
||||
AVRational maxscl[3]; |
||||
|
||||
/**
|
||||
* The average of linearized maxRGB values in the processing window in the |
||||
* scene. The value should be in the range of 0 to 1, inclusive and in |
||||
* multiples of 0.00001. |
||||
*/ |
||||
AVRational average_maxrgb; |
||||
|
||||
/**
|
||||
* The number of linearized maxRGB values at given percentiles in the |
||||
* processing window in the scene. The maximum value shall be 15. |
||||
*/ |
||||
uint8_t num_distribution_maxrgb_percentiles; |
||||
|
||||
/**
|
||||
* The linearized maxRGB values at given percentiles in the |
||||
* processing window in the scene. |
||||
*/ |
||||
AVHDRPlusPercentile distribution_maxrgb[15]; |
||||
|
||||
/**
|
||||
* The fraction of selected pixels in the image that contains the brightest |
||||
* pixel in the scene. The value shall be in the range of 0 to 1, inclusive |
||||
* and in multiples of 0.001. |
||||
*/ |
||||
AVRational fraction_bright_pixels; |
||||
|
||||
/**
|
||||
* This flag indicates that the metadata for the tone mapping function in |
||||
* the processing window is present (for value of 1). |
||||
*/ |
||||
uint8_t tone_mapping_flag; |
||||
|
||||
/**
|
||||
* The x coordinate of the separation point between the linear part and the |
||||
* curved part of the tone mapping function. The value shall be in the range |
||||
* of 0 to 1, excluding 0 and in multiples of 1/4095. |
||||
*/ |
||||
AVRational knee_point_x; |
||||
|
||||
/**
|
||||
* The y coordinate of the separation point between the linear part and the |
||||
* curved part of the tone mapping function. The value shall be in the range |
||||
* of 0 to 1, excluding 0 and in multiples of 1/4095. |
||||
*/ |
||||
AVRational knee_point_y; |
||||
|
||||
/**
|
||||
* The number of the intermediate anchor parameters of the tone mapping |
||||
* function in the processing window. The maximum value shall be 15. |
||||
*/ |
||||
uint8_t num_bezier_curve_anchors; |
||||
|
||||
/**
|
||||
* The intermediate anchor parameters of the tone mapping function in the |
||||
* processing window in the scene. The values should be in the range of 0 |
||||
* to 1, inclusive and in multiples of 1/1023. |
||||
*/ |
||||
AVRational bezier_curve_anchors[15]; |
||||
|
||||
/**
|
||||
* This flag shall be equal to 0 in bitstreams conforming to this version of |
||||
* this Specification. Other values are reserved for future use. |
||||
*/ |
||||
uint8_t color_saturation_mapping_flag; |
||||
|
||||
/**
|
||||
* The color saturation gain in the processing window in the scene. The |
||||
* value shall be in the range of 0 to 63/8, inclusive and in multiples of |
||||
* 1/8. The default value shall be 1. |
||||
*/ |
||||
AVRational color_saturation_weight; |
||||
} AVHDRPlusColorTransformParams; |
||||
|
||||
/**
|
||||
* This struct represents dynamic metadata for color volume transform - |
||||
* application 4 of SMPTE 2094-40:2016 standard. |
||||
* |
||||
* To be used as payload of a AVFrameSideData or AVPacketSideData with the |
||||
* appropriate type. |
||||
* |
||||
* @note The struct should be allocated with |
||||
* av_dynamic_hdr_plus_alloc() and its size is not a part of |
||||
* the public ABI. |
||||
*/ |
||||
typedef struct AVDynamicHDRPlus { |
||||
/**
|
||||
* Country code by Rec. ITU-T T.35 Annex A. The value shall be 0xB5. |
||||
*/ |
||||
uint8_t itu_t_t35_country_code; |
||||
|
||||
/**
|
||||
* Application version in the application defining document in ST-2094 |
||||
* suite. The value shall be set to 0. |
||||
*/ |
||||
uint8_t application_version; |
||||
|
||||
/**
|
||||
* The number of processing windows. The value shall be in the range |
||||
* of 1 to 3, inclusive. |
||||
*/ |
||||
uint8_t num_windows; |
||||
|
||||
/**
|
||||
* The color transform parameters for every processing window. |
||||
*/ |
||||
AVHDRPlusColorTransformParams params[3]; |
||||
|
||||
/**
|
||||
* The nominal maximum display luminance of the targeted system display, |
||||
* in units of 0.0001 candelas per square metre. The value shall be in |
||||
* the range of 0 to 10000, inclusive. |
||||
*/ |
||||
AVRational targeted_system_display_maximum_luminance; |
||||
|
||||
/**
|
||||
* This flag shall be equal to 0 in bit streams conforming to this version |
||||
* of this Specification. The value 1 is reserved for future use. |
||||
*/ |
||||
uint8_t targeted_system_display_actual_peak_luminance_flag; |
||||
|
||||
/**
|
||||
* The number of rows in the targeted system_display_actual_peak_luminance |
||||
* array. The value shall be in the range of 2 to 25, inclusive. |
||||
*/ |
||||
uint8_t num_rows_targeted_system_display_actual_peak_luminance; |
||||
|
||||
/**
|
||||
* The number of columns in the |
||||
* targeted_system_display_actual_peak_luminance array. The value shall be |
||||
* in the range of 2 to 25, inclusive. |
||||
*/ |
||||
uint8_t num_cols_targeted_system_display_actual_peak_luminance; |
||||
|
||||
/**
|
||||
* The normalized actual peak luminance of the targeted system display. The |
||||
* values should be in the range of 0 to 1, inclusive and in multiples of |
||||
* 1/15. |
||||
*/ |
||||
AVRational targeted_system_display_actual_peak_luminance[25][25]; |
||||
|
||||
/**
|
||||
* This flag shall be equal to 0 in bitstreams conforming to this version of |
||||
* this Specification. The value 1 is reserved for future use. |
||||
*/ |
||||
uint8_t mastering_display_actual_peak_luminance_flag; |
||||
|
||||
/**
|
||||
* The number of rows in the mastering_display_actual_peak_luminance array. |
||||
* The value shall be in the range of 2 to 25, inclusive. |
||||
*/ |
||||
uint8_t num_rows_mastering_display_actual_peak_luminance; |
||||
|
||||
/**
|
||||
* The number of columns in the mastering_display_actual_peak_luminance |
||||
* array. The value shall be in the range of 2 to 25, inclusive. |
||||
*/ |
||||
uint8_t num_cols_mastering_display_actual_peak_luminance; |
||||
|
||||
/**
|
||||
* The normalized actual peak luminance of the mastering display used for |
||||
* mastering the image essence. The values should be in the range of 0 to 1, |
||||
* inclusive and in multiples of 1/15. |
||||
*/ |
||||
AVRational mastering_display_actual_peak_luminance[25][25]; |
||||
} AVDynamicHDRPlus; |
||||
|
||||
/**
|
||||
* Allocate an AVDynamicHDRPlus structure and set its fields to |
||||
* default values. The resulting struct can be freed using av_freep(). |
||||
* |
||||
* @return An AVDynamicHDRPlus filled with default values or NULL |
||||
* on failure. |
||||
*/ |
||||
AVDynamicHDRPlus *av_dynamic_hdr_plus_alloc(size_t *size); |
||||
|
||||
/**
|
||||
* Allocate a complete AVDynamicHDRPlus and add it to the frame. |
||||
* @param frame The frame which side data is added to. |
||||
* |
||||
* @return The AVDynamicHDRPlus structure to be filled by caller or NULL |
||||
* on failure. |
||||
*/ |
||||
AVDynamicHDRPlus *av_dynamic_hdr_plus_create_side_data(AVFrame *frame); |
||||
|
||||
#endif /* AVUTIL_HDR_DYNAMIC_METADATA_H */ |
@ -0,0 +1,100 @@ |
||||
/*
|
||||
* Copyright (C) 2012 Martin Storsjo |
||||
* |
||||
* 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_HMAC_H |
||||
#define AVUTIL_HMAC_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "version.h" |
||||
/**
|
||||
* @defgroup lavu_hmac HMAC |
||||
* @ingroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
enum AVHMACType { |
||||
AV_HMAC_MD5, |
||||
AV_HMAC_SHA1, |
||||
AV_HMAC_SHA224, |
||||
AV_HMAC_SHA256, |
||||
AV_HMAC_SHA384, |
||||
AV_HMAC_SHA512, |
||||
}; |
||||
|
||||
typedef struct AVHMAC AVHMAC; |
||||
|
||||
/**
|
||||
* Allocate an AVHMAC context. |
||||
* @param type The hash function used for the HMAC. |
||||
*/ |
||||
AVHMAC *av_hmac_alloc(enum AVHMACType type); |
||||
|
||||
/**
|
||||
* Free an AVHMAC context. |
||||
* @param ctx The context to free, may be NULL |
||||
*/ |
||||
void av_hmac_free(AVHMAC *ctx); |
||||
|
||||
/**
|
||||
* Initialize an AVHMAC context with an authentication key. |
||||
* @param ctx The HMAC context |
||||
* @param key The authentication key |
||||
* @param keylen The length of the key, in bytes |
||||
*/ |
||||
void av_hmac_init(AVHMAC *ctx, const uint8_t *key, unsigned int keylen); |
||||
|
||||
/**
|
||||
* Hash data with the HMAC. |
||||
* @param ctx The HMAC context |
||||
* @param data The data to hash |
||||
* @param len The length of the data, in bytes |
||||
*/ |
||||
void av_hmac_update(AVHMAC *ctx, const uint8_t *data, unsigned int len); |
||||
|
||||
/**
|
||||
* Finish hashing and output the HMAC digest. |
||||
* @param ctx The HMAC context |
||||
* @param out The output buffer to write the digest into |
||||
* @param outlen The length of the out buffer, in bytes |
||||
* @return The number of bytes written to out, or a negative error code. |
||||
*/ |
||||
int av_hmac_final(AVHMAC *ctx, uint8_t *out, unsigned int outlen); |
||||
|
||||
/**
|
||||
* Hash an array of data with a key. |
||||
* @param ctx The HMAC context |
||||
* @param data The data to hash |
||||
* @param len The length of the data, in bytes |
||||
* @param key The authentication key |
||||
* @param keylen The length of the key, in bytes |
||||
* @param out The output buffer to write the digest into |
||||
* @param outlen The length of the out buffer, in bytes |
||||
* @return The number of bytes written to out, or a negative error code. |
||||
*/ |
||||
int av_hmac_calc(AVHMAC *ctx, const uint8_t *data, unsigned int len, |
||||
const uint8_t *key, unsigned int keylen, |
||||
uint8_t *out, unsigned int outlen); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_HMAC_H */ |
@ -0,0 +1,605 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_H |
||||
#define AVUTIL_HWCONTEXT_H |
||||
|
||||
#include "buffer.h" |
||||
#include "frame.h" |
||||
#include "log.h" |
||||
#include "pixfmt.h" |
||||
|
||||
enum AVHWDeviceType { |
||||
AV_HWDEVICE_TYPE_NONE, |
||||
AV_HWDEVICE_TYPE_VDPAU, |
||||
AV_HWDEVICE_TYPE_CUDA, |
||||
AV_HWDEVICE_TYPE_VAAPI, |
||||
AV_HWDEVICE_TYPE_DXVA2, |
||||
AV_HWDEVICE_TYPE_QSV, |
||||
AV_HWDEVICE_TYPE_VIDEOTOOLBOX, |
||||
AV_HWDEVICE_TYPE_D3D11VA, |
||||
AV_HWDEVICE_TYPE_DRM, |
||||
AV_HWDEVICE_TYPE_OPENCL, |
||||
AV_HWDEVICE_TYPE_MEDIACODEC, |
||||
AV_HWDEVICE_TYPE_VULKAN, |
||||
}; |
||||
|
||||
typedef struct AVHWDeviceInternal AVHWDeviceInternal; |
||||
|
||||
/**
|
||||
* This struct aggregates all the (hardware/vendor-specific) "high-level" state, |
||||
* i.e. state that is not tied to a concrete processing configuration. |
||||
* E.g., in an API that supports hardware-accelerated encoding and decoding, |
||||
* this struct will (if possible) wrap the state that is common to both encoding |
||||
* and decoding and from which specific instances of encoders or decoders can be |
||||
* derived. |
||||
* |
||||
* This struct is reference-counted with the AVBuffer mechanism. The |
||||
* av_hwdevice_ctx_alloc() constructor yields a reference, whose data field |
||||
* points to the actual AVHWDeviceContext. Further objects derived from |
||||
* AVHWDeviceContext (such as AVHWFramesContext, describing a frame pool with |
||||
* specific properties) will hold an internal reference to it. After all the |
||||
* references are released, the AVHWDeviceContext itself will be freed, |
||||
* optionally invoking a user-specified callback for uninitializing the hardware |
||||
* state. |
||||
*/ |
||||
typedef struct AVHWDeviceContext { |
||||
/**
|
||||
* A class for logging. Set by av_hwdevice_ctx_alloc(). |
||||
*/ |
||||
const AVClass *av_class; |
||||
|
||||
/**
|
||||
* Private data used internally by libavutil. Must not be accessed in any |
||||
* way by the caller. |
||||
*/ |
||||
AVHWDeviceInternal *internal; |
||||
|
||||
/**
|
||||
* This field identifies the underlying API used for hardware access. |
||||
* |
||||
* This field is set when this struct is allocated and never changed |
||||
* afterwards. |
||||
*/ |
||||
enum AVHWDeviceType type; |
||||
|
||||
/**
|
||||
* The format-specific data, allocated and freed by libavutil along with |
||||
* this context. |
||||
* |
||||
* Should be cast by the user to the format-specific context defined in the |
||||
* corresponding header (hwcontext_*.h) and filled as described in the |
||||
* documentation before calling av_hwdevice_ctx_init(). |
||||
* |
||||
* After calling av_hwdevice_ctx_init() this struct should not be modified |
||||
* by the caller. |
||||
*/ |
||||
void *hwctx; |
||||
|
||||
/**
|
||||
* This field may be set by the caller before calling av_hwdevice_ctx_init(). |
||||
* |
||||
* If non-NULL, this callback will be called when the last reference to |
||||
* this context is unreferenced, immediately before it is freed. |
||||
* |
||||
* @note when other objects (e.g an AVHWFramesContext) are derived from this |
||||
* struct, this callback will be invoked after all such child objects |
||||
* are fully uninitialized and their respective destructors invoked. |
||||
*/ |
||||
void (*free)(struct AVHWDeviceContext *ctx); |
||||
|
||||
/**
|
||||
* Arbitrary user data, to be used e.g. by the free() callback. |
||||
*/ |
||||
void *user_opaque; |
||||
} AVHWDeviceContext; |
||||
|
||||
typedef struct AVHWFramesInternal AVHWFramesInternal; |
||||
|
||||
/**
|
||||
* This struct describes a set or pool of "hardware" frames (i.e. those with |
||||
* data not located in normal system memory). All the frames in the pool are |
||||
* assumed to be allocated in the same way and interchangeable. |
||||
* |
||||
* This struct is reference-counted with the AVBuffer mechanism and tied to a |
||||
* given AVHWDeviceContext instance. The av_hwframe_ctx_alloc() constructor |
||||
* yields a reference, whose data field points to the actual AVHWFramesContext |
||||
* struct. |
||||
*/ |
||||
typedef struct AVHWFramesContext { |
||||
/**
|
||||
* A class for logging. |
||||
*/ |
||||
const AVClass *av_class; |
||||
|
||||
/**
|
||||
* Private data used internally by libavutil. Must not be accessed in any |
||||
* way by the caller. |
||||
*/ |
||||
AVHWFramesInternal *internal; |
||||
|
||||
/**
|
||||
* A reference to the parent AVHWDeviceContext. This reference is owned and |
||||
* managed by the enclosing AVHWFramesContext, but the caller may derive |
||||
* additional references from it. |
||||
*/ |
||||
AVBufferRef *device_ref; |
||||
|
||||
/**
|
||||
* The parent AVHWDeviceContext. This is simply a pointer to |
||||
* device_ref->data provided for convenience. |
||||
* |
||||
* Set by libavutil in av_hwframe_ctx_init(). |
||||
*/ |
||||
AVHWDeviceContext *device_ctx; |
||||
|
||||
/**
|
||||
* The format-specific data, allocated and freed automatically along with |
||||
* this context. |
||||
* |
||||
* Should be cast by the user to the format-specific context defined in the |
||||
* corresponding header (hwframe_*.h) and filled as described in the |
||||
* documentation before calling av_hwframe_ctx_init(). |
||||
* |
||||
* After any frames using this context are created, the contents of this |
||||
* struct should not be modified by the caller. |
||||
*/ |
||||
void *hwctx; |
||||
|
||||
/**
|
||||
* This field may be set by the caller before calling av_hwframe_ctx_init(). |
||||
* |
||||
* If non-NULL, this callback will be called when the last reference to |
||||
* this context is unreferenced, immediately before it is freed. |
||||
*/ |
||||
void (*free)(struct AVHWFramesContext *ctx); |
||||
|
||||
/**
|
||||
* Arbitrary user data, to be used e.g. by the free() callback. |
||||
*/ |
||||
void *user_opaque; |
||||
|
||||
/**
|
||||
* A pool from which the frames are allocated by av_hwframe_get_buffer(). |
||||
* This field may be set by the caller before calling av_hwframe_ctx_init(). |
||||
* The buffers returned by calling av_buffer_pool_get() on this pool must |
||||
* have the properties described in the documentation in the corresponding hw |
||||
* type's header (hwcontext_*.h). The pool will be freed strictly before |
||||
* this struct's free() callback is invoked. |
||||
* |
||||
* This field may be NULL, then libavutil will attempt to allocate a pool |
||||
* internally. Note that certain device types enforce pools allocated at |
||||
* fixed size (frame count), which cannot be extended dynamically. In such a |
||||
* case, initial_pool_size must be set appropriately. |
||||
*/ |
||||
AVBufferPool *pool; |
||||
|
||||
/**
|
||||
* Initial size of the frame pool. If a device type does not support |
||||
* dynamically resizing the pool, then this is also the maximum pool size. |
||||
* |
||||
* May be set by the caller before calling av_hwframe_ctx_init(). Must be |
||||
* set if pool is NULL and the device type does not support dynamic pools. |
||||
*/ |
||||
int initial_pool_size; |
||||
|
||||
/**
|
||||
* The pixel format identifying the underlying HW surface type. |
||||
* |
||||
* Must be a hwaccel format, i.e. the corresponding descriptor must have the |
||||
* AV_PIX_FMT_FLAG_HWACCEL flag set. |
||||
* |
||||
* Must be set by the user before calling av_hwframe_ctx_init(). |
||||
*/ |
||||
enum AVPixelFormat format; |
||||
|
||||
/**
|
||||
* The pixel format identifying the actual data layout of the hardware |
||||
* frames. |
||||
* |
||||
* Must be set by the caller before calling av_hwframe_ctx_init(). |
||||
* |
||||
* @note when the underlying API does not provide the exact data layout, but |
||||
* only the colorspace/bit depth, this field should be set to the fully |
||||
* planar version of that format (e.g. for 8-bit 420 YUV it should be |
||||
* AV_PIX_FMT_YUV420P, not AV_PIX_FMT_NV12 or anything else). |
||||
*/ |
||||
enum AVPixelFormat sw_format; |
||||
|
||||
/**
|
||||
* The allocated dimensions of the frames in this pool. |
||||
* |
||||
* Must be set by the user before calling av_hwframe_ctx_init(). |
||||
*/ |
||||
int width, height; |
||||
} AVHWFramesContext; |
||||
|
||||
/**
|
||||
* Look up an AVHWDeviceType by name. |
||||
* |
||||
* @param name String name of the device type (case-insensitive). |
||||
* @return The type from enum AVHWDeviceType, or AV_HWDEVICE_TYPE_NONE if |
||||
* not found. |
||||
*/ |
||||
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name); |
||||
|
||||
/** Get the string name of an AVHWDeviceType.
|
||||
* |
||||
* @param type Type from enum AVHWDeviceType. |
||||
* @return Pointer to a static string containing the name, or NULL if the type |
||||
* is not valid. |
||||
*/ |
||||
const char *av_hwdevice_get_type_name(enum AVHWDeviceType type); |
||||
|
||||
/**
|
||||
* Iterate over supported device types. |
||||
* |
||||
* @param type AV_HWDEVICE_TYPE_NONE initially, then the previous type |
||||
* returned by this function in subsequent iterations. |
||||
* @return The next usable device type from enum AVHWDeviceType, or |
||||
* AV_HWDEVICE_TYPE_NONE if there are no more. |
||||
*/ |
||||
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev); |
||||
|
||||
/**
|
||||
* Allocate an AVHWDeviceContext for a given hardware type. |
||||
* |
||||
* @param type the type of the hardware device to allocate. |
||||
* @return a reference to the newly created AVHWDeviceContext on success or NULL |
||||
* on failure. |
||||
*/ |
||||
AVBufferRef *av_hwdevice_ctx_alloc(enum AVHWDeviceType type); |
||||
|
||||
/**
|
||||
* Finalize the device context before use. This function must be called after |
||||
* the context is filled with all the required information and before it is |
||||
* used in any way. |
||||
* |
||||
* @param ref a reference to the AVHWDeviceContext |
||||
* @return 0 on success, a negative AVERROR code on failure |
||||
*/ |
||||
int av_hwdevice_ctx_init(AVBufferRef *ref); |
||||
|
||||
/**
|
||||
* Open a device of the specified type and create an AVHWDeviceContext for it. |
||||
* |
||||
* This is a convenience function intended to cover the simple cases. Callers |
||||
* who need to fine-tune device creation/management should open the device |
||||
* manually and then wrap it in an AVHWDeviceContext using |
||||
* av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init(). |
||||
* |
||||
* The returned context is already initialized and ready for use, the caller |
||||
* should not call av_hwdevice_ctx_init() on it. The user_opaque/free fields of |
||||
* the created AVHWDeviceContext are set by this function and should not be |
||||
* touched by the caller. |
||||
* |
||||
* @param device_ctx On success, a reference to the newly-created device context |
||||
* will be written here. The reference is owned by the caller |
||||
* and must be released with av_buffer_unref() when no longer |
||||
* needed. On failure, NULL will be written to this pointer. |
||||
* @param type The type of the device to create. |
||||
* @param device A type-specific string identifying the device to open. |
||||
* @param opts A dictionary of additional (type-specific) options to use in |
||||
* opening the device. The dictionary remains owned by the caller. |
||||
* @param flags currently unused |
||||
* |
||||
* @return 0 on success, a negative AVERROR code on failure. |
||||
*/ |
||||
int av_hwdevice_ctx_create(AVBufferRef **device_ctx, enum AVHWDeviceType type, |
||||
const char *device, AVDictionary *opts, int flags); |
||||
|
||||
/**
|
||||
* Create a new device of the specified type from an existing device. |
||||
* |
||||
* If the source device is a device of the target type or was originally |
||||
* derived from such a device (possibly through one or more intermediate |
||||
* devices of other types), then this will return a reference to the |
||||
* existing device of the same type as is requested. |
||||
* |
||||
* Otherwise, it will attempt to derive a new device from the given source |
||||
* device. If direct derivation to the new type is not implemented, it will |
||||
* attempt the same derivation from each ancestor of the source device in |
||||
* turn looking for an implemented derivation method. |
||||
* |
||||
* @param dst_ctx On success, a reference to the newly-created |
||||
* AVHWDeviceContext. |
||||
* @param type The type of the new device to create. |
||||
* @param src_ctx A reference to an existing AVHWDeviceContext which will be |
||||
* used to create the new device. |
||||
* @param flags Currently unused; should be set to zero. |
||||
* @return Zero on success, a negative AVERROR code on failure. |
||||
*/ |
||||
int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx, |
||||
enum AVHWDeviceType type, |
||||
AVBufferRef *src_ctx, int flags); |
||||
|
||||
/**
|
||||
* Create a new device of the specified type from an existing device. |
||||
* |
||||
* This function performs the same action as av_hwdevice_ctx_create_derived, |
||||
* however, it is able to set options for the new device to be derived. |
||||
* |
||||
* @param dst_ctx On success, a reference to the newly-created |
||||
* AVHWDeviceContext. |
||||
* @param type The type of the new device to create. |
||||
* @param src_ctx A reference to an existing AVHWDeviceContext which will be |
||||
* used to create the new device. |
||||
* @param options Options for the new device to create, same format as in |
||||
* av_hwdevice_ctx_create. |
||||
* @param flags Currently unused; should be set to zero. |
||||
* @return Zero on success, a negative AVERROR code on failure. |
||||
*/ |
||||
int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ctx, |
||||
enum AVHWDeviceType type, |
||||
AVBufferRef *src_ctx, |
||||
AVDictionary *options, int flags); |
||||
|
||||
/**
|
||||
* Allocate an AVHWFramesContext tied to a given device context. |
||||
* |
||||
* @param device_ctx a reference to a AVHWDeviceContext. This function will make |
||||
* a new reference for internal use, the one passed to the |
||||
* function remains owned by the caller. |
||||
* @return a reference to the newly created AVHWFramesContext on success or NULL |
||||
* on failure. |
||||
*/ |
||||
AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ctx); |
||||
|
||||
/**
|
||||
* Finalize the context before use. This function must be called after the |
||||
* context is filled with all the required information and before it is attached |
||||
* to any frames. |
||||
* |
||||
* @param ref a reference to the AVHWFramesContext |
||||
* @return 0 on success, a negative AVERROR code on failure |
||||
*/ |
||||
int av_hwframe_ctx_init(AVBufferRef *ref); |
||||
|
||||
/**
|
||||
* Allocate a new frame attached to the given AVHWFramesContext. |
||||
* |
||||
* @param hwframe_ctx a reference to an AVHWFramesContext |
||||
* @param frame an empty (freshly allocated or unreffed) frame to be filled with |
||||
* newly allocated buffers. |
||||
* @param flags currently unused, should be set to zero |
||||
* @return 0 on success, a negative AVERROR code on failure |
||||
*/ |
||||
int av_hwframe_get_buffer(AVBufferRef *hwframe_ctx, AVFrame *frame, int flags); |
||||
|
||||
/**
|
||||
* Copy data to or from a hw surface. At least one of dst/src must have an |
||||
* AVHWFramesContext attached. |
||||
* |
||||
* If src has an AVHWFramesContext attached, then the format of dst (if set) |
||||
* must use one of the formats returned by av_hwframe_transfer_get_formats(src, |
||||
* AV_HWFRAME_TRANSFER_DIRECTION_FROM). |
||||
* If dst has an AVHWFramesContext attached, then the format of src must use one |
||||
* of the formats returned by av_hwframe_transfer_get_formats(dst, |
||||
* AV_HWFRAME_TRANSFER_DIRECTION_TO) |
||||
* |
||||
* dst may be "clean" (i.e. with data/buf pointers unset), in which case the |
||||
* data buffers will be allocated by this function using av_frame_get_buffer(). |
||||
* If dst->format is set, then this format will be used, otherwise (when |
||||
* dst->format is AV_PIX_FMT_NONE) the first acceptable format will be chosen. |
||||
* |
||||
* The two frames must have matching allocated dimensions (i.e. equal to |
||||
* AVHWFramesContext.width/height), since not all device types support |
||||
* transferring a sub-rectangle of the whole surface. The display dimensions |
||||
* (i.e. AVFrame.width/height) may be smaller than the allocated dimensions, but |
||||
* also have to be equal for both frames. When the display dimensions are |
||||
* smaller than the allocated dimensions, the content of the padding in the |
||||
* destination frame is unspecified. |
||||
* |
||||
* @param dst the destination frame. dst is not touched on failure. |
||||
* @param src the source frame. |
||||
* @param flags currently unused, should be set to zero |
||||
* @return 0 on success, a negative AVERROR error code on failure. |
||||
*/ |
||||
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags); |
||||
|
||||
enum AVHWFrameTransferDirection { |
||||
/**
|
||||
* Transfer the data from the queried hw frame. |
||||
*/ |
||||
AV_HWFRAME_TRANSFER_DIRECTION_FROM, |
||||
|
||||
/**
|
||||
* Transfer the data to the queried hw frame. |
||||
*/ |
||||
AV_HWFRAME_TRANSFER_DIRECTION_TO, |
||||
}; |
||||
|
||||
/**
|
||||
* Get a list of possible source or target formats usable in |
||||
* av_hwframe_transfer_data(). |
||||
* |
||||
* @param hwframe_ctx the frame context to obtain the information for |
||||
* @param dir the direction of the transfer |
||||
* @param formats the pointer to the output format list will be written here. |
||||
* The list is terminated with AV_PIX_FMT_NONE and must be freed |
||||
* by the caller when no longer needed using av_free(). |
||||
* If this function returns successfully, the format list will |
||||
* have at least one item (not counting the terminator). |
||||
* On failure, the contents of this pointer are unspecified. |
||||
* @param flags currently unused, should be set to zero |
||||
* @return 0 on success, a negative AVERROR code on failure. |
||||
*/ |
||||
int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ctx, |
||||
enum AVHWFrameTransferDirection dir, |
||||
enum AVPixelFormat **formats, int flags); |
||||
|
||||
|
||||
/**
|
||||
* This struct describes the constraints on hardware frames attached to |
||||
* a given device with a hardware-specific configuration. This is returned |
||||
* by av_hwdevice_get_hwframe_constraints() and must be freed by |
||||
* av_hwframe_constraints_free() after use. |
||||
*/ |
||||
typedef struct AVHWFramesConstraints { |
||||
/**
|
||||
* A list of possible values for format in the hw_frames_ctx, |
||||
* terminated by AV_PIX_FMT_NONE. This member will always be filled. |
||||
*/ |
||||
enum AVPixelFormat *valid_hw_formats; |
||||
|
||||
/**
|
||||
* A list of possible values for sw_format in the hw_frames_ctx, |
||||
* terminated by AV_PIX_FMT_NONE. Can be NULL if this information is |
||||
* not known. |
||||
*/ |
||||
enum AVPixelFormat *valid_sw_formats; |
||||
|
||||
/**
|
||||
* The minimum size of frames in this hw_frames_ctx. |
||||
* (Zero if not known.) |
||||
*/ |
||||
int min_width; |
||||
int min_height; |
||||
|
||||
/**
|
||||
* The maximum size of frames in this hw_frames_ctx. |
||||
* (INT_MAX if not known / no limit.) |
||||
*/ |
||||
int max_width; |
||||
int max_height; |
||||
} AVHWFramesConstraints; |
||||
|
||||
/**
|
||||
* Allocate a HW-specific configuration structure for a given HW device. |
||||
* After use, the user must free all members as required by the specific |
||||
* hardware structure being used, then free the structure itself with |
||||
* av_free(). |
||||
* |
||||
* @param device_ctx a reference to the associated AVHWDeviceContext. |
||||
* @return The newly created HW-specific configuration structure on |
||||
* success or NULL on failure. |
||||
*/ |
||||
void *av_hwdevice_hwconfig_alloc(AVBufferRef *device_ctx); |
||||
|
||||
/**
|
||||
* Get the constraints on HW frames given a device and the HW-specific |
||||
* configuration to be used with that device. If no HW-specific |
||||
* configuration is provided, returns the maximum possible capabilities |
||||
* of the device. |
||||
* |
||||
* @param ref a reference to the associated AVHWDeviceContext. |
||||
* @param hwconfig a filled HW-specific configuration structure, or NULL |
||||
* to return the maximum possible capabilities of the device. |
||||
* @return AVHWFramesConstraints structure describing the constraints |
||||
* on the device, or NULL if not available. |
||||
*/ |
||||
AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref, |
||||
const void *hwconfig); |
||||
|
||||
/**
|
||||
* Free an AVHWFrameConstraints structure. |
||||
* |
||||
* @param constraints The (filled or unfilled) AVHWFrameConstraints structure. |
||||
*/ |
||||
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints); |
||||
|
||||
|
||||
/**
|
||||
* Flags to apply to frame mappings. |
||||
*/ |
||||
enum { |
||||
/**
|
||||
* The mapping must be readable. |
||||
*/ |
||||
AV_HWFRAME_MAP_READ = 1 << 0, |
||||
/**
|
||||
* The mapping must be writeable. |
||||
*/ |
||||
AV_HWFRAME_MAP_WRITE = 1 << 1, |
||||
/**
|
||||
* The mapped frame will be overwritten completely in subsequent |
||||
* operations, so the current frame data need not be loaded. Any values |
||||
* which are not overwritten are unspecified. |
||||
*/ |
||||
AV_HWFRAME_MAP_OVERWRITE = 1 << 2, |
||||
/**
|
||||
* The mapping must be direct. That is, there must not be any copying in |
||||
* the map or unmap steps. Note that performance of direct mappings may |
||||
* be much lower than normal memory. |
||||
*/ |
||||
AV_HWFRAME_MAP_DIRECT = 1 << 3, |
||||
}; |
||||
|
||||
/**
|
||||
* Map a hardware frame. |
||||
* |
||||
* This has a number of different possible effects, depending on the format |
||||
* and origin of the src and dst frames. On input, src should be a usable |
||||
* frame with valid buffers and dst should be blank (typically as just created |
||||
* by av_frame_alloc()). src should have an associated hwframe context, and |
||||
* dst may optionally have a format and associated hwframe context. |
||||
* |
||||
* If src was created by mapping a frame from the hwframe context of dst, |
||||
* then this function undoes the mapping - dst is replaced by a reference to |
||||
* the frame that src was originally mapped from. |
||||
* |
||||
* If both src and dst have an associated hwframe context, then this function |
||||
* attempts to map the src frame from its hardware context to that of dst and |
||||
* then fill dst with appropriate data to be usable there. This will only be |
||||
* possible if the hwframe contexts and associated devices are compatible - |
||||
* given compatible devices, av_hwframe_ctx_create_derived() can be used to |
||||
* create a hwframe context for dst in which mapping should be possible. |
||||
* |
||||
* If src has a hwframe context but dst does not, then the src frame is |
||||
* mapped to normal memory and should thereafter be usable as a normal frame. |
||||
* If the format is set on dst, then the mapping will attempt to create dst |
||||
* with that format and fail if it is not possible. If format is unset (is |
||||
* AV_PIX_FMT_NONE) then dst will be mapped with whatever the most appropriate |
||||
* format to use is (probably the sw_format of the src hwframe context). |
||||
* |
||||
* A return value of AVERROR(ENOSYS) indicates that the mapping is not |
||||
* possible with the given arguments and hwframe setup, while other return |
||||
* values indicate that it failed somehow. |
||||
* |
||||
* @param dst Destination frame, to contain the mapping. |
||||
* @param src Source frame, to be mapped. |
||||
* @param flags Some combination of AV_HWFRAME_MAP_* flags. |
||||
* @return Zero on success, negative AVERROR code on failure. |
||||
*/ |
||||
int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags); |
||||
|
||||
|
||||
/**
|
||||
* Create and initialise an AVHWFramesContext as a mapping of another existing |
||||
* AVHWFramesContext on a different device. |
||||
* |
||||
* av_hwframe_ctx_init() should not be called after this. |
||||
* |
||||
* @param derived_frame_ctx On success, a reference to the newly created |
||||
* AVHWFramesContext. |
||||
* @param derived_device_ctx A reference to the device to create the new |
||||
* AVHWFramesContext on. |
||||
* @param source_frame_ctx A reference to an existing AVHWFramesContext |
||||
* which will be mapped to the derived context. |
||||
* @param flags Some combination of AV_HWFRAME_MAP_* flags, defining the |
||||
* mapping parameters to apply to frames which are allocated |
||||
* in the derived device. |
||||
* @return Zero on success, negative AVERROR code on failure. |
||||
*/ |
||||
int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx, |
||||
enum AVPixelFormat format, |
||||
AVBufferRef *derived_device_ctx, |
||||
AVBufferRef *source_frame_ctx, |
||||
int flags); |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_H */ |
@ -0,0 +1,69 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_CUDA_H |
||||
#define AVUTIL_HWCONTEXT_CUDA_H |
||||
|
||||
#ifndef CUDA_VERSION |
||||
#include <cuda.h> |
||||
#endif |
||||
|
||||
#include "pixfmt.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* An API-specific header for AV_HWDEVICE_TYPE_CUDA. |
||||
* |
||||
* This API supports dynamic frame pools. AVHWFramesContext.pool must return |
||||
* AVBufferRefs whose data pointer is a CUdeviceptr. |
||||
*/ |
||||
|
||||
typedef struct AVCUDADeviceContextInternal AVCUDADeviceContextInternal; |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVCUDADeviceContext { |
||||
CUcontext cuda_ctx; |
||||
CUstream stream; |
||||
AVCUDADeviceContextInternal *internal; |
||||
} AVCUDADeviceContext; |
||||
|
||||
/**
|
||||
* AVHWFramesContext.hwctx is currently not used |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup hwcontext_cuda Device context creation flags |
||||
* |
||||
* Flags for av_hwdevice_ctx_create. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Use primary device context instead of creating a new one. |
||||
*/ |
||||
#define AV_CUDA_USE_PRIMARY_CONTEXT (1 << 0) |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_CUDA_H */ |
@ -0,0 +1,169 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_D3D11VA_H |
||||
#define AVUTIL_HWCONTEXT_D3D11VA_H |
||||
|
||||
/**
|
||||
* @file |
||||
* An API-specific header for AV_HWDEVICE_TYPE_D3D11VA. |
||||
* |
||||
* The default pool implementation will be fixed-size if initial_pool_size is |
||||
* set (and allocate elements from an array texture). Otherwise it will allocate |
||||
* individual textures. Be aware that decoding requires a single array texture. |
||||
* |
||||
* Using sw_format==AV_PIX_FMT_YUV420P has special semantics, and maps to |
||||
* DXGI_FORMAT_420_OPAQUE. av_hwframe_transfer_data() is not supported for |
||||
* this format. Refer to MSDN for details. |
||||
* |
||||
* av_hwdevice_ctx_create() for this device type supports a key named "debug" |
||||
* for the AVDictionary entry. If this is set to any value, the device creation |
||||
* code will try to load various supported D3D debugging layers. |
||||
*/ |
||||
|
||||
#include <d3d11.h> |
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVD3D11VADeviceContext { |
||||
/**
|
||||
* Device used for texture creation and access. This can also be used to |
||||
* set the libavcodec decoding device. |
||||
* |
||||
* Must be set by the user. This is the only mandatory field - the other |
||||
* device context fields are set from this and are available for convenience. |
||||
* |
||||
* Deallocating the AVHWDeviceContext will always release this interface, |
||||
* and it does not matter whether it was user-allocated. |
||||
*/ |
||||
ID3D11Device *device; |
||||
|
||||
/**
|
||||
* If unset, this will be set from the device field on init. |
||||
* |
||||
* Deallocating the AVHWDeviceContext will always release this interface, |
||||
* and it does not matter whether it was user-allocated. |
||||
*/ |
||||
ID3D11DeviceContext *device_context; |
||||
|
||||
/**
|
||||
* If unset, this will be set from the device field on init. |
||||
* |
||||
* Deallocating the AVHWDeviceContext will always release this interface, |
||||
* and it does not matter whether it was user-allocated. |
||||
*/ |
||||
ID3D11VideoDevice *video_device; |
||||
|
||||
/**
|
||||
* If unset, this will be set from the device_context field on init. |
||||
* |
||||
* Deallocating the AVHWDeviceContext will always release this interface, |
||||
* and it does not matter whether it was user-allocated. |
||||
*/ |
||||
ID3D11VideoContext *video_context; |
||||
|
||||
/**
|
||||
* Callbacks for locking. They protect accesses to device_context and |
||||
* video_context calls. They also protect access to the internal staging |
||||
* texture (for av_hwframe_transfer_data() calls). They do NOT protect |
||||
* access to hwcontext or decoder state in general. |
||||
* |
||||
* If unset on init, the hwcontext implementation will set them to use an |
||||
* internal mutex. |
||||
* |
||||
* The underlying lock must be recursive. lock_ctx is for free use by the |
||||
* locking implementation. |
||||
*/ |
||||
void (*lock)(void *lock_ctx); |
||||
void (*unlock)(void *lock_ctx); |
||||
void *lock_ctx; |
||||
} AVD3D11VADeviceContext; |
||||
|
||||
/**
|
||||
* D3D11 frame descriptor for pool allocation. |
||||
* |
||||
* In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs |
||||
* with the data pointer pointing at an object of this type describing the |
||||
* planes of the frame. |
||||
* |
||||
* This has no use outside of custom allocation, and AVFrame AVBufferRef do not |
||||
* necessarily point to an instance of this struct. |
||||
*/ |
||||
typedef struct AVD3D11FrameDescriptor { |
||||
/**
|
||||
* The texture in which the frame is located. The reference count is |
||||
* managed by the AVBufferRef, and destroying the reference will release |
||||
* the interface. |
||||
* |
||||
* Normally stored in AVFrame.data[0]. |
||||
*/ |
||||
ID3D11Texture2D *texture; |
||||
|
||||
/**
|
||||
* The index into the array texture element representing the frame, or 0 |
||||
* if the texture is not an array texture. |
||||
* |
||||
* Normally stored in AVFrame.data[1] (cast from intptr_t). |
||||
*/ |
||||
intptr_t index; |
||||
} AVD3D11FrameDescriptor; |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWFramesContext.hwctx |
||||
*/ |
||||
typedef struct AVD3D11VAFramesContext { |
||||
/**
|
||||
* The canonical texture used for pool allocation. If this is set to NULL |
||||
* on init, the hwframes implementation will allocate and set an array |
||||
* texture if initial_pool_size > 0. |
||||
* |
||||
* The only situation when the API user should set this is: |
||||
* - the user wants to do manual pool allocation (setting |
||||
* AVHWFramesContext.pool), instead of letting AVHWFramesContext |
||||
* allocate the pool |
||||
* - of an array texture |
||||
* - and wants it to use it for decoding |
||||
* - this has to be done before calling av_hwframe_ctx_init() |
||||
* |
||||
* Deallocating the AVHWFramesContext will always release this interface, |
||||
* and it does not matter whether it was user-allocated. |
||||
* |
||||
* This is in particular used by the libavcodec D3D11VA hwaccel, which |
||||
* requires a single array texture. It will create ID3D11VideoDecoderOutputView |
||||
* objects for each array texture element on decoder initialization. |
||||
*/ |
||||
ID3D11Texture2D *texture; |
||||
|
||||
/**
|
||||
* D3D11_TEXTURE2D_DESC.BindFlags used for texture creation. The user must |
||||
* at least set D3D11_BIND_DECODER if the frames context is to be used for |
||||
* video decoding. |
||||
* This field is ignored/invalid if a user-allocated texture is provided. |
||||
*/ |
||||
UINT BindFlags; |
||||
|
||||
/**
|
||||
* D3D11_TEXTURE2D_DESC.MiscFlags used for texture creation. |
||||
* This field is ignored/invalid if a user-allocated texture is provided. |
||||
*/ |
||||
UINT MiscFlags; |
||||
} AVD3D11VAFramesContext; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_D3D11VA_H */ |
@ -0,0 +1,169 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_DRM_H |
||||
#define AVUTIL_HWCONTEXT_DRM_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* @file |
||||
* API-specific header for AV_HWDEVICE_TYPE_DRM. |
||||
* |
||||
* Internal frame allocation is not currently supported - all frames |
||||
* must be allocated by the user. Thus AVHWFramesContext is always |
||||
* NULL, though this may change if support for frame allocation is |
||||
* added in future. |
||||
*/ |
||||
|
||||
enum { |
||||
/**
|
||||
* The maximum number of layers/planes in a DRM frame. |
||||
*/ |
||||
AV_DRM_MAX_PLANES = 4 |
||||
}; |
||||
|
||||
/**
|
||||
* DRM object descriptor. |
||||
* |
||||
* Describes a single DRM object, addressing it as a PRIME file |
||||
* descriptor. |
||||
*/ |
||||
typedef struct AVDRMObjectDescriptor { |
||||
/**
|
||||
* DRM PRIME fd for the object. |
||||
*/ |
||||
int fd; |
||||
/**
|
||||
* Total size of the object. |
||||
* |
||||
* (This includes any parts not which do not contain image data.) |
||||
*/ |
||||
size_t size; |
||||
/**
|
||||
* Format modifier applied to the object (DRM_FORMAT_MOD_*). |
||||
* |
||||
* If the format modifier is unknown then this should be set to |
||||
* DRM_FORMAT_MOD_INVALID. |
||||
*/ |
||||
uint64_t format_modifier; |
||||
} AVDRMObjectDescriptor; |
||||
|
||||
/**
|
||||
* DRM plane descriptor. |
||||
* |
||||
* Describes a single plane of a layer, which is contained within |
||||
* a single object. |
||||
*/ |
||||
typedef struct AVDRMPlaneDescriptor { |
||||
/**
|
||||
* Index of the object containing this plane in the objects |
||||
* array of the enclosing frame descriptor. |
||||
*/ |
||||
int object_index; |
||||
/**
|
||||
* Offset within that object of this plane. |
||||
*/ |
||||
ptrdiff_t offset; |
||||
/**
|
||||
* Pitch (linesize) of this plane. |
||||
*/ |
||||
ptrdiff_t pitch; |
||||
} AVDRMPlaneDescriptor; |
||||
|
||||
/**
|
||||
* DRM layer descriptor. |
||||
* |
||||
* Describes a single layer within a frame. This has the structure |
||||
* defined by its format, and will contain one or more planes. |
||||
*/ |
||||
typedef struct AVDRMLayerDescriptor { |
||||
/**
|
||||
* Format of the layer (DRM_FORMAT_*). |
||||
*/ |
||||
uint32_t format; |
||||
/**
|
||||
* Number of planes in the layer. |
||||
* |
||||
* This must match the number of planes required by format. |
||||
*/ |
||||
int nb_planes; |
||||
/**
|
||||
* Array of planes in this layer. |
||||
*/ |
||||
AVDRMPlaneDescriptor planes[AV_DRM_MAX_PLANES]; |
||||
} AVDRMLayerDescriptor; |
||||
|
||||
/**
|
||||
* DRM frame descriptor. |
||||
* |
||||
* This is used as the data pointer for AV_PIX_FMT_DRM_PRIME frames. |
||||
* It is also used by user-allocated frame pools - allocating in |
||||
* AVHWFramesContext.pool must return AVBufferRefs which contain |
||||
* an object of this type. |
||||
* |
||||
* The fields of this structure should be set such it can be |
||||
* imported directly by EGL using the EGL_EXT_image_dma_buf_import |
||||
* and EGL_EXT_image_dma_buf_import_modifiers extensions. |
||||
* (Note that the exact layout of a particular format may vary between |
||||
* platforms - we only specify that the same platform should be able |
||||
* to import it.) |
||||
* |
||||
* The total number of planes must not exceed AV_DRM_MAX_PLANES, and |
||||
* the order of the planes by increasing layer index followed by |
||||
* increasing plane index must be the same as the order which would |
||||
* be used for the data pointers in the equivalent software format. |
||||
*/ |
||||
typedef struct AVDRMFrameDescriptor { |
||||
/**
|
||||
* Number of DRM objects making up this frame. |
||||
*/ |
||||
int nb_objects; |
||||
/**
|
||||
* Array of objects making up the frame. |
||||
*/ |
||||
AVDRMObjectDescriptor objects[AV_DRM_MAX_PLANES]; |
||||
/**
|
||||
* Number of layers in the frame. |
||||
*/ |
||||
int nb_layers; |
||||
/**
|
||||
* Array of layers in the frame. |
||||
*/ |
||||
AVDRMLayerDescriptor layers[AV_DRM_MAX_PLANES]; |
||||
} AVDRMFrameDescriptor; |
||||
|
||||
/**
|
||||
* DRM device. |
||||
* |
||||
* Allocated as AVHWDeviceContext.hwctx. |
||||
*/ |
||||
typedef struct AVDRMDeviceContext { |
||||
/**
|
||||
* File descriptor of DRM device. |
||||
* |
||||
* This is used as the device to create frames on, and may also be |
||||
* used in some derivation and mapping operations. |
||||
* |
||||
* If no device is required, set to -1. |
||||
*/ |
||||
int fd; |
||||
} AVDRMDeviceContext; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_DRM_H */ |
@ -0,0 +1,75 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_DXVA2_H |
||||
#define AVUTIL_HWCONTEXT_DXVA2_H |
||||
|
||||
/**
|
||||
* @file |
||||
* An API-specific header for AV_HWDEVICE_TYPE_DXVA2. |
||||
* |
||||
* Only fixed-size pools are supported. |
||||
* |
||||
* For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs |
||||
* with the data pointer set to a pointer to IDirect3DSurface9. |
||||
*/ |
||||
|
||||
#include <d3d9.h> |
||||
#include <dxva2api.h> |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVDXVA2DeviceContext { |
||||
IDirect3DDeviceManager9 *devmgr; |
||||
} AVDXVA2DeviceContext; |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWFramesContext.hwctx |
||||
*/ |
||||
typedef struct AVDXVA2FramesContext { |
||||
/**
|
||||
* The surface type (e.g. DXVA2_VideoProcessorRenderTarget or |
||||
* DXVA2_VideoDecoderRenderTarget). Must be set by the caller. |
||||
*/ |
||||
DWORD surface_type; |
||||
|
||||
/**
|
||||
* The surface pool. When an external pool is not provided by the caller, |
||||
* this will be managed (allocated and filled on init, freed on uninit) by |
||||
* libavutil. |
||||
*/ |
||||
IDirect3DSurface9 **surfaces; |
||||
int nb_surfaces; |
||||
|
||||
/**
|
||||
* Certain drivers require the decoder to be destroyed before the surfaces. |
||||
* To allow internally managed pools to work properly in such cases, this |
||||
* field is provided. |
||||
* |
||||
* If it is non-NULL, libavutil will call IDirectXVideoDecoder_Release() on |
||||
* it just before the internal surface pool is freed. |
||||
* |
||||
* This is for convenience only. Some code uses other methods to manage the |
||||
* decoder reference. |
||||
*/ |
||||
IDirectXVideoDecoder *decoder_to_release; |
||||
} AVDXVA2FramesContext; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_DXVA2_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 AVUTIL_HWCONTEXT_MEDIACODEC_H |
||||
#define AVUTIL_HWCONTEXT_MEDIACODEC_H |
||||
|
||||
/**
|
||||
* MediaCodec details. |
||||
* |
||||
* Allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVMediaCodecDeviceContext { |
||||
/**
|
||||
* android/view/Surface handle, to be filled by the user. |
||||
* |
||||
* This is the default surface used by decoders on this device. |
||||
*/ |
||||
void *surface; |
||||
} AVMediaCodecDeviceContext; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_MEDIACODEC_H */ |
@ -0,0 +1,100 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_OPENCL_H |
||||
#define AVUTIL_HWCONTEXT_OPENCL_H |
||||
|
||||
#ifdef __APPLE__ |
||||
#include <OpenCL/cl.h> |
||||
#else |
||||
#include <CL/cl.h> |
||||
#endif |
||||
|
||||
#include "frame.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* API-specific header for AV_HWDEVICE_TYPE_OPENCL. |
||||
* |
||||
* Pools allocated internally are always dynamic, and are primarily intended |
||||
* to be used in OpenCL-only cases. If interoperation is required, it is |
||||
* typically required to allocate frames in the other API and then map the |
||||
* frames context to OpenCL with av_hwframe_ctx_create_derived(). |
||||
*/ |
||||
|
||||
/**
|
||||
* OpenCL frame descriptor for pool allocation. |
||||
* |
||||
* In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs |
||||
* with the data pointer pointing at an object of this type describing the |
||||
* planes of the frame. |
||||
*/ |
||||
typedef struct AVOpenCLFrameDescriptor { |
||||
/**
|
||||
* Number of planes in the frame. |
||||
*/ |
||||
int nb_planes; |
||||
/**
|
||||
* OpenCL image2d objects for each plane of the frame. |
||||
*/ |
||||
cl_mem planes[AV_NUM_DATA_POINTERS]; |
||||
} AVOpenCLFrameDescriptor; |
||||
|
||||
/**
|
||||
* OpenCL device details. |
||||
* |
||||
* Allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVOpenCLDeviceContext { |
||||
/**
|
||||
* The primary device ID of the device. If multiple OpenCL devices |
||||
* are associated with the context then this is the one which will |
||||
* be used for all operations internal to FFmpeg. |
||||
*/ |
||||
cl_device_id device_id; |
||||
/**
|
||||
* The OpenCL context which will contain all operations and frames on |
||||
* this device. |
||||
*/ |
||||
cl_context context; |
||||
/**
|
||||
* The default command queue for this device, which will be used by all |
||||
* frames contexts which do not have their own command queue. If not |
||||
* intialised by the user, a default queue will be created on the |
||||
* primary device. |
||||
*/ |
||||
cl_command_queue command_queue; |
||||
} AVOpenCLDeviceContext; |
||||
|
||||
/**
|
||||
* OpenCL-specific data associated with a frame pool. |
||||
* |
||||
* Allocated as AVHWFramesContext.hwctx. |
||||
*/ |
||||
typedef struct AVOpenCLFramesContext { |
||||
/**
|
||||
* The command queue used for internal asynchronous operations on this |
||||
* device (av_hwframe_transfer_data(), av_hwframe_map()). |
||||
* |
||||
* If this is not set, the command queue from the associated device is |
||||
* used instead. |
||||
*/ |
||||
cl_command_queue command_queue; |
||||
} AVOpenCLFramesContext; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_OPENCL_H */ |
@ -0,0 +1,53 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_QSV_H |
||||
#define AVUTIL_HWCONTEXT_QSV_H |
||||
|
||||
#include <mfx/mfxvideo.h> |
||||
|
||||
/**
|
||||
* @file |
||||
* An API-specific header for AV_HWDEVICE_TYPE_QSV. |
||||
* |
||||
* This API does not support dynamic frame pools. AVHWFramesContext.pool must |
||||
* contain AVBufferRefs whose data pointer points to an mfxFrameSurface1 struct. |
||||
*/ |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVQSVDeviceContext { |
||||
mfxSession session; |
||||
} AVQSVDeviceContext; |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWFramesContext.hwctx |
||||
*/ |
||||
typedef struct AVQSVFramesContext { |
||||
mfxFrameSurface1 *surfaces; |
||||
int nb_surfaces; |
||||
|
||||
/**
|
||||
* A combination of MFX_MEMTYPE_* describing the frame pool. |
||||
*/ |
||||
int frame_type; |
||||
} AVQSVFramesContext; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_QSV_H */ |
||||
|
@ -0,0 +1,117 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_VAAPI_H |
||||
#define AVUTIL_HWCONTEXT_VAAPI_H |
||||
|
||||
#include <va/va.h> |
||||
|
||||
/**
|
||||
* @file |
||||
* API-specific header for AV_HWDEVICE_TYPE_VAAPI. |
||||
* |
||||
* Dynamic frame pools are supported, but note that any pool used as a render |
||||
* target is required to be of fixed size in order to be be usable as an |
||||
* argument to vaCreateContext(). |
||||
* |
||||
* For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs |
||||
* with the data pointer set to a VASurfaceID. |
||||
*/ |
||||
|
||||
enum { |
||||
/**
|
||||
* The quirks field has been set by the user and should not be detected |
||||
* automatically by av_hwdevice_ctx_init(). |
||||
*/ |
||||
AV_VAAPI_DRIVER_QUIRK_USER_SET = (1 << 0), |
||||
/**
|
||||
* The driver does not destroy parameter buffers when they are used by |
||||
* vaRenderPicture(). Additional code will be required to destroy them |
||||
* separately afterwards. |
||||
*/ |
||||
AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS = (1 << 1), |
||||
|
||||
/**
|
||||
* The driver does not support the VASurfaceAttribMemoryType attribute, |
||||
* so the surface allocation code will not try to use it. |
||||
*/ |
||||
AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE = (1 << 2), |
||||
|
||||
/**
|
||||
* The driver does not support surface attributes at all. |
||||
* The surface allocation code will never pass them to surface allocation, |
||||
* and the results of the vaQuerySurfaceAttributes() call will be faked. |
||||
*/ |
||||
AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES = (1 << 3), |
||||
}; |
||||
|
||||
/**
|
||||
* VAAPI connection details. |
||||
* |
||||
* Allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVVAAPIDeviceContext { |
||||
/**
|
||||
* The VADisplay handle, to be filled by the user. |
||||
*/ |
||||
VADisplay display; |
||||
/**
|
||||
* Driver quirks to apply - this is filled by av_hwdevice_ctx_init(), |
||||
* with reference to a table of known drivers, unless the |
||||
* AV_VAAPI_DRIVER_QUIRK_USER_SET bit is already present. The user |
||||
* may need to refer to this field when performing any later |
||||
* operations using VAAPI with the same VADisplay. |
||||
*/ |
||||
unsigned int driver_quirks; |
||||
} AVVAAPIDeviceContext; |
||||
|
||||
/**
|
||||
* VAAPI-specific data associated with a frame pool. |
||||
* |
||||
* Allocated as AVHWFramesContext.hwctx. |
||||
*/ |
||||
typedef struct AVVAAPIFramesContext { |
||||
/**
|
||||
* Set by the user to apply surface attributes to all surfaces in |
||||
* the frame pool. If null, default settings are used. |
||||
*/ |
||||
VASurfaceAttrib *attributes; |
||||
int nb_attributes; |
||||
/**
|
||||
* The surfaces IDs of all surfaces in the pool after creation. |
||||
* Only valid if AVHWFramesContext.initial_pool_size was positive. |
||||
* These are intended to be used as the render_targets arguments to |
||||
* vaCreateContext(). |
||||
*/ |
||||
VASurfaceID *surface_ids; |
||||
int nb_surfaces; |
||||
} AVVAAPIFramesContext; |
||||
|
||||
/**
|
||||
* VAAPI hardware pipeline configuration details. |
||||
* |
||||
* Allocated with av_hwdevice_hwconfig_alloc(). |
||||
*/ |
||||
typedef struct AVVAAPIHWConfig { |
||||
/**
|
||||
* ID of a VAAPI pipeline configuration. |
||||
*/ |
||||
VAConfigID config_id; |
||||
} AVVAAPIHWConfig; |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_VAAPI_H */ |
@ -0,0 +1,44 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_VDPAU_H |
||||
#define AVUTIL_HWCONTEXT_VDPAU_H |
||||
|
||||
#include <vdpau/vdpau.h> |
||||
|
||||
/**
|
||||
* @file |
||||
* An API-specific header for AV_HWDEVICE_TYPE_VDPAU. |
||||
* |
||||
* This API supports dynamic frame pools. AVHWFramesContext.pool must return |
||||
* AVBufferRefs whose data pointer is a VdpVideoSurface. |
||||
*/ |
||||
|
||||
/**
|
||||
* This struct is allocated as AVHWDeviceContext.hwctx |
||||
*/ |
||||
typedef struct AVVDPAUDeviceContext { |
||||
VdpDevice device; |
||||
VdpGetProcAddress *get_proc_address; |
||||
} AVVDPAUDeviceContext; |
||||
|
||||
/**
|
||||
* AVHWFramesContext.hwctx is currently not used |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_VDPAU_H */ |
@ -0,0 +1,60 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H |
||||
#define AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include <VideoToolbox/VideoToolbox.h> |
||||
|
||||
#include "pixfmt.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX. |
||||
* |
||||
* This API currently does not support frame allocation, as the raw VideoToolbox |
||||
* API does allocation, and FFmpeg itself never has the need to allocate frames. |
||||
* |
||||
* If the API user sets a custom pool, AVHWFramesContext.pool must return |
||||
* AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef. |
||||
* |
||||
* Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always |
||||
* NULL. |
||||
*/ |
||||
|
||||
/**
|
||||
* Convert a VideoToolbox (actually CoreVideo) format to AVPixelFormat. |
||||
* Returns AV_PIX_FMT_NONE if no known equivalent was found. |
||||
*/ |
||||
enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt); |
||||
|
||||
/**
|
||||
* Convert an AVPixelFormat to a VideoToolbox (actually CoreVideo) format. |
||||
* Returns 0 if no known equivalent was found. |
||||
*/ |
||||
uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt); |
||||
|
||||
/**
|
||||
* Same as av_map_videotoolbox_format_from_pixfmt function, but can map and |
||||
* return full range pixel formats via a flag. |
||||
*/ |
||||
uint32_t av_map_videotoolbox_format_from_pixfmt2(enum AVPixelFormat pix_fmt, bool full_range); |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */ |
@ -0,0 +1,204 @@ |
||||
/*
|
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_HWCONTEXT_VULKAN_H |
||||
#define AVUTIL_HWCONTEXT_VULKAN_H |
||||
|
||||
#include <vulkan/vulkan.h> |
||||
|
||||
#include "pixfmt.h" |
||||
#include "frame.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* API-specific header for AV_HWDEVICE_TYPE_VULKAN. |
||||
* |
||||
* For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs |
||||
* with the data pointer set to an AVVkFrame. |
||||
*/ |
||||
|
||||
/**
|
||||
* Main Vulkan context, allocated as AVHWDeviceContext.hwctx. |
||||
* All of these can be set before init to change what the context uses |
||||
*/ |
||||
typedef struct AVVulkanDeviceContext { |
||||
/**
|
||||
* Custom memory allocator, else NULL |
||||
*/ |
||||
const VkAllocationCallbacks *alloc; |
||||
/**
|
||||
* Vulkan instance. Must be at least version 1.1. |
||||
*/ |
||||
VkInstance inst; |
||||
/**
|
||||
* Physical device |
||||
*/ |
||||
VkPhysicalDevice phys_dev; |
||||
/**
|
||||
* Active device |
||||
*/ |
||||
VkDevice act_dev; |
||||
/**
|
||||
* Queue family index for graphics |
||||
* @note av_hwdevice_create() will set all 3 queue indices if unset |
||||
* If there is no dedicated queue for compute or transfer operations, |
||||
* they will be set to the graphics queue index which can handle both. |
||||
* nb_graphics_queues indicates how many queues were enabled for the |
||||
* graphics queue (must be at least 1) |
||||
*/ |
||||
int queue_family_index; |
||||
int nb_graphics_queues; |
||||
/**
|
||||
* Queue family index to use for transfer operations, and the amount of queues |
||||
* enabled. In case there is no dedicated transfer queue, nb_tx_queues |
||||
* must be 0 and queue_family_tx_index must be the same as either the graphics |
||||
* queue or the compute queue, if available. |
||||
*/ |
||||
int queue_family_tx_index; |
||||
int nb_tx_queues; |
||||
/**
|
||||
* Queue family index for compute ops, and the amount of queues enabled. |
||||
* In case there are no dedicated compute queues, nb_comp_queues must be |
||||
* 0 and its queue family index must be set to the graphics queue. |
||||
*/ |
||||
int queue_family_comp_index; |
||||
int nb_comp_queues; |
||||
/**
|
||||
* Enabled instance extensions. |
||||
* If supplying your own device context, set this to an array of strings, with |
||||
* each entry containing the specified Vulkan extension string to enable. |
||||
* Duplicates are possible and accepted. |
||||
* If no extensions are enabled, set these fields to NULL, and 0 respectively. |
||||
*/ |
||||
const char * const *enabled_inst_extensions; |
||||
int nb_enabled_inst_extensions; |
||||
/**
|
||||
* Enabled device extensions. By default, VK_KHR_external_memory_fd, |
||||
* VK_EXT_external_memory_dma_buf, VK_EXT_image_drm_format_modifier, |
||||
* VK_KHR_external_semaphore_fd and VK_EXT_external_memory_host are enabled if found. |
||||
* If supplying your own device context, these fields takes the same format as |
||||
* the above fields, with the same conditions that duplicates are possible |
||||
* and accepted, and that NULL and 0 respectively means no extensions are enabled. |
||||
*/ |
||||
const char * const *enabled_dev_extensions; |
||||
int nb_enabled_dev_extensions; |
||||
/**
|
||||
* This structure should be set to the set of features that present and enabled |
||||
* during device creation. When a device is created by FFmpeg, it will default to |
||||
* enabling all that are present of the shaderImageGatherExtended, |
||||
* fragmentStoresAndAtomics, shaderInt64 and vertexPipelineStoresAndAtomics features. |
||||
*/ |
||||
VkPhysicalDeviceFeatures2 device_features; |
||||
} AVVulkanDeviceContext; |
||||
|
||||
/**
|
||||
* Allocated as AVHWFramesContext.hwctx, used to set pool-specific options |
||||
*/ |
||||
typedef struct AVVulkanFramesContext { |
||||
/**
|
||||
* Controls the tiling of allocated frames. |
||||
*/ |
||||
VkImageTiling tiling; |
||||
/**
|
||||
* Defines extra usage of output frames. If left as 0, the following bits |
||||
* are set: TRANSFER_SRC, TRANSFER_DST. SAMPLED and STORAGE. |
||||
*/ |
||||
VkImageUsageFlagBits usage; |
||||
/**
|
||||
* Extension data for image creation. |
||||
*/ |
||||
void *create_pnext; |
||||
/**
|
||||
* Extension data for memory allocation. Must have as many entries as |
||||
* the number of planes of the sw_format. |
||||
* This will be chained to VkExportMemoryAllocateInfo, which is used |
||||
* to make all pool images exportable to other APIs if the necessary |
||||
* extensions are present in enabled_dev_extensions. |
||||
*/ |
||||
void *alloc_pnext[AV_NUM_DATA_POINTERS]; |
||||
} AVVulkanFramesContext; |
||||
|
||||
/*
|
||||
* Frame structure, the VkFormat of the image will always match |
||||
* the pool's sw_format. |
||||
* All frames, imported or allocated, will be created with the |
||||
* VK_IMAGE_CREATE_ALIAS_BIT flag set, so the memory may be aliased if needed. |
||||
* |
||||
* If all three queue family indices in the device context are the same, |
||||
* images will be created with the EXCLUSIVE sharing mode. Otherwise, all images |
||||
* will be created using the CONCURRENT sharing mode. |
||||
* |
||||
* @note the size of this structure is not part of the ABI, to allocate |
||||
* you must use @av_vk_frame_alloc(). |
||||
*/ |
||||
typedef struct AVVkFrame { |
||||
/**
|
||||
* Vulkan images to which the memory is bound to. |
||||
*/ |
||||
VkImage img[AV_NUM_DATA_POINTERS]; |
||||
|
||||
/**
|
||||
* The same tiling must be used for all images in the frame. |
||||
*/ |
||||
VkImageTiling tiling; |
||||
|
||||
/**
|
||||
* Memory backing the images. Could be less than the amount of images |
||||
* if importing from a DRM or VAAPI frame. |
||||
*/ |
||||
VkDeviceMemory mem[AV_NUM_DATA_POINTERS]; |
||||
size_t size[AV_NUM_DATA_POINTERS]; |
||||
|
||||
/**
|
||||
* OR'd flags for all memory allocated |
||||
*/ |
||||
VkMemoryPropertyFlagBits flags; |
||||
|
||||
/**
|
||||
* Updated after every barrier |
||||
*/ |
||||
VkAccessFlagBits access[AV_NUM_DATA_POINTERS]; |
||||
VkImageLayout layout[AV_NUM_DATA_POINTERS]; |
||||
|
||||
/**
|
||||
* Synchronization semaphores. Must not be freed manually. Must be waited on |
||||
* and signalled at every queue submission. |
||||
* Could be less than the amount of images: either one per VkDeviceMemory |
||||
* or one for the entire frame. All others will be set to VK_NULL_HANDLE. |
||||
*/ |
||||
VkSemaphore sem[AV_NUM_DATA_POINTERS]; |
||||
|
||||
/**
|
||||
* Internal data. |
||||
*/ |
||||
struct AVVkFrameInternal *internal; |
||||
} AVVkFrame; |
||||
|
||||
/**
|
||||
* Allocates a single AVVkFrame and initializes everything as 0. |
||||
* @note Must be freed via av_free() |
||||
*/ |
||||
AVVkFrame *av_vk_frame_alloc(void); |
||||
|
||||
/**
|
||||
* Returns the format of each image up to the number of planes for a given sw_format. |
||||
* Returns NULL on unsupported formats. |
||||
*/ |
||||
const VkFormat *av_vkfmt_from_pixfmt(enum AVPixelFormat p); |
||||
|
||||
#endif /* AVUTIL_HWCONTEXT_VULKAN_H */ |
@ -0,0 +1,291 @@ |
||||
/*
|
||||
* 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_IMGUTILS_H |
||||
#define AVUTIL_IMGUTILS_H |
||||
|
||||
/**
|
||||
* @file |
||||
* misc image utilities |
||||
* |
||||
* @addtogroup lavu_picture |
||||
* @{ |
||||
*/ |
||||
|
||||
#include "avutil.h" |
||||
#include "pixdesc.h" |
||||
#include "rational.h" |
||||
|
||||
/**
|
||||
* Compute the max pixel step for each plane of an image with a |
||||
* format described by pixdesc. |
||||
* |
||||
* The pixel step is the distance in bytes between the first byte of |
||||
* the group of bytes which describe a pixel component and the first |
||||
* byte of the successive group in the same plane for the same |
||||
* component. |
||||
* |
||||
* @param max_pixsteps an array which is filled with the max pixel step |
||||
* for each plane. Since a plane may contain different pixel |
||||
* components, the computed max_pixsteps[plane] is relative to the |
||||
* component in the plane with the max pixel step. |
||||
* @param max_pixstep_comps an array which is filled with the component |
||||
* for each plane which has the max pixel step. May be NULL. |
||||
*/ |
||||
void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], |
||||
const AVPixFmtDescriptor *pixdesc); |
||||
|
||||
/**
|
||||
* Compute the size of an image line with format pix_fmt and width |
||||
* width for the plane plane. |
||||
* |
||||
* @return the computed size in bytes |
||||
*/ |
||||
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane); |
||||
|
||||
/**
|
||||
* Fill plane linesizes for an image with pixel format pix_fmt and |
||||
* width width. |
||||
* |
||||
* @param linesizes array to be filled with the linesize for each plane |
||||
* @return >= 0 in case of success, a negative error code otherwise |
||||
*/ |
||||
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width); |
||||
|
||||
/**
|
||||
* Fill plane sizes for an image with pixel format pix_fmt and height height. |
||||
* |
||||
* @param size the array to be filled with the size of each image plane |
||||
* @param linesizes the array containing the linesize for each |
||||
* plane, should be filled by av_image_fill_linesizes() |
||||
* @return >= 0 in case of success, a negative error code otherwise |
||||
* |
||||
* @note The linesize parameters have the type ptrdiff_t here, while they are |
||||
* int for av_image_fill_linesizes(). |
||||
*/ |
||||
int av_image_fill_plane_sizes(size_t size[4], enum AVPixelFormat pix_fmt, |
||||
int height, const ptrdiff_t linesizes[4]); |
||||
|
||||
/**
|
||||
* Fill plane data pointers for an image with pixel format pix_fmt and |
||||
* height height. |
||||
* |
||||
* @param data pointers array to be filled with the pointer for each image plane |
||||
* @param ptr the pointer to a buffer which will contain the image |
||||
* @param linesizes the array containing the linesize for each |
||||
* plane, should be filled by av_image_fill_linesizes() |
||||
* @return the size in bytes required for the image buffer, a negative |
||||
* error code in case of failure |
||||
*/ |
||||
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, |
||||
uint8_t *ptr, const int linesizes[4]); |
||||
|
||||
/**
|
||||
* Allocate an image with size w and h and pixel format pix_fmt, and |
||||
* fill pointers and linesizes accordingly. |
||||
* The allocated image buffer has to be freed by using |
||||
* av_freep(&pointers[0]). |
||||
* |
||||
* @param align the value to use for buffer size alignment |
||||
* @return the size in bytes required for the image buffer, a negative |
||||
* error code in case of failure |
||||
*/ |
||||
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], |
||||
int w, int h, enum AVPixelFormat pix_fmt, int align); |
||||
|
||||
/**
|
||||
* Copy image plane from src to dst. |
||||
* That is, copy "height" number of lines of "bytewidth" bytes each. |
||||
* The first byte of each successive line is separated by *_linesize |
||||
* bytes. |
||||
* |
||||
* bytewidth must be contained by both absolute values of dst_linesize |
||||
* and src_linesize, otherwise the function behavior is undefined. |
||||
* |
||||
* @param dst_linesize linesize for the image plane in dst |
||||
* @param src_linesize linesize for the image plane in src |
||||
*/ |
||||
void av_image_copy_plane(uint8_t *dst, int dst_linesize, |
||||
const uint8_t *src, int src_linesize, |
||||
int bytewidth, int height); |
||||
|
||||
/**
|
||||
* Copy image in src_data to dst_data. |
||||
* |
||||
* @param dst_linesizes linesizes for the image in dst_data |
||||
* @param src_linesizes linesizes for the image in src_data |
||||
*/ |
||||
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], |
||||
const uint8_t *src_data[4], const int src_linesizes[4], |
||||
enum AVPixelFormat pix_fmt, int width, int height); |
||||
|
||||
/**
|
||||
* Copy image data located in uncacheable (e.g. GPU mapped) memory. Where |
||||
* available, this function will use special functionality for reading from such |
||||
* memory, which may result in greatly improved performance compared to plain |
||||
* av_image_copy(). |
||||
* |
||||
* The data pointers and the linesizes must be aligned to the maximum required |
||||
* by the CPU architecture. |
||||
* |
||||
* @note The linesize parameters have the type ptrdiff_t here, while they are |
||||
* int for av_image_copy(). |
||||
* @note On x86, the linesizes currently need to be aligned to the cacheline |
||||
* size (i.e. 64) to get improved performance. |
||||
*/ |
||||
void av_image_copy_uc_from(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4], |
||||
const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4], |
||||
enum AVPixelFormat pix_fmt, int width, int height); |
||||
|
||||
/**
|
||||
* Setup the data pointers and linesizes based on the specified image |
||||
* parameters and the provided array. |
||||
* |
||||
* The fields of the given image are filled in by using the src |
||||
* address which points to the image data buffer. Depending on the |
||||
* specified pixel format, one or multiple image data pointers and |
||||
* line sizes will be set. If a planar format is specified, several |
||||
* pointers will be set pointing to the different picture planes and |
||||
* the line sizes of the different planes will be stored in the |
||||
* lines_sizes array. Call with src == NULL to get the required |
||||
* size for the src buffer. |
||||
* |
||||
* To allocate the buffer and fill in the dst_data and dst_linesize in |
||||
* one call, use av_image_alloc(). |
||||
* |
||||
* @param dst_data data pointers to be filled in |
||||
* @param dst_linesize linesizes for the image in dst_data to be filled in |
||||
* @param src buffer which will contain or contains the actual image data, can be NULL |
||||
* @param pix_fmt the pixel format of the image |
||||
* @param width the width of the image in pixels |
||||
* @param height the height of the image in pixels |
||||
* @param align the value used in src for linesize alignment |
||||
* @return the size in bytes required for src, a negative error code |
||||
* in case of failure |
||||
*/ |
||||
int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], |
||||
const uint8_t *src, |
||||
enum AVPixelFormat pix_fmt, int width, int height, int align); |
||||
|
||||
/**
|
||||
* Return the size in bytes of the amount of data required to store an |
||||
* image with the given parameters. |
||||
* |
||||
* @param pix_fmt the pixel format of the image |
||||
* @param width the width of the image in pixels |
||||
* @param height the height of the image in pixels |
||||
* @param align the assumed linesize alignment |
||||
* @return the buffer size in bytes, a negative error code in case of failure |
||||
*/ |
||||
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align); |
||||
|
||||
/**
|
||||
* Copy image data from an image into a buffer. |
||||
* |
||||
* av_image_get_buffer_size() can be used to compute the required size |
||||
* for the buffer to fill. |
||||
* |
||||
* @param dst a buffer into which picture data will be copied |
||||
* @param dst_size the size in bytes of dst |
||||
* @param src_data pointers containing the source image data |
||||
* @param src_linesize linesizes for the image in src_data |
||||
* @param pix_fmt the pixel format of the source image |
||||
* @param width the width of the source image in pixels |
||||
* @param height the height of the source image in pixels |
||||
* @param align the assumed linesize alignment for dst |
||||
* @return the number of bytes written to dst, or a negative value |
||||
* (error code) on error |
||||
*/ |
||||
int av_image_copy_to_buffer(uint8_t *dst, int dst_size, |
||||
const uint8_t * const src_data[4], const int src_linesize[4], |
||||
enum AVPixelFormat pix_fmt, int width, int height, int align); |
||||
|
||||
/**
|
||||
* Check if the given dimension of an image is valid, meaning that all |
||||
* bytes of the image can be addressed with a signed int. |
||||
* |
||||
* @param w the width of the picture |
||||
* @param h the height of the picture |
||||
* @param log_offset the offset to sum to the log level for logging with log_ctx |
||||
* @param log_ctx the parent logging context, it may be NULL |
||||
* @return >= 0 if valid, a negative error code otherwise |
||||
*/ |
||||
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx); |
||||
|
||||
/**
|
||||
* Check if the given dimension of an image is valid, meaning that all |
||||
* bytes of a plane of an image with the specified pix_fmt can be addressed |
||||
* with a signed int. |
||||
* |
||||
* @param w the width of the picture |
||||
* @param h the height of the picture |
||||
* @param max_pixels the maximum number of pixels the user wants to accept |
||||
* @param pix_fmt the pixel format, can be AV_PIX_FMT_NONE if unknown. |
||||
* @param log_offset the offset to sum to the log level for logging with log_ctx |
||||
* @param log_ctx the parent logging context, it may be NULL |
||||
* @return >= 0 if valid, a negative error code otherwise |
||||
*/ |
||||
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx); |
||||
|
||||
/**
|
||||
* Check if the given sample aspect ratio of an image is valid. |
||||
* |
||||
* It is considered invalid if the denominator is 0 or if applying the ratio |
||||
* to the image size would make the smaller dimension less than 1. If the |
||||
* sar numerator is 0, it is considered unknown and will return as valid. |
||||
* |
||||
* @param w width of the image |
||||
* @param h height of the image |
||||
* @param sar sample aspect ratio of the image |
||||
* @return 0 if valid, a negative AVERROR code otherwise |
||||
*/ |
||||
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar); |
||||
|
||||
/**
|
||||
* Overwrite the image data with black. This is suitable for filling a |
||||
* sub-rectangle of an image, meaning the padding between the right most pixel |
||||
* and the left most pixel on the next line will not be overwritten. For some |
||||
* formats, the image size might be rounded up due to inherent alignment. |
||||
* |
||||
* If the pixel format has alpha, the alpha is cleared to opaque. |
||||
* |
||||
* This can return an error if the pixel format is not supported. Normally, all |
||||
* non-hwaccel pixel formats should be supported. |
||||
* |
||||
* Passing NULL for dst_data is allowed. Then the function returns whether the |
||||
* operation would have succeeded. (It can return an error if the pix_fmt is |
||||
* not supported.) |
||||
* |
||||
* @param dst_data data pointers to destination image |
||||
* @param dst_linesize linesizes for the destination image |
||||
* @param pix_fmt the pixel format of the image |
||||
* @param range the color range of the image (important for colorspaces such as YUV) |
||||
* @param width the width of the image in pixels |
||||
* @param height the height of the image in pixels |
||||
* @return 0 if the image data was cleared, a negative AVERROR code otherwise |
||||
*/ |
||||
int av_image_fill_black(uint8_t *dst_data[4], const ptrdiff_t dst_linesize[4], |
||||
enum AVPixelFormat pix_fmt, enum AVColorRange range, |
||||
int width, int height); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
|
||||
#endif /* AVUTIL_IMGUTILS_H */ |
@ -0,0 +1,77 @@ |
||||
/*
|
||||
* Copyright (c) 2011 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_INTFLOAT_H |
||||
#define AVUTIL_INTFLOAT_H |
||||
|
||||
#include <stdint.h> |
||||
#include "attributes.h" |
||||
|
||||
union av_intfloat32 { |
||||
uint32_t i; |
||||
float f; |
||||
}; |
||||
|
||||
union av_intfloat64 { |
||||
uint64_t i; |
||||
double f; |
||||
}; |
||||
|
||||
/**
|
||||
* Reinterpret a 32-bit integer as a float. |
||||
*/ |
||||
static av_always_inline float av_int2float(uint32_t i) |
||||
{ |
||||
union av_intfloat32 v; |
||||
v.i = i; |
||||
return v.f; |
||||
} |
||||
|
||||
/**
|
||||
* Reinterpret a float as a 32-bit integer. |
||||
*/ |
||||
static av_always_inline uint32_t av_float2int(float f) |
||||
{ |
||||
union av_intfloat32 v; |
||||
v.f = f; |
||||
return v.i; |
||||
} |
||||
|
||||
/**
|
||||
* Reinterpret a 64-bit integer as a double. |
||||
*/ |
||||
static av_always_inline double av_int2double(uint64_t i) |
||||
{ |
||||
union av_intfloat64 v; |
||||
v.i = i; |
||||
return v.f; |
||||
} |
||||
|
||||
/**
|
||||
* Reinterpret a double as a 64-bit integer. |
||||
*/ |
||||
static av_always_inline uint64_t av_double2int(double f) |
||||
{ |
||||
union av_intfloat64 v; |
||||
v.f = f; |
||||
return v.i; |
||||
} |
||||
|
||||
#endif /* AVUTIL_INTFLOAT_H */ |
@ -0,0 +1,644 @@ |
||||
/*
|
||||
* 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_INTREADWRITE_H |
||||
#define AVUTIL_INTREADWRITE_H |
||||
|
||||
#include <stdint.h> |
||||
#include "libavutil/avconfig.h" |
||||
#include "attributes.h" |
||||
#include "bswap.h" |
||||
|
||||
typedef union { |
||||
uint64_t u64; |
||||
uint32_t u32[2]; |
||||
uint16_t u16[4]; |
||||
uint8_t u8 [8]; |
||||
double f64; |
||||
float f32[2]; |
||||
} av_alias av_alias64; |
||||
|
||||
typedef union { |
||||
uint32_t u32; |
||||
uint16_t u16[2]; |
||||
uint8_t u8 [4]; |
||||
float f32; |
||||
} av_alias av_alias32; |
||||
|
||||
typedef union { |
||||
uint16_t u16; |
||||
uint8_t u8 [2]; |
||||
} av_alias av_alias16; |
||||
|
||||
/*
|
||||
* Arch-specific headers can provide any combination of |
||||
* AV_[RW][BLN](16|24|32|48|64) and AV_(COPY|SWAP|ZERO)(64|128) macros. |
||||
* Preprocessor symbols must be defined, even if these are implemented |
||||
* as inline functions. |
||||
* |
||||
* R/W means read/write, B/L/N means big/little/native endianness. |
||||
* The following macros require aligned access, compared to their |
||||
* unaligned variants: AV_(COPY|SWAP|ZERO)(64|128), AV_[RW]N[8-64]A. |
||||
* Incorrect usage may range from abysmal performance to crash |
||||
* depending on the platform. |
||||
* |
||||
* The unaligned variants are AV_[RW][BLN][8-64] and AV_COPY*U. |
||||
*/ |
||||
|
||||
#ifdef HAVE_AV_CONFIG_H |
||||
|
||||
#include "config.h" |
||||
|
||||
#if ARCH_ARM |
||||
# include "arm/intreadwrite.h" |
||||
#elif ARCH_AVR32 |
||||
# include "avr32/intreadwrite.h" |
||||
#elif ARCH_MIPS |
||||
# include "mips/intreadwrite.h" |
||||
#elif ARCH_PPC |
||||
# include "ppc/intreadwrite.h" |
||||
#elif ARCH_TOMI |
||||
# include "tomi/intreadwrite.h" |
||||
#elif ARCH_X86 |
||||
# include "x86/intreadwrite.h" |
||||
#endif |
||||
|
||||
#endif /* HAVE_AV_CONFIG_H */ |
||||
|
||||
/*
|
||||
* Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers. |
||||
*/ |
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
|
||||
# if defined(AV_RN16) && !defined(AV_RB16) |
||||
# define AV_RB16(p) AV_RN16(p) |
||||
# elif !defined(AV_RN16) && defined(AV_RB16) |
||||
# define AV_RN16(p) AV_RB16(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN16) && !defined(AV_WB16) |
||||
# define AV_WB16(p, v) AV_WN16(p, v) |
||||
# elif !defined(AV_WN16) && defined(AV_WB16) |
||||
# define AV_WN16(p, v) AV_WB16(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN24) && !defined(AV_RB24) |
||||
# define AV_RB24(p) AV_RN24(p) |
||||
# elif !defined(AV_RN24) && defined(AV_RB24) |
||||
# define AV_RN24(p) AV_RB24(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN24) && !defined(AV_WB24) |
||||
# define AV_WB24(p, v) AV_WN24(p, v) |
||||
# elif !defined(AV_WN24) && defined(AV_WB24) |
||||
# define AV_WN24(p, v) AV_WB24(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN32) && !defined(AV_RB32) |
||||
# define AV_RB32(p) AV_RN32(p) |
||||
# elif !defined(AV_RN32) && defined(AV_RB32) |
||||
# define AV_RN32(p) AV_RB32(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN32) && !defined(AV_WB32) |
||||
# define AV_WB32(p, v) AV_WN32(p, v) |
||||
# elif !defined(AV_WN32) && defined(AV_WB32) |
||||
# define AV_WN32(p, v) AV_WB32(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN48) && !defined(AV_RB48) |
||||
# define AV_RB48(p) AV_RN48(p) |
||||
# elif !defined(AV_RN48) && defined(AV_RB48) |
||||
# define AV_RN48(p) AV_RB48(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN48) && !defined(AV_WB48) |
||||
# define AV_WB48(p, v) AV_WN48(p, v) |
||||
# elif !defined(AV_WN48) && defined(AV_WB48) |
||||
# define AV_WN48(p, v) AV_WB48(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN64) && !defined(AV_RB64) |
||||
# define AV_RB64(p) AV_RN64(p) |
||||
# elif !defined(AV_RN64) && defined(AV_RB64) |
||||
# define AV_RN64(p) AV_RB64(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN64) && !defined(AV_WB64) |
||||
# define AV_WB64(p, v) AV_WN64(p, v) |
||||
# elif !defined(AV_WN64) && defined(AV_WB64) |
||||
# define AV_WN64(p, v) AV_WB64(p, v) |
||||
# endif |
||||
|
||||
#else /* AV_HAVE_BIGENDIAN */ |
||||
|
||||
# if defined(AV_RN16) && !defined(AV_RL16) |
||||
# define AV_RL16(p) AV_RN16(p) |
||||
# elif !defined(AV_RN16) && defined(AV_RL16) |
||||
# define AV_RN16(p) AV_RL16(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN16) && !defined(AV_WL16) |
||||
# define AV_WL16(p, v) AV_WN16(p, v) |
||||
# elif !defined(AV_WN16) && defined(AV_WL16) |
||||
# define AV_WN16(p, v) AV_WL16(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN24) && !defined(AV_RL24) |
||||
# define AV_RL24(p) AV_RN24(p) |
||||
# elif !defined(AV_RN24) && defined(AV_RL24) |
||||
# define AV_RN24(p) AV_RL24(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN24) && !defined(AV_WL24) |
||||
# define AV_WL24(p, v) AV_WN24(p, v) |
||||
# elif !defined(AV_WN24) && defined(AV_WL24) |
||||
# define AV_WN24(p, v) AV_WL24(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN32) && !defined(AV_RL32) |
||||
# define AV_RL32(p) AV_RN32(p) |
||||
# elif !defined(AV_RN32) && defined(AV_RL32) |
||||
# define AV_RN32(p) AV_RL32(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN32) && !defined(AV_WL32) |
||||
# define AV_WL32(p, v) AV_WN32(p, v) |
||||
# elif !defined(AV_WN32) && defined(AV_WL32) |
||||
# define AV_WN32(p, v) AV_WL32(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN48) && !defined(AV_RL48) |
||||
# define AV_RL48(p) AV_RN48(p) |
||||
# elif !defined(AV_RN48) && defined(AV_RL48) |
||||
# define AV_RN48(p) AV_RL48(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN48) && !defined(AV_WL48) |
||||
# define AV_WL48(p, v) AV_WN48(p, v) |
||||
# elif !defined(AV_WN48) && defined(AV_WL48) |
||||
# define AV_WN48(p, v) AV_WL48(p, v) |
||||
# endif |
||||
|
||||
# if defined(AV_RN64) && !defined(AV_RL64) |
||||
# define AV_RL64(p) AV_RN64(p) |
||||
# elif !defined(AV_RN64) && defined(AV_RL64) |
||||
# define AV_RN64(p) AV_RL64(p) |
||||
# endif |
||||
|
||||
# if defined(AV_WN64) && !defined(AV_WL64) |
||||
# define AV_WL64(p, v) AV_WN64(p, v) |
||||
# elif !defined(AV_WN64) && defined(AV_WL64) |
||||
# define AV_WN64(p, v) AV_WL64(p, v) |
||||
# endif |
||||
|
||||
#endif /* !AV_HAVE_BIGENDIAN */ |
||||
|
||||
/*
|
||||
* Define AV_[RW]N helper macros to simplify definitions not provided |
||||
* by per-arch headers. |
||||
*/ |
||||
|
||||
#if defined(__GNUC__) |
||||
|
||||
union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias; |
||||
union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias; |
||||
union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias; |
||||
|
||||
# define AV_RN(s, p) (((const union unaligned_##s *) (p))->l) |
||||
# define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v)) |
||||
|
||||
#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_X64) || defined(_M_ARM64)) && AV_HAVE_FAST_UNALIGNED |
||||
|
||||
# define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) |
||||
# define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) |
||||
|
||||
#elif AV_HAVE_FAST_UNALIGNED |
||||
|
||||
# define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) |
||||
# define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) |
||||
|
||||
#else |
||||
|
||||
#ifndef AV_RB16 |
||||
# define AV_RB16(x) \ |
||||
((((const uint8_t*)(x))[0] << 8) | \
|
||||
((const uint8_t*)(x))[1]) |
||||
#endif |
||||
#ifndef AV_WB16 |
||||
# define AV_WB16(p, val) do { \ |
||||
uint16_t d = (val); \
|
||||
((uint8_t*)(p))[1] = (d); \
|
||||
((uint8_t*)(p))[0] = (d)>>8; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RL16 |
||||
# define AV_RL16(x) \ |
||||
((((const uint8_t*)(x))[1] << 8) | \
|
||||
((const uint8_t*)(x))[0]) |
||||
#endif |
||||
#ifndef AV_WL16 |
||||
# define AV_WL16(p, val) do { \ |
||||
uint16_t d = (val); \
|
||||
((uint8_t*)(p))[0] = (d); \
|
||||
((uint8_t*)(p))[1] = (d)>>8; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RB32 |
||||
# define AV_RB32(x) \ |
||||
(((uint32_t)((const uint8_t*)(x))[0] << 24) | \
|
||||
(((const uint8_t*)(x))[1] << 16) | \
|
||||
(((const uint8_t*)(x))[2] << 8) | \
|
||||
((const uint8_t*)(x))[3]) |
||||
#endif |
||||
#ifndef AV_WB32 |
||||
# define AV_WB32(p, val) do { \ |
||||
uint32_t d = (val); \
|
||||
((uint8_t*)(p))[3] = (d); \
|
||||
((uint8_t*)(p))[2] = (d)>>8; \
|
||||
((uint8_t*)(p))[1] = (d)>>16; \
|
||||
((uint8_t*)(p))[0] = (d)>>24; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RL32 |
||||
# define AV_RL32(x) \ |
||||
(((uint32_t)((const uint8_t*)(x))[3] << 24) | \
|
||||
(((const uint8_t*)(x))[2] << 16) | \
|
||||
(((const uint8_t*)(x))[1] << 8) | \
|
||||
((const uint8_t*)(x))[0]) |
||||
#endif |
||||
#ifndef AV_WL32 |
||||
# define AV_WL32(p, val) do { \ |
||||
uint32_t d = (val); \
|
||||
((uint8_t*)(p))[0] = (d); \
|
||||
((uint8_t*)(p))[1] = (d)>>8; \
|
||||
((uint8_t*)(p))[2] = (d)>>16; \
|
||||
((uint8_t*)(p))[3] = (d)>>24; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RB64 |
||||
# define AV_RB64(x) \ |
||||
(((uint64_t)((const uint8_t*)(x))[0] << 56) | \
|
||||
((uint64_t)((const uint8_t*)(x))[1] << 48) | \
|
||||
((uint64_t)((const uint8_t*)(x))[2] << 40) | \
|
||||
((uint64_t)((const uint8_t*)(x))[3] << 32) | \
|
||||
((uint64_t)((const uint8_t*)(x))[4] << 24) | \
|
||||
((uint64_t)((const uint8_t*)(x))[5] << 16) | \
|
||||
((uint64_t)((const uint8_t*)(x))[6] << 8) | \
|
||||
(uint64_t)((const uint8_t*)(x))[7]) |
||||
#endif |
||||
#ifndef AV_WB64 |
||||
# define AV_WB64(p, val) do { \ |
||||
uint64_t d = (val); \
|
||||
((uint8_t*)(p))[7] = (d); \
|
||||
((uint8_t*)(p))[6] = (d)>>8; \
|
||||
((uint8_t*)(p))[5] = (d)>>16; \
|
||||
((uint8_t*)(p))[4] = (d)>>24; \
|
||||
((uint8_t*)(p))[3] = (d)>>32; \
|
||||
((uint8_t*)(p))[2] = (d)>>40; \
|
||||
((uint8_t*)(p))[1] = (d)>>48; \
|
||||
((uint8_t*)(p))[0] = (d)>>56; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RL64 |
||||
# define AV_RL64(x) \ |
||||
(((uint64_t)((const uint8_t*)(x))[7] << 56) | \
|
||||
((uint64_t)((const uint8_t*)(x))[6] << 48) | \
|
||||
((uint64_t)((const uint8_t*)(x))[5] << 40) | \
|
||||
((uint64_t)((const uint8_t*)(x))[4] << 32) | \
|
||||
((uint64_t)((const uint8_t*)(x))[3] << 24) | \
|
||||
((uint64_t)((const uint8_t*)(x))[2] << 16) | \
|
||||
((uint64_t)((const uint8_t*)(x))[1] << 8) | \
|
||||
(uint64_t)((const uint8_t*)(x))[0]) |
||||
#endif |
||||
#ifndef AV_WL64 |
||||
# define AV_WL64(p, val) do { \ |
||||
uint64_t d = (val); \
|
||||
((uint8_t*)(p))[0] = (d); \
|
||||
((uint8_t*)(p))[1] = (d)>>8; \
|
||||
((uint8_t*)(p))[2] = (d)>>16; \
|
||||
((uint8_t*)(p))[3] = (d)>>24; \
|
||||
((uint8_t*)(p))[4] = (d)>>32; \
|
||||
((uint8_t*)(p))[5] = (d)>>40; \
|
||||
((uint8_t*)(p))[6] = (d)>>48; \
|
||||
((uint8_t*)(p))[7] = (d)>>56; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
# define AV_RN(s, p) AV_RB##s(p) |
||||
# define AV_WN(s, p, v) AV_WB##s(p, v) |
||||
#else |
||||
# define AV_RN(s, p) AV_RL##s(p) |
||||
# define AV_WN(s, p, v) AV_WL##s(p, v) |
||||
#endif |
||||
|
||||
#endif /* HAVE_FAST_UNALIGNED */ |
||||
|
||||
#ifndef AV_RN16 |
||||
# define AV_RN16(p) AV_RN(16, p) |
||||
#endif |
||||
|
||||
#ifndef AV_RN32 |
||||
# define AV_RN32(p) AV_RN(32, p) |
||||
#endif |
||||
|
||||
#ifndef AV_RN64 |
||||
# define AV_RN64(p) AV_RN(64, p) |
||||
#endif |
||||
|
||||
#ifndef AV_WN16 |
||||
# define AV_WN16(p, v) AV_WN(16, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_WN32 |
||||
# define AV_WN32(p, v) AV_WN(32, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_WN64 |
||||
# define AV_WN64(p, v) AV_WN(64, p, v) |
||||
#endif |
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
# define AV_RB(s, p) AV_RN##s(p) |
||||
# define AV_WB(s, p, v) AV_WN##s(p, v) |
||||
# define AV_RL(s, p) av_bswap##s(AV_RN##s(p)) |
||||
# define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v)) |
||||
#else |
||||
# define AV_RB(s, p) av_bswap##s(AV_RN##s(p)) |
||||
# define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v)) |
||||
# define AV_RL(s, p) AV_RN##s(p) |
||||
# define AV_WL(s, p, v) AV_WN##s(p, v) |
||||
#endif |
||||
|
||||
#define AV_RB8(x) (((const uint8_t*)(x))[0]) |
||||
#define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) |
||||
|
||||
#define AV_RL8(x) AV_RB8(x) |
||||
#define AV_WL8(p, d) AV_WB8(p, d) |
||||
|
||||
#ifndef AV_RB16 |
||||
# define AV_RB16(p) AV_RB(16, p) |
||||
#endif |
||||
#ifndef AV_WB16 |
||||
# define AV_WB16(p, v) AV_WB(16, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RL16 |
||||
# define AV_RL16(p) AV_RL(16, p) |
||||
#endif |
||||
#ifndef AV_WL16 |
||||
# define AV_WL16(p, v) AV_WL(16, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RB32 |
||||
# define AV_RB32(p) AV_RB(32, p) |
||||
#endif |
||||
#ifndef AV_WB32 |
||||
# define AV_WB32(p, v) AV_WB(32, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RL32 |
||||
# define AV_RL32(p) AV_RL(32, p) |
||||
#endif |
||||
#ifndef AV_WL32 |
||||
# define AV_WL32(p, v) AV_WL(32, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RB64 |
||||
# define AV_RB64(p) AV_RB(64, p) |
||||
#endif |
||||
#ifndef AV_WB64 |
||||
# define AV_WB64(p, v) AV_WB(64, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RL64 |
||||
# define AV_RL64(p) AV_RL(64, p) |
||||
#endif |
||||
#ifndef AV_WL64 |
||||
# define AV_WL64(p, v) AV_WL(64, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RB24 |
||||
# define AV_RB24(x) \ |
||||
((((const uint8_t*)(x))[0] << 16) | \
|
||||
(((const uint8_t*)(x))[1] << 8) | \
|
||||
((const uint8_t*)(x))[2]) |
||||
#endif |
||||
#ifndef AV_WB24 |
||||
# define AV_WB24(p, d) do { \ |
||||
((uint8_t*)(p))[2] = (d); \
|
||||
((uint8_t*)(p))[1] = (d)>>8; \
|
||||
((uint8_t*)(p))[0] = (d)>>16; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RL24 |
||||
# define AV_RL24(x) \ |
||||
((((const uint8_t*)(x))[2] << 16) | \
|
||||
(((const uint8_t*)(x))[1] << 8) | \
|
||||
((const uint8_t*)(x))[0]) |
||||
#endif |
||||
#ifndef AV_WL24 |
||||
# define AV_WL24(p, d) do { \ |
||||
((uint8_t*)(p))[0] = (d); \
|
||||
((uint8_t*)(p))[1] = (d)>>8; \
|
||||
((uint8_t*)(p))[2] = (d)>>16; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RB48 |
||||
# define AV_RB48(x) \ |
||||
(((uint64_t)((const uint8_t*)(x))[0] << 40) | \
|
||||
((uint64_t)((const uint8_t*)(x))[1] << 32) | \
|
||||
((uint64_t)((const uint8_t*)(x))[2] << 24) | \
|
||||
((uint64_t)((const uint8_t*)(x))[3] << 16) | \
|
||||
((uint64_t)((const uint8_t*)(x))[4] << 8) | \
|
||||
(uint64_t)((const uint8_t*)(x))[5]) |
||||
#endif |
||||
#ifndef AV_WB48 |
||||
# define AV_WB48(p, darg) do { \ |
||||
uint64_t d = (darg); \
|
||||
((uint8_t*)(p))[5] = (d); \
|
||||
((uint8_t*)(p))[4] = (d)>>8; \
|
||||
((uint8_t*)(p))[3] = (d)>>16; \
|
||||
((uint8_t*)(p))[2] = (d)>>24; \
|
||||
((uint8_t*)(p))[1] = (d)>>32; \
|
||||
((uint8_t*)(p))[0] = (d)>>40; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#ifndef AV_RL48 |
||||
# define AV_RL48(x) \ |
||||
(((uint64_t)((const uint8_t*)(x))[5] << 40) | \
|
||||
((uint64_t)((const uint8_t*)(x))[4] << 32) | \
|
||||
((uint64_t)((const uint8_t*)(x))[3] << 24) | \
|
||||
((uint64_t)((const uint8_t*)(x))[2] << 16) | \
|
||||
((uint64_t)((const uint8_t*)(x))[1] << 8) | \
|
||||
(uint64_t)((const uint8_t*)(x))[0]) |
||||
#endif |
||||
#ifndef AV_WL48 |
||||
# define AV_WL48(p, darg) do { \ |
||||
uint64_t d = (darg); \
|
||||
((uint8_t*)(p))[0] = (d); \
|
||||
((uint8_t*)(p))[1] = (d)>>8; \
|
||||
((uint8_t*)(p))[2] = (d)>>16; \
|
||||
((uint8_t*)(p))[3] = (d)>>24; \
|
||||
((uint8_t*)(p))[4] = (d)>>32; \
|
||||
((uint8_t*)(p))[5] = (d)>>40; \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
/*
|
||||
* The AV_[RW]NA macros access naturally aligned data |
||||
* in a type-safe way. |
||||
*/ |
||||
|
||||
#define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s) |
||||
#define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v)) |
||||
|
||||
#ifndef AV_RN16A |
||||
# define AV_RN16A(p) AV_RNA(16, p) |
||||
#endif |
||||
|
||||
#ifndef AV_RN32A |
||||
# define AV_RN32A(p) AV_RNA(32, p) |
||||
#endif |
||||
|
||||
#ifndef AV_RN64A |
||||
# define AV_RN64A(p) AV_RNA(64, p) |
||||
#endif |
||||
|
||||
#ifndef AV_WN16A |
||||
# define AV_WN16A(p, v) AV_WNA(16, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_WN32A |
||||
# define AV_WN32A(p, v) AV_WNA(32, p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_WN64A |
||||
# define AV_WN64A(p, v) AV_WNA(64, p, v) |
||||
#endif |
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
# define AV_RLA(s, p) av_bswap##s(AV_RN##s##A(p)) |
||||
# define AV_WLA(s, p, v) AV_WN##s##A(p, av_bswap##s(v)) |
||||
#else |
||||
# define AV_RLA(s, p) AV_RN##s##A(p) |
||||
# define AV_WLA(s, p, v) AV_WN##s##A(p, v) |
||||
#endif |
||||
|
||||
#ifndef AV_RL64A |
||||
# define AV_RL64A(p) AV_RLA(64, p) |
||||
#endif |
||||
#ifndef AV_WL64A |
||||
# define AV_WL64A(p, v) AV_WLA(64, p, v) |
||||
#endif |
||||
|
||||
/*
|
||||
* The AV_COPYxxU macros are suitable for copying data to/from unaligned |
||||
* memory locations. |
||||
*/ |
||||
|
||||
#define AV_COPYU(n, d, s) AV_WN##n(d, AV_RN##n(s)); |
||||
|
||||
#ifndef AV_COPY16U |
||||
# define AV_COPY16U(d, s) AV_COPYU(16, d, s) |
||||
#endif |
||||
|
||||
#ifndef AV_COPY32U |
||||
# define AV_COPY32U(d, s) AV_COPYU(32, d, s) |
||||
#endif |
||||
|
||||
#ifndef AV_COPY64U |
||||
# define AV_COPY64U(d, s) AV_COPYU(64, d, s) |
||||
#endif |
||||
|
||||
#ifndef AV_COPY128U |
||||
# define AV_COPY128U(d, s) \ |
||||
do { \
|
||||
AV_COPY64U(d, s); \
|
||||
AV_COPY64U((char *)(d) + 8, (const char *)(s) + 8); \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
/* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be
|
||||
* naturally aligned. They may be implemented using MMX, |
||||
* so emms_c() must be called before using any float code |
||||
* afterwards. |
||||
*/ |
||||
|
||||
#define AV_COPY(n, d, s) \ |
||||
(((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n) |
||||
|
||||
#ifndef AV_COPY16 |
||||
# define AV_COPY16(d, s) AV_COPY(16, d, s) |
||||
#endif |
||||
|
||||
#ifndef AV_COPY32 |
||||
# define AV_COPY32(d, s) AV_COPY(32, d, s) |
||||
#endif |
||||
|
||||
#ifndef AV_COPY64 |
||||
# define AV_COPY64(d, s) AV_COPY(64, d, s) |
||||
#endif |
||||
|
||||
#ifndef AV_COPY128 |
||||
# define AV_COPY128(d, s) \ |
||||
do { \
|
||||
AV_COPY64(d, s); \
|
||||
AV_COPY64((char*)(d)+8, (char*)(s)+8); \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b)) |
||||
|
||||
#ifndef AV_SWAP64 |
||||
# define AV_SWAP64(a, b) AV_SWAP(64, a, b) |
||||
#endif |
||||
|
||||
#define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0) |
||||
|
||||
#ifndef AV_ZERO16 |
||||
# define AV_ZERO16(d) AV_ZERO(16, d) |
||||
#endif |
||||
|
||||
#ifndef AV_ZERO32 |
||||
# define AV_ZERO32(d) AV_ZERO(32, d) |
||||
#endif |
||||
|
||||
#ifndef AV_ZERO64 |
||||
# define AV_ZERO64(d) AV_ZERO(64, d) |
||||
#endif |
||||
|
||||
#ifndef AV_ZERO128 |
||||
# define AV_ZERO128(d) \ |
||||
do { \
|
||||
AV_ZERO64(d); \
|
||||
AV_ZERO64((char*)(d)+8); \
|
||||
} while(0) |
||||
#endif |
||||
|
||||
#endif /* AVUTIL_INTREADWRITE_H */ |
@ -0,0 +1,80 @@ |
||||
/*
|
||||
* Lagged Fibonacci PRNG |
||||
* Copyright (c) 2008 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 AVUTIL_LFG_H |
||||
#define AVUTIL_LFG_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
* Context structure for the Lagged Fibonacci PRNG. |
||||
* The exact layout, types and content of this struct may change and should |
||||
* not be accessed directly. Only its sizeof() is guranteed to stay the same |
||||
* to allow easy instanciation. |
||||
*/ |
||||
typedef struct AVLFG { |
||||
unsigned int state[64]; |
||||
int index; |
||||
} AVLFG; |
||||
|
||||
void av_lfg_init(AVLFG *c, unsigned int seed); |
||||
|
||||
/**
|
||||
* Seed the state of the ALFG using binary data. |
||||
* |
||||
* Return value: 0 on success, negative value (AVERROR) on failure. |
||||
*/ |
||||
int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length); |
||||
|
||||
/**
|
||||
* Get the next random unsigned 32-bit number using an ALFG. |
||||
* |
||||
* Please also consider a simple LCG like state= state*1664525+1013904223, |
||||
* it may be good enough and faster for your specific use case. |
||||
*/ |
||||
static inline unsigned int av_lfg_get(AVLFG *c){ |
||||
unsigned a = c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 63]; |
||||
c->index += 1U; |
||||
return a; |
||||
} |
||||
|
||||
/**
|
||||
* Get the next random unsigned 32-bit number using a MLFG. |
||||
* |
||||
* Please also consider av_lfg_get() above, it is faster. |
||||
*/ |
||||
static inline unsigned int av_mlfg_get(AVLFG *c){ |
||||
unsigned int a= c->state[(c->index-55) & 63]; |
||||
unsigned int b= c->state[(c->index-24) & 63]; |
||||
a = c->state[c->index & 63] = 2*a*b+a+b; |
||||
c->index += 1U; |
||||
return a; |
||||
} |
||||
|
||||
/**
|
||||
* Get the next two numbers generated by a Box-Muller Gaussian |
||||
* generator using the random numbers issued by lfg. |
||||
* |
||||
* @param out array where the two generated numbers are placed |
||||
*/ |
||||
void av_bmg_get(AVLFG *lfg, double out[2]); |
||||
|
||||
#endif /* AVUTIL_LFG_H */ |
@ -0,0 +1,401 @@ |
||||
/*
|
||||
* 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_LOG_H |
||||
#define AVUTIL_LOG_H |
||||
|
||||
#include <stdarg.h> |
||||
#include "avutil.h" |
||||
#include "attributes.h" |
||||
#include "version.h" |
||||
|
||||
typedef enum { |
||||
AV_CLASS_CATEGORY_NA = 0, |
||||
AV_CLASS_CATEGORY_INPUT, |
||||
AV_CLASS_CATEGORY_OUTPUT, |
||||
AV_CLASS_CATEGORY_MUXER, |
||||
AV_CLASS_CATEGORY_DEMUXER, |
||||
AV_CLASS_CATEGORY_ENCODER, |
||||
AV_CLASS_CATEGORY_DECODER, |
||||
AV_CLASS_CATEGORY_FILTER, |
||||
AV_CLASS_CATEGORY_BITSTREAM_FILTER, |
||||
AV_CLASS_CATEGORY_SWSCALER, |
||||
AV_CLASS_CATEGORY_SWRESAMPLER, |
||||
AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40, |
||||
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT, |
||||
AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT, |
||||
AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT, |
||||
AV_CLASS_CATEGORY_DEVICE_OUTPUT, |
||||
AV_CLASS_CATEGORY_DEVICE_INPUT, |
||||
AV_CLASS_CATEGORY_NB ///< not part of ABI/API
|
||||
}AVClassCategory; |
||||
|
||||
#define AV_IS_INPUT_DEVICE(category) \ |
||||
(((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) || \
|
||||
((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) || \
|
||||
((category) == AV_CLASS_CATEGORY_DEVICE_INPUT)) |
||||
|
||||
#define AV_IS_OUTPUT_DEVICE(category) \ |
||||
(((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT) || \
|
||||
((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT) || \
|
||||
((category) == AV_CLASS_CATEGORY_DEVICE_OUTPUT)) |
||||
|
||||
struct AVOptionRanges; |
||||
|
||||
/**
|
||||
* Describe the class of an AVClass context structure. That is an |
||||
* arbitrary struct of which the first field is a pointer to an |
||||
* AVClass struct (e.g. AVCodecContext, AVFormatContext etc.). |
||||
*/ |
||||
typedef struct AVClass { |
||||
/**
|
||||
* The name of the class; usually it is the same name as the |
||||
* context structure type to which the AVClass is associated. |
||||
*/ |
||||
const char* class_name; |
||||
|
||||
/**
|
||||
* A pointer to a function which returns the name of a context |
||||
* instance ctx associated with the class. |
||||
*/ |
||||
const char* (*item_name)(void* ctx); |
||||
|
||||
/**
|
||||
* a pointer to the first option specified in the class if any or NULL |
||||
* |
||||
* @see av_set_default_options() |
||||
*/ |
||||
const struct AVOption *option; |
||||
|
||||
/**
|
||||
* LIBAVUTIL_VERSION with which this structure was created. |
||||
* This is used to allow fields to be added without requiring major |
||||
* version bumps everywhere. |
||||
*/ |
||||
|
||||
int version; |
||||
|
||||
/**
|
||||
* Offset in the structure where log_level_offset is stored. |
||||
* 0 means there is no such variable |
||||
*/ |
||||
int log_level_offset_offset; |
||||
|
||||
/**
|
||||
* Offset in the structure where a pointer to the parent context for |
||||
* logging is stored. For example a decoder could pass its AVCodecContext |
||||
* to eval as such a parent context, which an av_log() implementation |
||||
* could then leverage to display the parent context. |
||||
* The offset can be NULL. |
||||
*/ |
||||
int parent_log_context_offset; |
||||
|
||||
/**
|
||||
* Return next AVOptions-enabled child or NULL |
||||
*/ |
||||
void* (*child_next)(void *obj, void *prev); |
||||
|
||||
#if FF_API_CHILD_CLASS_NEXT |
||||
/**
|
||||
* Return an AVClass corresponding to the next potential |
||||
* AVOptions-enabled child. |
||||
* |
||||
* The difference between child_next and this is that |
||||
* child_next iterates over _already existing_ objects, while |
||||
* child_class_next iterates over _all possible_ children. |
||||
*/ |
||||
attribute_deprecated |
||||
const struct AVClass* (*child_class_next)(const struct AVClass *prev); |
||||
#endif |
||||
|
||||
/**
|
||||
* Category used for visualization (like color) |
||||
* This is only set if the category is equal for all objects using this class. |
||||
* available since version (51 << 16 | 56 << 8 | 100) |
||||
*/ |
||||
AVClassCategory category; |
||||
|
||||
/**
|
||||
* Callback to return the category. |
||||
* available since version (51 << 16 | 59 << 8 | 100) |
||||
*/ |
||||
AVClassCategory (*get_category)(void* ctx); |
||||
|
||||
/**
|
||||
* Callback to return the supported/allowed ranges. |
||||
* available since version (52.12) |
||||
*/ |
||||
int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags); |
||||
|
||||
/**
|
||||
* Iterate over the AVClasses corresponding to potential AVOptions-enabled |
||||
* children. |
||||
* |
||||
* @param iter pointer to opaque iteration state. The caller must initialize |
||||
* *iter to NULL before the first call. |
||||
* @return AVClass for the next AVOptions-enabled child or NULL if there are |
||||
* no more such children. |
||||
* |
||||
* @note The difference between child_next and this is that child_next |
||||
* iterates over _already existing_ objects, while child_class_iterate |
||||
* iterates over _all possible_ children. |
||||
*/ |
||||
const struct AVClass* (*child_class_iterate)(void **iter); |
||||
} AVClass; |
||||
|
||||
/**
|
||||
* @addtogroup lavu_log |
||||
* |
||||
* @{ |
||||
* |
||||
* @defgroup lavu_log_constants Logging Constants |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Print no output. |
||||
*/ |
||||
#define AV_LOG_QUIET -8 |
||||
|
||||
/**
|
||||
* Something went really wrong and we will crash now. |
||||
*/ |
||||
#define AV_LOG_PANIC 0 |
||||
|
||||
/**
|
||||
* Something went wrong and recovery is not possible. |
||||
* For example, no header was found for a format which depends |
||||
* on headers or an illegal combination of parameters is used. |
||||
*/ |
||||
#define AV_LOG_FATAL 8 |
||||
|
||||
/**
|
||||
* Something went wrong and cannot losslessly be recovered. |
||||
* However, not all future data is affected. |
||||
*/ |
||||
#define AV_LOG_ERROR 16 |
||||
|
||||
/**
|
||||
* Something somehow does not look correct. This may or may not |
||||
* lead to problems. An example would be the use of '-vstrict -2'. |
||||
*/ |
||||
#define AV_LOG_WARNING 24 |
||||
|
||||
/**
|
||||
* Standard information. |
||||
*/ |
||||
#define AV_LOG_INFO 32 |
||||
|
||||
/**
|
||||
* Detailed information. |
||||
*/ |
||||
#define AV_LOG_VERBOSE 40 |
||||
|
||||
/**
|
||||
* Stuff which is only useful for libav* developers. |
||||
*/ |
||||
#define AV_LOG_DEBUG 48 |
||||
|
||||
/**
|
||||
* Extremely verbose debugging, useful for libav* development. |
||||
*/ |
||||
#define AV_LOG_TRACE 56 |
||||
|
||||
#define AV_LOG_MAX_OFFSET (AV_LOG_TRACE - AV_LOG_QUIET) |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* Sets additional colors for extended debugging sessions. |
||||
* @code |
||||
av_log(ctx, AV_LOG_DEBUG|AV_LOG_C(134), "Message in purple\n"); |
||||
@endcode |
||||
* Requires 256color terminal support. Uses outside debugging is not |
||||
* recommended. |
||||
*/ |
||||
#define AV_LOG_C(x) ((x) << 8) |
||||
|
||||
/**
|
||||
* Send the specified message to the log if the level is less than or equal |
||||
* to the current av_log_level. By default, all logging messages are sent to |
||||
* stderr. This behavior can be altered by setting a different logging callback |
||||
* function. |
||||
* @see av_log_set_callback |
||||
* |
||||
* @param avcl A pointer to an arbitrary struct of which the first field is a |
||||
* pointer to an AVClass struct or NULL if general log. |
||||
* @param level The importance level of the message expressed using a @ref |
||||
* lavu_log_constants "Logging Constant". |
||||
* @param fmt The format string (printf-compatible) that specifies how |
||||
* subsequent arguments are converted to output. |
||||
*/ |
||||
void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4); |
||||
|
||||
/**
|
||||
* Send the specified message to the log once with the initial_level and then with |
||||
* the subsequent_level. By default, all logging messages are sent to |
||||
* stderr. This behavior can be altered by setting a different logging callback |
||||
* function. |
||||
* @see av_log |
||||
* |
||||
* @param avcl A pointer to an arbitrary struct of which the first field is a |
||||
* pointer to an AVClass struct or NULL if general log. |
||||
* @param initial_level importance level of the message expressed using a @ref |
||||
* lavu_log_constants "Logging Constant" for the first occurance. |
||||
* @param subsequent_level importance level of the message expressed using a @ref |
||||
* lavu_log_constants "Logging Constant" after the first occurance. |
||||
* @param fmt The format string (printf-compatible) that specifies how |
||||
* subsequent arguments are converted to output. |
||||
* @param state a variable to keep trak of if a message has already been printed |
||||
* this must be initialized to 0 before the first use. The same state |
||||
* must not be accessed by 2 Threads simultaneously. |
||||
*/ |
||||
void av_log_once(void* avcl, int initial_level, int subsequent_level, int *state, const char *fmt, ...) av_printf_format(5, 6); |
||||
|
||||
|
||||
/**
|
||||
* Send the specified message to the log if the level is less than or equal |
||||
* to the current av_log_level. By default, all logging messages are sent to |
||||
* stderr. This behavior can be altered by setting a different logging callback |
||||
* function. |
||||
* @see av_log_set_callback |
||||
* |
||||
* @param avcl A pointer to an arbitrary struct of which the first field is a |
||||
* pointer to an AVClass struct. |
||||
* @param level The importance level of the message expressed using a @ref |
||||
* lavu_log_constants "Logging Constant". |
||||
* @param fmt The format string (printf-compatible) that specifies how |
||||
* subsequent arguments are converted to output. |
||||
* @param vl The arguments referenced by the format string. |
||||
*/ |
||||
void av_vlog(void *avcl, int level, const char *fmt, va_list vl); |
||||
|
||||
/**
|
||||
* Get the current log level |
||||
* |
||||
* @see lavu_log_constants |
||||
* |
||||
* @return Current log level |
||||
*/ |
||||
int av_log_get_level(void); |
||||
|
||||
/**
|
||||
* Set the log level |
||||
* |
||||
* @see lavu_log_constants |
||||
* |
||||
* @param level Logging level |
||||
*/ |
||||
void av_log_set_level(int level); |
||||
|
||||
/**
|
||||
* Set the logging callback |
||||
* |
||||
* @note The callback must be thread safe, even if the application does not use |
||||
* threads itself as some codecs are multithreaded. |
||||
* |
||||
* @see av_log_default_callback |
||||
* |
||||
* @param callback A logging function with a compatible signature. |
||||
*/ |
||||
void av_log_set_callback(void (*callback)(void*, int, const char*, va_list)); |
||||
|
||||
/**
|
||||
* Default logging callback |
||||
* |
||||
* It prints the message to stderr, optionally colorizing it. |
||||
* |
||||
* @param avcl A pointer to an arbitrary struct of which the first field is a |
||||
* pointer to an AVClass struct. |
||||
* @param level The importance level of the message expressed using a @ref |
||||
* lavu_log_constants "Logging Constant". |
||||
* @param fmt The format string (printf-compatible) that specifies how |
||||
* subsequent arguments are converted to output. |
||||
* @param vl The arguments referenced by the format string. |
||||
*/ |
||||
void av_log_default_callback(void *avcl, int level, const char *fmt, |
||||
va_list vl); |
||||
|
||||
/**
|
||||
* Return the context name |
||||
* |
||||
* @param ctx The AVClass context |
||||
* |
||||
* @return The AVClass class_name |
||||
*/ |
||||
const char* av_default_item_name(void* ctx); |
||||
AVClassCategory av_default_get_category(void *ptr); |
||||
|
||||
/**
|
||||
* Format a line of log the same way as the default callback. |
||||
* @param line buffer to receive the formatted line |
||||
* @param line_size size of the buffer |
||||
* @param print_prefix used to store whether the prefix must be printed; |
||||
* must point to a persistent integer initially set to 1 |
||||
*/ |
||||
void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, |
||||
char *line, int line_size, int *print_prefix); |
||||
|
||||
/**
|
||||
* Format a line of log the same way as the default callback. |
||||
* @param line buffer to receive the formatted line; |
||||
* may be NULL if line_size is 0 |
||||
* @param line_size size of the buffer; at most line_size-1 characters will |
||||
* be written to the buffer, plus one null terminator |
||||
* @param print_prefix used to store whether the prefix must be printed; |
||||
* must point to a persistent integer initially set to 1 |
||||
* @return Returns a negative value if an error occurred, otherwise returns |
||||
* the number of characters that would have been written for a |
||||
* sufficiently large buffer, not including the terminating null |
||||
* character. If the return value is not less than line_size, it means |
||||
* that the log message was truncated to fit the buffer. |
||||
*/ |
||||
int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl, |
||||
char *line, int line_size, int *print_prefix); |
||||
|
||||
/**
|
||||
* Skip repeated messages, this requires the user app to use av_log() instead of |
||||
* (f)printf as the 2 would otherwise interfere and lead to |
||||
* "Last message repeated x times" messages below (f)printf messages with some |
||||
* bad luck. |
||||
* Also to receive the last, "last repeated" line if any, the user app must |
||||
* call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end |
||||
*/ |
||||
#define AV_LOG_SKIP_REPEATED 1 |
||||
|
||||
/**
|
||||
* Include the log severity in messages originating from codecs. |
||||
* |
||||
* Results in messages such as: |
||||
* [rawvideo @ 0xDEADBEEF] [error] encode did not produce valid pts |
||||
*/ |
||||
#define AV_LOG_PRINT_LEVEL 2 |
||||
|
||||
void av_log_set_flags(int arg); |
||||
int av_log_get_flags(void); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_LOG_H */ |
@ -0,0 +1,66 @@ |
||||
/*
|
||||
* LZO 1x decompression |
||||
* copyright (c) 2006 Reimar Doeffinger |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_LZO_H |
||||
#define AVUTIL_LZO_H |
||||
|
||||
/**
|
||||
* @defgroup lavu_lzo LZO |
||||
* @ingroup lavu_crypto |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/** @name Error flags returned by av_lzo1x_decode
|
||||
* @{ */ |
||||
/// end of the input buffer reached before decoding finished
|
||||
#define AV_LZO_INPUT_DEPLETED 1 |
||||
/// decoded data did not fit into output buffer
|
||||
#define AV_LZO_OUTPUT_FULL 2 |
||||
/// a reference to previously decoded data was wrong
|
||||
#define AV_LZO_INVALID_BACKPTR 4 |
||||
/// a non-specific error in the compressed bitstream
|
||||
#define AV_LZO_ERROR 8 |
||||
/** @} */ |
||||
|
||||
#define AV_LZO_INPUT_PADDING 8 |
||||
#define AV_LZO_OUTPUT_PADDING 12 |
||||
|
||||
/**
|
||||
* @brief Decodes LZO 1x compressed data. |
||||
* @param out output buffer |
||||
* @param outlen size of output buffer, number of bytes left are returned here |
||||
* @param in input buffer |
||||
* @param inlen size of input buffer, number of bytes left are returned here |
||||
* @return 0 on success, otherwise a combination of the error flags above |
||||
* |
||||
* Make sure all buffers are appropriately padded, in must provide |
||||
* AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes. |
||||
*/ |
||||
int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_LZO_H */ |
@ -0,0 +1,50 @@ |
||||
/*
|
||||
* 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 |
||||
* Utility Preprocessor macros |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_MACROS_H |
||||
#define AVUTIL_MACROS_H |
||||
|
||||
/**
|
||||
* @addtogroup preproc_misc Preprocessor String Macros |
||||
* |
||||
* String manipulation macros |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#define AV_STRINGIFY(s) AV_TOSTRING(s) |
||||
#define AV_TOSTRING(s) #s |
||||
|
||||
#define AV_GLUE(a, b) a ## b |
||||
#define AV_JOIN(a, b) AV_GLUE(a, b) |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#define AV_PRAGMA(s) _Pragma(#s) |
||||
|
||||
#define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1)) |
||||
|
||||
#endif /* AVUTIL_MACROS_H */ |
@ -0,0 +1,128 @@ |
||||
/*
|
||||
* Copyright (c) 2016 Neil Birkbeck <neil.birkbeck@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_MASTERING_DISPLAY_METADATA_H |
||||
#define AVUTIL_MASTERING_DISPLAY_METADATA_H |
||||
|
||||
#include "frame.h" |
||||
#include "rational.h" |
||||
|
||||
|
||||
/**
|
||||
* Mastering display metadata capable of representing the color volume of |
||||
* the display used to master the content (SMPTE 2086:2014). |
||||
* |
||||
* To be used as payload of a AVFrameSideData or AVPacketSideData with the |
||||
* appropriate type. |
||||
* |
||||
* @note The struct should be allocated with av_mastering_display_metadata_alloc() |
||||
* and its size is not a part of the public ABI. |
||||
*/ |
||||
typedef struct AVMasteringDisplayMetadata { |
||||
/**
|
||||
* CIE 1931 xy chromaticity coords of color primaries (r, g, b order). |
||||
*/ |
||||
AVRational display_primaries[3][2]; |
||||
|
||||
/**
|
||||
* CIE 1931 xy chromaticity coords of white point. |
||||
*/ |
||||
AVRational white_point[2]; |
||||
|
||||
/**
|
||||
* Min luminance of mastering display (cd/m^2). |
||||
*/ |
||||
AVRational min_luminance; |
||||
|
||||
/**
|
||||
* Max luminance of mastering display (cd/m^2). |
||||
*/ |
||||
AVRational max_luminance; |
||||
|
||||
/**
|
||||
* Flag indicating whether the display primaries (and white point) are set. |
||||
*/ |
||||
int has_primaries; |
||||
|
||||
/**
|
||||
* Flag indicating whether the luminance (min_ and max_) have been set. |
||||
*/ |
||||
int has_luminance; |
||||
|
||||
} AVMasteringDisplayMetadata; |
||||
|
||||
/**
|
||||
* Allocate an AVMasteringDisplayMetadata structure and set its fields to |
||||
* default values. The resulting struct can be freed using av_freep(). |
||||
* |
||||
* @return An AVMasteringDisplayMetadata filled with default values or NULL |
||||
* on failure. |
||||
*/ |
||||
AVMasteringDisplayMetadata *av_mastering_display_metadata_alloc(void); |
||||
|
||||
/**
|
||||
* Allocate a complete AVMasteringDisplayMetadata and add it to the frame. |
||||
* |
||||
* @param frame The frame which side data is added to. |
||||
* |
||||
* @return The AVMasteringDisplayMetadata structure to be filled by caller. |
||||
*/ |
||||
AVMasteringDisplayMetadata *av_mastering_display_metadata_create_side_data(AVFrame *frame); |
||||
|
||||
/**
|
||||
* Content light level needed by to transmit HDR over HDMI (CTA-861.3). |
||||
* |
||||
* To be used as payload of a AVFrameSideData or AVPacketSideData with the |
||||
* appropriate type. |
||||
* |
||||
* @note The struct should be allocated with av_content_light_metadata_alloc() |
||||
* and its size is not a part of the public ABI. |
||||
*/ |
||||
typedef struct AVContentLightMetadata { |
||||
/**
|
||||
* Max content light level (cd/m^2). |
||||
*/ |
||||
unsigned MaxCLL; |
||||
|
||||
/**
|
||||
* Max average light level per frame (cd/m^2). |
||||
*/ |
||||
unsigned MaxFALL; |
||||
} AVContentLightMetadata; |
||||
|
||||
/**
|
||||
* Allocate an AVContentLightMetadata structure and set its fields to |
||||
* default values. The resulting struct can be freed using av_freep(). |
||||
* |
||||
* @return An AVContentLightMetadata filled with default values or NULL |
||||
* on failure. |
||||
*/ |
||||
AVContentLightMetadata *av_content_light_metadata_alloc(size_t *size); |
||||
|
||||
/**
|
||||
* Allocate a complete AVContentLightMetadata and add it to the frame. |
||||
* |
||||
* @param frame The frame which side data is added to. |
||||
* |
||||
* @return The AVContentLightMetadata structure to be filled by caller. |
||||
*/ |
||||
AVContentLightMetadata *av_content_light_metadata_create_side_data(AVFrame *frame); |
||||
|
||||
#endif /* AVUTIL_MASTERING_DISPLAY_METADATA_H */ |
@ -0,0 +1,243 @@ |
||||
/*
|
||||
* copyright (c) 2005-2012 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 |
||||
* @addtogroup lavu_math |
||||
* Mathematical utilities for working with timestamp and time base. |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_MATHEMATICS_H |
||||
#define AVUTIL_MATHEMATICS_H |
||||
|
||||
#include <stdint.h> |
||||
#include <math.h> |
||||
#include "attributes.h" |
||||
#include "rational.h" |
||||
#include "intfloat.h" |
||||
|
||||
#ifndef M_E |
||||
#define M_E 2.7182818284590452354 /* e */ |
||||
#endif |
||||
#ifndef M_LN2 |
||||
#define M_LN2 0.69314718055994530942 /* log_e 2 */ |
||||
#endif |
||||
#ifndef M_LN10 |
||||
#define M_LN10 2.30258509299404568402 /* log_e 10 */ |
||||
#endif |
||||
#ifndef M_LOG2_10 |
||||
#define M_LOG2_10 3.32192809488736234787 /* log_2 10 */ |
||||
#endif |
||||
#ifndef M_PHI |
||||
#define M_PHI 1.61803398874989484820 /* phi / golden ratio */ |
||||
#endif |
||||
#ifndef M_PI |
||||
#define M_PI 3.14159265358979323846 /* pi */ |
||||
#endif |
||||
#ifndef M_PI_2 |
||||
#define M_PI_2 1.57079632679489661923 /* pi/2 */ |
||||
#endif |
||||
#ifndef M_SQRT1_2 |
||||
#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ |
||||
#endif |
||||
#ifndef M_SQRT2 |
||||
#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ |
||||
#endif |
||||
#ifndef NAN |
||||
#define NAN av_int2float(0x7fc00000) |
||||
#endif |
||||
#ifndef INFINITY |
||||
#define INFINITY av_int2float(0x7f800000) |
||||
#endif |
||||
|
||||
/**
|
||||
* @addtogroup lavu_math |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Rounding methods. |
||||
*/ |
||||
enum AVRounding { |
||||
AV_ROUND_ZERO = 0, ///< Round toward zero.
|
||||
AV_ROUND_INF = 1, ///< Round away from zero.
|
||||
AV_ROUND_DOWN = 2, ///< Round toward -infinity.
|
||||
AV_ROUND_UP = 3, ///< Round toward +infinity.
|
||||
AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero.
|
||||
/**
|
||||
* Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through |
||||
* unchanged, avoiding special cases for #AV_NOPTS_VALUE. |
||||
* |
||||
* Unlike other values of the enumeration AVRounding, this value is a |
||||
* bitmask that must be used in conjunction with another value of the |
||||
* enumeration through a bitwise OR, in order to set behavior for normal |
||||
* cases. |
||||
* |
||||
* @code{.c} |
||||
* av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX); |
||||
* // Rescaling 3:
|
||||
* // Calculating 3 * 1 / 2
|
||||
* // 3 / 2 is rounded up to 2
|
||||
* // => 2
|
||||
* |
||||
* av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX); |
||||
* // Rescaling AV_NOPTS_VALUE:
|
||||
* // AV_NOPTS_VALUE == INT64_MIN
|
||||
* // AV_NOPTS_VALUE is passed through
|
||||
* // => AV_NOPTS_VALUE
|
||||
* @endcode |
||||
*/ |
||||
AV_ROUND_PASS_MINMAX = 8192, |
||||
}; |
||||
|
||||
/**
|
||||
* Compute the greatest common divisor of two integer operands. |
||||
* |
||||
* @param a,b Operands |
||||
* @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0; |
||||
* if a == 0 and b == 0, returns 0. |
||||
*/ |
||||
int64_t av_const av_gcd(int64_t a, int64_t b); |
||||
|
||||
/**
|
||||
* Rescale a 64-bit integer with rounding to nearest. |
||||
* |
||||
* The operation is mathematically equivalent to `a * b / c`, but writing that |
||||
* directly can overflow. |
||||
* |
||||
* This function is equivalent to av_rescale_rnd() with #AV_ROUND_NEAR_INF. |
||||
* |
||||
* @see av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd() |
||||
*/ |
||||
int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const; |
||||
|
||||
/**
|
||||
* Rescale a 64-bit integer with specified rounding. |
||||
* |
||||
* The operation is mathematically equivalent to `a * b / c`, but writing that |
||||
* directly can overflow, and does not support different rounding methods. |
||||
* If the result is not representable then INT64_MIN is returned. |
||||
* |
||||
* @see av_rescale(), av_rescale_q(), av_rescale_q_rnd() |
||||
*/ |
||||
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const; |
||||
|
||||
/**
|
||||
* Rescale a 64-bit integer by 2 rational numbers. |
||||
* |
||||
* The operation is mathematically equivalent to `a * bq / cq`. |
||||
* |
||||
* This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF. |
||||
* |
||||
* @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd() |
||||
*/ |
||||
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const; |
||||
|
||||
/**
|
||||
* Rescale a 64-bit integer by 2 rational numbers with specified rounding. |
||||
* |
||||
* The operation is mathematically equivalent to `a * bq / cq`. |
||||
* |
||||
* @see av_rescale(), av_rescale_rnd(), av_rescale_q() |
||||
*/ |
||||
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, |
||||
enum AVRounding rnd) av_const; |
||||
|
||||
/**
|
||||
* Compare two timestamps each in its own time base. |
||||
* |
||||
* @return One of the following values: |
||||
* - -1 if `ts_a` is before `ts_b` |
||||
* - 1 if `ts_a` is after `ts_b` |
||||
* - 0 if they represent the same position |
||||
* |
||||
* @warning |
||||
* The result of the function is undefined if one of the timestamps is outside |
||||
* the `int64_t` range when represented in the other's timebase. |
||||
*/ |
||||
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b); |
||||
|
||||
/**
|
||||
* Compare the remainders of two integer operands divided by a common divisor. |
||||
* |
||||
* In other words, compare the least significant `log2(mod)` bits of integers |
||||
* `a` and `b`. |
||||
* |
||||
* @code{.c} |
||||
* av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10 (0x1) < 0x02 % 0x10 (0x2)
|
||||
* av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)
|
||||
* @endcode |
||||
* |
||||
* @param a,b Operands |
||||
* @param mod Divisor; must be a power of 2 |
||||
* @return |
||||
* - a negative value if `a % mod < b % mod` |
||||
* - a positive value if `a % mod > b % mod` |
||||
* - zero if `a % mod == b % mod` |
||||
*/ |
||||
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod); |
||||
|
||||
/**
|
||||
* Rescale a timestamp while preserving known durations. |
||||
* |
||||
* This function is designed to be called per audio packet to scale the input |
||||
* timestamp to a different time base. Compared to a simple av_rescale_q() |
||||
* call, this function is robust against possible inconsistent frame durations. |
||||
* |
||||
* The `last` parameter is a state variable that must be preserved for all |
||||
* subsequent calls for the same stream. For the first call, `*last` should be |
||||
* initialized to #AV_NOPTS_VALUE. |
||||
* |
||||
* @param[in] in_tb Input time base |
||||
* @param[in] in_ts Input timestamp |
||||
* @param[in] fs_tb Duration time base; typically this is finer-grained |
||||
* (greater) than `in_tb` and `out_tb` |
||||
* @param[in] duration Duration till the next call to this function (i.e. |
||||
* duration of the current packet/frame) |
||||
* @param[in,out] last Pointer to a timestamp expressed in terms of |
||||
* `fs_tb`, acting as a state variable |
||||
* @param[in] out_tb Output timebase |
||||
* @return Timestamp expressed in terms of `out_tb` |
||||
* |
||||
* @note In the context of this function, "duration" is in term of samples, not |
||||
* seconds. |
||||
*/ |
||||
int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb); |
||||
|
||||
/**
|
||||
* Add a value to a timestamp. |
||||
* |
||||
* This function guarantees that when the same value is repeatly added that |
||||
* no accumulation of rounding errors occurs. |
||||
* |
||||
* @param[in] ts Input timestamp |
||||
* @param[in] ts_tb Input timestamp time base |
||||
* @param[in] inc Value to be added |
||||
* @param[in] inc_tb Time base of `inc` |
||||
*/ |
||||
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc); |
||||
|
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_MATHEMATICS_H */ |
@ -0,0 +1,98 @@ |
||||
/*
|
||||
* 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_md5 |
||||
* Public header for MD5 hash function implementation. |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_MD5_H |
||||
#define AVUTIL_MD5_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_md5 MD5 |
||||
* @ingroup lavu_hash |
||||
* MD5 hash function implementation. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
extern const int av_md5_size; |
||||
|
||||
struct AVMD5; |
||||
|
||||
/**
|
||||
* Allocate an AVMD5 context. |
||||
*/ |
||||
struct AVMD5 *av_md5_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize MD5 hashing. |
||||
* |
||||
* @param ctx pointer to the function context (of size av_md5_size) |
||||
*/ |
||||
void av_md5_init(struct AVMD5 *ctx); |
||||
|
||||
/**
|
||||
* Update hash value. |
||||
* |
||||
* @param ctx hash function context |
||||
* @param src input data to update hash with |
||||
* @param len input data length |
||||
*/ |
||||
#if FF_API_CRYPTO_SIZE_T |
||||
void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len); |
||||
#else |
||||
void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, size_t len); |
||||
#endif |
||||
|
||||
/**
|
||||
* Finish hashing and output digest value. |
||||
* |
||||
* @param ctx hash function context |
||||
* @param dst buffer where output digest value is stored |
||||
*/ |
||||
void av_md5_final(struct AVMD5 *ctx, uint8_t *dst); |
||||
|
||||
/**
|
||||
* Hash an array of data. |
||||
* |
||||
* @param dst The output buffer to write the digest into |
||||
* @param src The data to hash |
||||
* @param len The length of the data, in bytes |
||||
*/ |
||||
#if FF_API_CRYPTO_SIZE_T |
||||
void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len); |
||||
#else |
||||
void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len); |
||||
#endif |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_MD5_H */ |
@ -0,0 +1,706 @@ |
||||
/*
|
||||
* 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_mem |
||||
* Memory handling functions |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_MEM_H |
||||
#define AVUTIL_MEM_H |
||||
|
||||
#include <limits.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "error.h" |
||||
#include "avutil.h" |
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @addtogroup lavu_mem |
||||
* Utilities for manipulating memory. |
||||
* |
||||
* FFmpeg has several applications of memory that are not required of a typical |
||||
* program. For example, the computing-heavy components like video decoding and |
||||
* encoding can be sped up significantly through the use of aligned memory. |
||||
* |
||||
* However, for each of FFmpeg's applications of memory, there might not be a |
||||
* recognized or standardized API for that specific use. Memory alignment, for |
||||
* instance, varies wildly depending on operating systems, architectures, and |
||||
* compilers. Hence, this component of @ref libavutil is created to make |
||||
* dealing with memory consistently possible on all platforms. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
#if FF_API_DECLARE_ALIGNED |
||||
/**
|
||||
* |
||||
* @defgroup lavu_mem_macros Alignment Macros |
||||
* Helper macros for declaring aligned variables. |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @def DECLARE_ALIGNED(n,t,v) |
||||
* Declare a variable that is aligned in memory. |
||||
* |
||||
* @code{.c} |
||||
* DECLARE_ALIGNED(16, uint16_t, aligned_int) = 42; |
||||
* DECLARE_ALIGNED(32, uint8_t, aligned_array)[128]; |
||||
* |
||||
* // The default-alignment equivalent would be
|
||||
* uint16_t aligned_int = 42; |
||||
* uint8_t aligned_array[128]; |
||||
* @endcode |
||||
* |
||||
* @param n Minimum alignment in bytes |
||||
* @param t Type of the variable (or array element) |
||||
* @param v Name of the variable |
||||
*/ |
||||
|
||||
/**
|
||||
* @def DECLARE_ASM_ALIGNED(n,t,v) |
||||
* Declare an aligned variable appropriate for use in inline assembly code. |
||||
* |
||||
* @code{.c} |
||||
* DECLARE_ASM_ALIGNED(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008); |
||||
* @endcode |
||||
* |
||||
* @param n Minimum alignment in bytes |
||||
* @param t Type of the variable (or array element) |
||||
* @param v Name of the variable |
||||
*/ |
||||
|
||||
/**
|
||||
* @def DECLARE_ASM_CONST(n,t,v) |
||||
* Declare a static constant aligned variable appropriate for use in inline |
||||
* assembly code. |
||||
* |
||||
* @code{.c} |
||||
* DECLARE_ASM_CONST(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008); |
||||
* @endcode |
||||
* |
||||
* @param n Minimum alignment in bytes |
||||
* @param t Type of the variable (or array element) |
||||
* @param v Name of the variable |
||||
*/ |
||||
|
||||
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C) |
||||
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v |
||||
#define DECLARE_ASM_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v |
||||
#define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v |
||||
#elif defined(__DJGPP__) |
||||
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (FFMIN(n, 16)))) v |
||||
#define DECLARE_ASM_ALIGNED(n,t,v) t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v |
||||
#define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v |
||||
#elif defined(__GNUC__) || defined(__clang__) |
||||
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v |
||||
#define DECLARE_ASM_ALIGNED(n,t,v) t av_used __attribute__ ((aligned (n))) v |
||||
#define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v |
||||
#elif defined(_MSC_VER) |
||||
#define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v |
||||
#define DECLARE_ASM_ALIGNED(n,t,v) __declspec(align(n)) t v |
||||
#define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v |
||||
#else |
||||
#define DECLARE_ALIGNED(n,t,v) t v |
||||
#define DECLARE_ASM_ALIGNED(n,t,v) t v |
||||
#define DECLARE_ASM_CONST(n,t,v) static const t v |
||||
#endif |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
#endif |
||||
|
||||
/**
|
||||
* @defgroup lavu_mem_attrs Function Attributes |
||||
* Function attributes applicable to memory handling functions. |
||||
* |
||||
* These function attributes can help compilers emit more useful warnings, or |
||||
* generate better code. |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* @def av_malloc_attrib |
||||
* Function attribute denoting a malloc-like function. |
||||
* |
||||
* @see <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007bmalloc_007d-function-attribute-3251">Function attribute `malloc` in GCC's documentation</a> |
||||
*/ |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(3,1) |
||||
#define av_malloc_attrib __attribute__((__malloc__)) |
||||
#else |
||||
#define av_malloc_attrib |
||||
#endif |
||||
|
||||
/**
|
||||
* @def av_alloc_size(...) |
||||
* Function attribute used on a function that allocates memory, whose size is |
||||
* given by the specified parameter(s). |
||||
* |
||||
* @code{.c} |
||||
* void *av_malloc(size_t size) av_alloc_size(1); |
||||
* void *av_calloc(size_t nmemb, size_t size) av_alloc_size(1, 2); |
||||
* @endcode |
||||
* |
||||
* @param ... One or two parameter indexes, separated by a comma |
||||
* |
||||
* @see <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007balloc_005fsize_007d-function-attribute-3220">Function attribute `alloc_size` in GCC's documentation</a> |
||||
*/ |
||||
|
||||
#if AV_GCC_VERSION_AT_LEAST(4,3) |
||||
#define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__))) |
||||
#else |
||||
#define av_alloc_size(...) |
||||
#endif |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavu_mem_funcs Heap Management |
||||
* Functions responsible for allocating, freeing, and copying memory. |
||||
* |
||||
* All memory allocation functions have a built-in upper limit of `INT_MAX` |
||||
* bytes. This may be changed with av_max_alloc(), although exercise extreme |
||||
* caution when doing so. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Allocate a memory block with alignment suitable for all memory accesses |
||||
* (including vectors if available on the CPU). |
||||
* |
||||
* @param size Size in bytes for the memory block to be allocated |
||||
* @return Pointer to the allocated block, or `NULL` if the block cannot |
||||
* be allocated |
||||
* @see av_mallocz() |
||||
*/ |
||||
void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1); |
||||
|
||||
/**
|
||||
* Allocate a memory block with alignment suitable for all memory accesses |
||||
* (including vectors if available on the CPU) and zero all the bytes of the |
||||
* block. |
||||
* |
||||
* @param size Size in bytes for the memory block to be allocated |
||||
* @return Pointer to the allocated block, or `NULL` if it cannot be allocated |
||||
* @see av_malloc() |
||||
*/ |
||||
void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1); |
||||
|
||||
/**
|
||||
* Allocate a memory block for an array with av_malloc(). |
||||
* |
||||
* The allocated memory will have size `size * nmemb` bytes. |
||||
* |
||||
* @param nmemb Number of element |
||||
* @param size Size of a single element |
||||
* @return Pointer to the allocated block, or `NULL` if the block cannot |
||||
* be allocated |
||||
* @see av_malloc() |
||||
*/ |
||||
av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size); |
||||
|
||||
/**
|
||||
* Allocate a memory block for an array with av_mallocz(). |
||||
* |
||||
* The allocated memory will have size `size * nmemb` bytes. |
||||
* |
||||
* @param nmemb Number of elements |
||||
* @param size Size of the single element |
||||
* @return Pointer to the allocated block, or `NULL` if the block cannot |
||||
* be allocated |
||||
* |
||||
* @see av_mallocz() |
||||
* @see av_malloc_array() |
||||
*/ |
||||
av_alloc_size(1, 2) void *av_mallocz_array(size_t nmemb, size_t size); |
||||
|
||||
/**
|
||||
* Non-inlined equivalent of av_mallocz_array(). |
||||
* |
||||
* Created for symmetry with the calloc() C function. |
||||
*/ |
||||
void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib; |
||||
|
||||
/**
|
||||
* Allocate, reallocate, or free a block of memory. |
||||
* |
||||
* If `ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is |
||||
* zero, free the memory block pointed to by `ptr`. Otherwise, expand or |
||||
* shrink that block of memory according to `size`. |
||||
* |
||||
* @param ptr Pointer to a memory block already allocated with |
||||
* av_realloc() or `NULL` |
||||
* @param size Size in bytes of the memory block to be allocated or |
||||
* reallocated |
||||
* |
||||
* @return Pointer to a newly-reallocated block or `NULL` if the block |
||||
* cannot be reallocated or the function is used to free the memory block |
||||
* |
||||
* @warning Unlike av_malloc(), the returned pointer is not guaranteed to be |
||||
* correctly aligned. |
||||
* @see av_fast_realloc() |
||||
* @see av_reallocp() |
||||
*/ |
||||
void *av_realloc(void *ptr, size_t size) av_alloc_size(2); |
||||
|
||||
/**
|
||||
* Allocate, reallocate, or free a block of memory through a pointer to a |
||||
* pointer. |
||||
* |
||||
* If `*ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is |
||||
* zero, free the memory block pointed to by `*ptr`. Otherwise, expand or |
||||
* shrink that block of memory according to `size`. |
||||
* |
||||
* @param[in,out] ptr Pointer to a pointer to a memory block already allocated |
||||
* with av_realloc(), or a pointer to `NULL`. The pointer |
||||
* is updated on success, or freed on failure. |
||||
* @param[in] size Size in bytes for the memory block to be allocated or |
||||
* reallocated |
||||
* |
||||
* @return Zero on success, an AVERROR error code on failure |
||||
* |
||||
* @warning Unlike av_malloc(), the allocated memory is not guaranteed to be |
||||
* correctly aligned. |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_reallocp(void *ptr, size_t size); |
||||
|
||||
/**
|
||||
* Allocate, reallocate, or free a block of memory. |
||||
* |
||||
* This function does the same thing as av_realloc(), except: |
||||
* - It takes two size arguments and allocates `nelem * elsize` bytes, |
||||
* after checking the result of the multiplication for integer overflow. |
||||
* - It frees the input block in case of failure, thus avoiding the memory |
||||
* leak with the classic |
||||
* @code{.c} |
||||
* buf = realloc(buf); |
||||
* if (!buf) |
||||
* return -1; |
||||
* @endcode |
||||
* pattern. |
||||
*/ |
||||
void *av_realloc_f(void *ptr, size_t nelem, size_t elsize); |
||||
|
||||
/**
|
||||
* Allocate, reallocate, or free an array. |
||||
* |
||||
* If `ptr` is `NULL` and `nmemb` > 0, allocate a new block. If |
||||
* `nmemb` is zero, free the memory block pointed to by `ptr`. |
||||
* |
||||
* @param ptr Pointer to a memory block already allocated with |
||||
* av_realloc() or `NULL` |
||||
* @param nmemb Number of elements in the array |
||||
* @param size Size of the single element of the array |
||||
* |
||||
* @return Pointer to a newly-reallocated block or NULL if the block |
||||
* cannot be reallocated or the function is used to free the memory block |
||||
* |
||||
* @warning Unlike av_malloc(), the allocated memory is not guaranteed to be |
||||
* correctly aligned. |
||||
* @see av_reallocp_array() |
||||
*/ |
||||
av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size); |
||||
|
||||
/**
|
||||
* Allocate, reallocate, or free an array through a pointer to a pointer. |
||||
* |
||||
* If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block. If `nmemb` is |
||||
* zero, free the memory block pointed to by `*ptr`. |
||||
* |
||||
* @param[in,out] ptr Pointer to a pointer to a memory block already |
||||
* allocated with av_realloc(), or a pointer to `NULL`. |
||||
* The pointer is updated on success, or freed on failure. |
||||
* @param[in] nmemb Number of elements |
||||
* @param[in] size Size of the single element |
||||
* |
||||
* @return Zero on success, an AVERROR error code on failure |
||||
* |
||||
* @warning Unlike av_malloc(), the allocated memory is not guaranteed to be |
||||
* correctly aligned. |
||||
*/ |
||||
int av_reallocp_array(void *ptr, size_t nmemb, size_t size); |
||||
|
||||
/**
|
||||
* Reallocate the given buffer if it is not large enough, otherwise do nothing. |
||||
* |
||||
* If the given buffer is `NULL`, then a new uninitialized buffer is allocated. |
||||
* |
||||
* If the given buffer is not large enough, and reallocation fails, `NULL` is |
||||
* returned and `*size` is set to 0, but the original buffer is not changed or |
||||
* freed. |
||||
* |
||||
* A typical use pattern follows: |
||||
* |
||||
* @code{.c} |
||||
* uint8_t *buf = ...; |
||||
* uint8_t *new_buf = av_fast_realloc(buf, ¤t_size, size_needed); |
||||
* if (!new_buf) { |
||||
* // Allocation failed; clean up original buffer
|
||||
* av_freep(&buf); |
||||
* return AVERROR(ENOMEM); |
||||
* } |
||||
* @endcode |
||||
* |
||||
* @param[in,out] ptr Already allocated buffer, or `NULL` |
||||
* @param[in,out] size Pointer to the size of buffer `ptr`. `*size` is |
||||
* updated to the new allocated size, in particular 0 |
||||
* in case of failure. |
||||
* @param[in] min_size Desired minimal size of buffer `ptr` |
||||
* @return `ptr` if the buffer is large enough, a pointer to newly reallocated |
||||
* buffer if the buffer was not large enough, or `NULL` in case of |
||||
* error |
||||
* @see av_realloc() |
||||
* @see av_fast_malloc() |
||||
*/ |
||||
void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size); |
||||
|
||||
/**
|
||||
* Allocate a buffer, reusing the given one if large enough. |
||||
* |
||||
* Contrary to av_fast_realloc(), the current buffer contents might not be |
||||
* preserved and on error the old buffer is freed, thus no special handling to |
||||
* avoid memleaks is necessary. |
||||
* |
||||
* `*ptr` is allowed to be `NULL`, in which case allocation always happens if |
||||
* `size_needed` is greater than 0. |
||||
* |
||||
* @code{.c} |
||||
* uint8_t *buf = ...; |
||||
* av_fast_malloc(&buf, ¤t_size, size_needed); |
||||
* if (!buf) { |
||||
* // Allocation failed; buf already freed
|
||||
* return AVERROR(ENOMEM); |
||||
* } |
||||
* @endcode |
||||
* |
||||
* @param[in,out] ptr Pointer to pointer to an already allocated buffer. |
||||
* `*ptr` will be overwritten with pointer to new |
||||
* buffer on success or `NULL` on failure |
||||
* @param[in,out] size Pointer to the size of buffer `*ptr`. `*size` is |
||||
* updated to the new allocated size, in particular 0 |
||||
* in case of failure. |
||||
* @param[in] min_size Desired minimal size of buffer `*ptr` |
||||
* @see av_realloc() |
||||
* @see av_fast_mallocz() |
||||
*/ |
||||
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size); |
||||
|
||||
/**
|
||||
* Allocate and clear a buffer, reusing the given one if large enough. |
||||
* |
||||
* Like av_fast_malloc(), but all newly allocated space is initially cleared. |
||||
* Reused buffer is not cleared. |
||||
* |
||||
* `*ptr` is allowed to be `NULL`, in which case allocation always happens if |
||||
* `size_needed` is greater than 0. |
||||
* |
||||
* @param[in,out] ptr Pointer to pointer to an already allocated buffer. |
||||
* `*ptr` will be overwritten with pointer to new |
||||
* buffer on success or `NULL` on failure |
||||
* @param[in,out] size Pointer to the size of buffer `*ptr`. `*size` is |
||||
* updated to the new allocated size, in particular 0 |
||||
* in case of failure. |
||||
* @param[in] min_size Desired minimal size of buffer `*ptr` |
||||
* @see av_fast_malloc() |
||||
*/ |
||||
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size); |
||||
|
||||
/**
|
||||
* Free a memory block which has been allocated with a function of av_malloc() |
||||
* or av_realloc() family. |
||||
* |
||||
* @param ptr Pointer to the memory block which should be freed. |
||||
* |
||||
* @note `ptr = NULL` is explicitly allowed. |
||||
* @note It is recommended that you use av_freep() instead, to prevent leaving |
||||
* behind dangling pointers. |
||||
* @see av_freep() |
||||
*/ |
||||
void av_free(void *ptr); |
||||
|
||||
/**
|
||||
* Free a memory block which has been allocated with a function of av_malloc() |
||||
* or av_realloc() family, and set the pointer pointing to it to `NULL`. |
||||
* |
||||
* @code{.c} |
||||
* uint8_t *buf = av_malloc(16); |
||||
* av_free(buf); |
||||
* // buf now contains a dangling pointer to freed memory, and accidental
|
||||
* // dereference of buf will result in a use-after-free, which may be a
|
||||
* // security risk.
|
||||
* |
||||
* uint8_t *buf = av_malloc(16); |
||||
* av_freep(&buf); |
||||
* // buf is now NULL, and accidental dereference will only result in a
|
||||
* // NULL-pointer dereference.
|
||||
* @endcode |
||||
* |
||||
* @param ptr Pointer to the pointer to the memory block which should be freed |
||||
* @note `*ptr = NULL` is safe and leads to no action. |
||||
* @see av_free() |
||||
*/ |
||||
void av_freep(void *ptr); |
||||
|
||||
/**
|
||||
* Duplicate a string. |
||||
* |
||||
* @param s String to be duplicated |
||||
* @return Pointer to a newly-allocated string containing a |
||||
* copy of `s` or `NULL` if the string cannot be allocated |
||||
* @see av_strndup() |
||||
*/ |
||||
char *av_strdup(const char *s) av_malloc_attrib; |
||||
|
||||
/**
|
||||
* Duplicate a substring of a string. |
||||
* |
||||
* @param s String to be duplicated |
||||
* @param len Maximum length of the resulting string (not counting the |
||||
* terminating byte) |
||||
* @return Pointer to a newly-allocated string containing a |
||||
* substring of `s` or `NULL` if the string cannot be allocated |
||||
*/ |
||||
char *av_strndup(const char *s, size_t len) av_malloc_attrib; |
||||
|
||||
/**
|
||||
* Duplicate a buffer with av_malloc(). |
||||
* |
||||
* @param p Buffer to be duplicated |
||||
* @param size Size in bytes of the buffer copied |
||||
* @return Pointer to a newly allocated buffer containing a |
||||
* copy of `p` or `NULL` if the buffer cannot be allocated |
||||
*/ |
||||
void *av_memdup(const void *p, size_t size); |
||||
|
||||
/**
|
||||
* Overlapping memcpy() implementation. |
||||
* |
||||
* @param dst Destination buffer |
||||
* @param back Number of bytes back to start copying (i.e. the initial size of |
||||
* the overlapping window); must be > 0 |
||||
* @param cnt Number of bytes to copy; must be >= 0 |
||||
* |
||||
* @note `cnt > back` is valid, this will copy the bytes we just copied, |
||||
* thus creating a repeating pattern with a period length of `back`. |
||||
*/ |
||||
void av_memcpy_backptr(uint8_t *dst, int back, int cnt); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavu_mem_dynarray Dynamic Array |
||||
* |
||||
* Utilities to make an array grow when needed. |
||||
* |
||||
* Sometimes, the programmer would want to have an array that can grow when |
||||
* needed. The libavutil dynamic array utilities fill that need. |
||||
* |
||||
* libavutil supports two systems of appending elements onto a dynamically |
||||
* allocated array, the first one storing the pointer to the value in the |
||||
* array, and the second storing the value directly. In both systems, the |
||||
* caller is responsible for maintaining a variable containing the length of |
||||
* the array, as well as freeing of the array after use. |
||||
* |
||||
* The first system stores pointers to values in a block of dynamically |
||||
* allocated memory. Since only pointers are stored, the function does not need |
||||
* to know the size of the type. Both av_dynarray_add() and |
||||
* av_dynarray_add_nofree() implement this system. |
||||
* |
||||
* @code |
||||
* type **array = NULL; //< an array of pointers to values
|
||||
* int nb = 0; //< a variable to keep track of the length of the array
|
||||
* |
||||
* type to_be_added = ...; |
||||
* type to_be_added2 = ...; |
||||
* |
||||
* av_dynarray_add(&array, &nb, &to_be_added); |
||||
* if (nb == 0) |
||||
* return AVERROR(ENOMEM); |
||||
* |
||||
* av_dynarray_add(&array, &nb, &to_be_added2); |
||||
* if (nb == 0) |
||||
* return AVERROR(ENOMEM); |
||||
* |
||||
* // Now:
|
||||
* // nb == 2
|
||||
* // &to_be_added == array[0]
|
||||
* // &to_be_added2 == array[1]
|
||||
* |
||||
* av_freep(&array); |
||||
* @endcode |
||||
* |
||||
* The second system stores the value directly in a block of memory. As a |
||||
* result, the function has to know the size of the type. av_dynarray2_add() |
||||
* implements this mechanism. |
||||
* |
||||
* @code |
||||
* type *array = NULL; //< an array of values
|
||||
* int nb = 0; //< a variable to keep track of the length of the array
|
||||
* |
||||
* type to_be_added = ...; |
||||
* type to_be_added2 = ...; |
||||
* |
||||
* type *addr = av_dynarray2_add((void **)&array, &nb, sizeof(*array), NULL); |
||||
* if (!addr) |
||||
* return AVERROR(ENOMEM); |
||||
* memcpy(addr, &to_be_added, sizeof(to_be_added)); |
||||
* |
||||
* // Shortcut of the above.
|
||||
* type *addr = av_dynarray2_add((void **)&array, &nb, sizeof(*array), |
||||
* (const void *)&to_be_added2); |
||||
* if (!addr) |
||||
* return AVERROR(ENOMEM); |
||||
* |
||||
* // Now:
|
||||
* // nb == 2
|
||||
* // to_be_added == array[0]
|
||||
* // to_be_added2 == array[1]
|
||||
* |
||||
* av_freep(&array); |
||||
* @endcode |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Add the pointer to an element to a dynamic array. |
||||
* |
||||
* The array to grow is supposed to be an array of pointers to |
||||
* structures, and the element to add must be a pointer to an already |
||||
* allocated structure. |
||||
* |
||||
* The array is reallocated when its size reaches powers of 2. |
||||
* Therefore, the amortized cost of adding an element is constant. |
||||
* |
||||
* In case of success, the pointer to the array is updated in order to |
||||
* point to the new grown array, and the number pointed to by `nb_ptr` |
||||
* is incremented. |
||||
* In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and |
||||
* `*nb_ptr` is set to 0. |
||||
* |
||||
* @param[in,out] tab_ptr Pointer to the array to grow |
||||
* @param[in,out] nb_ptr Pointer to the number of elements in the array |
||||
* @param[in] elem Element to add |
||||
* @see av_dynarray_add_nofree(), av_dynarray2_add() |
||||
*/ |
||||
void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem); |
||||
|
||||
/**
|
||||
* Add an element to a dynamic array. |
||||
* |
||||
* Function has the same functionality as av_dynarray_add(), |
||||
* but it doesn't free memory on fails. It returns error code |
||||
* instead and leave current buffer untouched. |
||||
* |
||||
* @return >=0 on success, negative otherwise |
||||
* @see av_dynarray_add(), av_dynarray2_add() |
||||
*/ |
||||
av_warn_unused_result |
||||
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem); |
||||
|
||||
/**
|
||||
* Add an element of size `elem_size` to a dynamic array. |
||||
* |
||||
* The array is reallocated when its number of elements reaches powers of 2. |
||||
* Therefore, the amortized cost of adding an element is constant. |
||||
* |
||||
* In case of success, the pointer to the array is updated in order to |
||||
* point to the new grown array, and the number pointed to by `nb_ptr` |
||||
* is incremented. |
||||
* In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and |
||||
* `*nb_ptr` is set to 0. |
||||
* |
||||
* @param[in,out] tab_ptr Pointer to the array to grow |
||||
* @param[in,out] nb_ptr Pointer to the number of elements in the array |
||||
* @param[in] elem_size Size in bytes of an element in the array |
||||
* @param[in] elem_data Pointer to the data of the element to add. If |
||||
* `NULL`, the space of the newly added element is |
||||
* allocated but left uninitialized. |
||||
* |
||||
* @return Pointer to the data of the element to copy in the newly allocated |
||||
* space |
||||
* @see av_dynarray_add(), av_dynarray_add_nofree() |
||||
*/ |
||||
void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size, |
||||
const uint8_t *elem_data); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup lavu_mem_misc Miscellaneous Functions |
||||
* |
||||
* Other functions related to memory allocation. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Multiply two `size_t` values checking for overflow. |
||||
* |
||||
* @param[in] a,b Operands of multiplication |
||||
* @param[out] r Pointer to the result of the operation |
||||
* @return 0 on success, AVERROR(EINVAL) on overflow |
||||
*/ |
||||
static inline int av_size_mult(size_t a, size_t b, size_t *r) |
||||
{ |
||||
size_t t = a * b; |
||||
/* Hack inspired from glibc: don't try the division if nelem and elsize
|
||||
* are both less than sqrt(SIZE_MAX). */ |
||||
if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b) |
||||
return AVERROR(EINVAL); |
||||
*r = t; |
||||
return 0; |
||||
} |
||||
|
||||
/**
|
||||
* Set the maximum size that may be allocated in one block. |
||||
* |
||||
* The value specified with this function is effective for all libavutil's @ref |
||||
* lavu_mem_funcs "heap management functions." |
||||
* |
||||
* By default, the max value is defined as `INT_MAX`. |
||||
* |
||||
* @param max Value to be set as the new maximum size |
||||
* |
||||
* @warning Exercise extreme caution when using this function. Don't touch |
||||
* this if you do not understand the full consequence of doing so. |
||||
*/ |
||||
void av_max_alloc(size_t max); |
||||
|
||||
/**
|
||||
* @} |
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_MEM_H */ |
@ -0,0 +1,57 @@ |
||||
/*
|
||||
* 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_MOTION_VECTOR_H |
||||
#define AVUTIL_MOTION_VECTOR_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
typedef struct AVMotionVector { |
||||
/**
|
||||
* Where the current macroblock comes from; negative value when it comes |
||||
* from the past, positive value when it comes from the future. |
||||
* XXX: set exact relative ref frame reference instead of a +/- 1 "direction". |
||||
*/ |
||||
int32_t source; |
||||
/**
|
||||
* Width and height of the block. |
||||
*/ |
||||
uint8_t w, h; |
||||
/**
|
||||
* Absolute source position. Can be outside the frame area. |
||||
*/ |
||||
int16_t src_x, src_y; |
||||
/**
|
||||
* Absolute destination position. Can be outside the frame area. |
||||
*/ |
||||
int16_t dst_x, dst_y; |
||||
/**
|
||||
* Extra flag information. |
||||
* Currently unused. |
||||
*/ |
||||
uint64_t flags; |
||||
/**
|
||||
* Motion vector |
||||
* src_x = dst_x + motion_x / motion_scale |
||||
* src_y = dst_y + motion_y / motion_scale |
||||
*/ |
||||
int32_t motion_x, motion_y; |
||||
uint16_t motion_scale; |
||||
} AVMotionVector; |
||||
|
||||
#endif /* AVUTIL_MOTION_VECTOR_H */ |
@ -0,0 +1,121 @@ |
||||
/*
|
||||
* Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de> |
||||
* |
||||
* 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_murmur3 |
||||
* Public header for MurmurHash3 hash function implementation. |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_MURMUR3_H |
||||
#define AVUTIL_MURMUR3_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_murmur3 Murmur3 |
||||
* @ingroup lavu_hash |
||||
* MurmurHash3 hash function implementation. |
||||
* |
||||
* MurmurHash3 is a non-cryptographic hash function, of which three |
||||
* incompatible versions were created by its inventor Austin Appleby: |
||||
* |
||||
* - 32-bit output |
||||
* - 128-bit output for 32-bit platforms |
||||
* - 128-bit output for 64-bit platforms |
||||
* |
||||
* FFmpeg only implements the last variant: 128-bit output designed for 64-bit |
||||
* platforms. Even though the hash function was designed for 64-bit platforms, |
||||
* the function in reality works on 32-bit systems too, only with reduced |
||||
* performance. |
||||
* |
||||
* @anchor lavu_murmur3_seedinfo |
||||
* By design, MurmurHash3 requires a seed to operate. In response to this, |
||||
* libavutil provides two functions for hash initiation, one that requires a |
||||
* seed (av_murmur3_init_seeded()) and one that uses a fixed arbitrary integer |
||||
* as the seed, and therefore does not (av_murmur3_init()). |
||||
* |
||||
* To make hashes comparable, you should provide the same seed for all calls to |
||||
* this hash function -- if you are supplying one yourself, that is. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Allocate an AVMurMur3 hash context. |
||||
* |
||||
* @return Uninitialized hash context or `NULL` in case of error |
||||
*/ |
||||
struct AVMurMur3 *av_murmur3_alloc(void); |
||||
|
||||
/**
|
||||
* Initialize or reinitialize an AVMurMur3 hash context with a seed. |
||||
* |
||||
* @param[out] c Hash context |
||||
* @param[in] seed Random seed |
||||
* |
||||
* @see av_murmur3_init() |
||||
* @see @ref lavu_murmur3_seedinfo "Detailed description" on a discussion of |
||||
* seeds for MurmurHash3. |
||||
*/ |
||||
void av_murmur3_init_seeded(struct AVMurMur3 *c, uint64_t seed); |
||||
|
||||
/**
|
||||
* Initialize or reinitialize an AVMurMur3 hash context. |
||||
* |
||||
* Equivalent to av_murmur3_init_seeded() with a built-in seed. |
||||
* |
||||
* @param[out] c Hash context |
||||
* |
||||
* @see av_murmur3_init_seeded() |
||||
* @see @ref lavu_murmur3_seedinfo "Detailed description" on a discussion of |
||||
* seeds for MurmurHash3. |
||||
*/ |
||||
void av_murmur3_init(struct AVMurMur3 *c); |
||||
|
||||
/**
|
||||
* Update hash context with new data. |
||||
* |
||||
* @param[out] c Hash context |
||||
* @param[in] src Input data to update hash with |
||||
* @param[in] len Number of bytes to read from `src` |
||||
*/ |
||||
#if FF_API_CRYPTO_SIZE_T |
||||
void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len); |
||||
#else |
||||
void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, size_t len); |
||||
#endif |
||||
|
||||
/**
|
||||
* Finish hashing and output digest value. |
||||
* |
||||
* @param[in,out] c Hash context |
||||
* @param[out] dst Buffer where output digest value is stored |
||||
*/ |
||||
void av_murmur3_final(struct AVMurMur3 *c, uint8_t dst[16]); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_MURMUR3_H */ |
@ -0,0 +1,886 @@ |
||||
/*
|
||||
* AVOptions |
||||
* copyright (c) 2005 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_OPT_H |
||||
#define AVUTIL_OPT_H |
||||
|
||||
/**
|
||||
* @file |
||||
* AVOptions |
||||
*/ |
||||
|
||||
#include "rational.h" |
||||
#include "avutil.h" |
||||
#include "dict.h" |
||||
#include "log.h" |
||||
#include "pixfmt.h" |
||||
#include "samplefmt.h" |
||||
#include "version.h" |
||||
|
||||
/**
|
||||
* @defgroup avoptions AVOptions |
||||
* @ingroup lavu_data |
||||
* @{ |
||||
* AVOptions provide a generic system to declare options on arbitrary structs |
||||
* ("objects"). An option can have a help text, a type and a range of possible |
||||
* values. Options may then be enumerated, read and written to. |
||||
* |
||||
* @section avoptions_implement Implementing AVOptions |
||||
* This section describes how to add AVOptions capabilities to a struct. |
||||
* |
||||
* All AVOptions-related information is stored in an AVClass. Therefore |
||||
* the first member of the struct should be a pointer to an AVClass describing it. |
||||
* The option field of the AVClass must be set to a NULL-terminated static array |
||||
* of AVOptions. Each AVOption must have a non-empty name, a type, a default |
||||
* value and for number-type AVOptions also a range of allowed values. It must |
||||
* also declare an offset in bytes from the start of the struct, where the field |
||||
* associated with this AVOption is located. Other fields in the AVOption struct |
||||
* should also be set when applicable, but are not required. |
||||
* |
||||
* The following example illustrates an AVOptions-enabled struct: |
||||
* @code |
||||
* typedef struct test_struct { |
||||
* const AVClass *class; |
||||
* int int_opt; |
||||
* char *str_opt; |
||||
* uint8_t *bin_opt; |
||||
* int bin_len; |
||||
* } test_struct; |
||||
* |
||||
* static const AVOption test_options[] = { |
||||
* { "test_int", "This is a test option of int type.", offsetof(test_struct, int_opt), |
||||
* AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX }, |
||||
* { "test_str", "This is a test option of string type.", offsetof(test_struct, str_opt), |
||||
* AV_OPT_TYPE_STRING }, |
||||
* { "test_bin", "This is a test option of binary type.", offsetof(test_struct, bin_opt), |
||||
* AV_OPT_TYPE_BINARY }, |
||||
* { NULL }, |
||||
* }; |
||||
* |
||||
* static const AVClass test_class = { |
||||
* .class_name = "test class", |
||||
* .item_name = av_default_item_name, |
||||
* .option = test_options, |
||||
* .version = LIBAVUTIL_VERSION_INT, |
||||
* }; |
||||
* @endcode |
||||
* |
||||
* Next, when allocating your struct, you must ensure that the AVClass pointer |
||||
* is set to the correct value. Then, av_opt_set_defaults() can be called to |
||||
* initialize defaults. After that the struct is ready to be used with the |
||||
* AVOptions API. |
||||
* |
||||
* When cleaning up, you may use the av_opt_free() function to automatically |
||||
* free all the allocated string and binary options. |
||||
* |
||||
* Continuing with the above example: |
||||
* |
||||
* @code |
||||
* test_struct *alloc_test_struct(void) |
||||
* { |
||||
* test_struct *ret = av_mallocz(sizeof(*ret)); |
||||
* ret->class = &test_class; |
||||
* av_opt_set_defaults(ret); |
||||
* return ret; |
||||
* } |
||||
* void free_test_struct(test_struct **foo) |
||||
* { |
||||
* av_opt_free(*foo); |
||||
* av_freep(foo); |
||||
* } |
||||
* @endcode |
||||
* |
||||
* @subsection avoptions_implement_nesting Nesting |
||||
* It may happen that an AVOptions-enabled struct contains another |
||||
* AVOptions-enabled struct as a member (e.g. AVCodecContext in |
||||
* libavcodec exports generic options, while its priv_data field exports |
||||
* codec-specific options). In such a case, it is possible to set up the |
||||
* parent struct to export a child's options. To do that, simply |
||||
* implement AVClass.child_next() and AVClass.child_class_iterate() in the |
||||
* parent struct's AVClass. |
||||
* Assuming that the test_struct from above now also contains a |
||||
* child_struct field: |
||||
* |
||||
* @code |
||||
* typedef struct child_struct { |
||||
* AVClass *class; |
||||
* int flags_opt; |
||||
* } child_struct; |
||||
* static const AVOption child_opts[] = { |
||||
* { "test_flags", "This is a test option of flags type.", |
||||
* offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX }, |
||||
* { NULL }, |
||||
* }; |
||||
* static const AVClass child_class = { |
||||
* .class_name = "child class", |
||||
* .item_name = av_default_item_name, |
||||
* .option = child_opts, |
||||
* .version = LIBAVUTIL_VERSION_INT, |
||||
* }; |
||||
* |
||||
* void *child_next(void *obj, void *prev) |
||||
* { |
||||
* test_struct *t = obj; |
||||
* if (!prev && t->child_struct) |
||||
* return t->child_struct; |
||||
* return NULL |
||||
* } |
||||
* const AVClass child_class_iterate(void **iter) |
||||
* { |
||||
* const AVClass *c = *iter ? NULL : &child_class; |
||||
* *iter = (void*)(uintptr_t)c; |
||||
* return c; |
||||
* } |
||||
* @endcode |
||||
* Putting child_next() and child_class_iterate() as defined above into |
||||
* test_class will now make child_struct's options accessible through |
||||
* test_struct (again, proper setup as described above needs to be done on |
||||
* child_struct right after it is created). |
||||
* |
||||
* From the above example it might not be clear why both child_next() |
||||
* and child_class_iterate() are needed. The distinction is that child_next() |
||||
* iterates over actually existing objects, while child_class_iterate() |
||||
* iterates over all possible child classes. E.g. if an AVCodecContext |
||||
* was initialized to use a codec which has private options, then its |
||||
* child_next() will return AVCodecContext.priv_data and finish |
||||
* iterating. OTOH child_class_iterate() on AVCodecContext.av_class will |
||||
* iterate over all available codecs with private options. |
||||
* |
||||
* @subsection avoptions_implement_named_constants Named constants |
||||
* It is possible to create named constants for options. Simply set the unit |
||||
* field of the option the constants should apply to a string and |
||||
* create the constants themselves as options of type AV_OPT_TYPE_CONST |
||||
* with their unit field set to the same string. |
||||
* Their default_val field should contain the value of the named |
||||
* constant. |
||||
* For example, to add some named constants for the test_flags option |
||||
* above, put the following into the child_opts array: |
||||
* @code |
||||
* { "test_flags", "This is a test option of flags type.", |
||||
* offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, "test_unit" }, |
||||
* { "flag1", "This is a flag with value 16", 0, AV_OPT_TYPE_CONST, { .i64 = 16 }, 0, 0, "test_unit" }, |
||||
* @endcode |
||||
* |
||||
* @section avoptions_use Using AVOptions |
||||
* This section deals with accessing options in an AVOptions-enabled struct. |
||||
* Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or |
||||
* AVFormatContext in libavformat. |
||||
* |
||||
* @subsection avoptions_use_examine Examining AVOptions |
||||
* The basic functions for examining options are av_opt_next(), which iterates |
||||
* over all options defined for one object, and av_opt_find(), which searches |
||||
* for an option with the given name. |
||||
* |
||||
* The situation is more complicated with nesting. An AVOptions-enabled struct |
||||
* may have AVOptions-enabled children. Passing the AV_OPT_SEARCH_CHILDREN flag |
||||
* to av_opt_find() will make the function search children recursively. |
||||
* |
||||
* For enumerating there are basically two cases. The first is when you want to |
||||
* get all options that may potentially exist on the struct and its children |
||||
* (e.g. when constructing documentation). In that case you should call |
||||
* av_opt_child_class_iterate() recursively on the parent struct's AVClass. The |
||||
* second case is when you have an already initialized struct with all its |
||||
* children and you want to get all options that can be actually written or read |
||||
* from it. In that case you should call av_opt_child_next() recursively (and |
||||
* av_opt_next() on each result). |
||||
* |
||||
* @subsection avoptions_use_get_set Reading and writing AVOptions |
||||
* When setting options, you often have a string read directly from the |
||||
* user. In such a case, simply passing it to av_opt_set() is enough. For |
||||
* non-string type options, av_opt_set() will parse the string according to the |
||||
* option type. |
||||
* |
||||
* Similarly av_opt_get() will read any option type and convert it to a string |
||||
* which will be returned. Do not forget that the string is allocated, so you |
||||
* have to free it with av_free(). |
||||
* |
||||
* In some cases it may be more convenient to put all options into an |
||||
* AVDictionary and call av_opt_set_dict() on it. A specific case of this |
||||
* are the format/codec open functions in lavf/lavc which take a dictionary |
||||
* filled with option as a parameter. This makes it possible to set some options |
||||
* that cannot be set otherwise, since e.g. the input file format is not known |
||||
* before the file is actually opened. |
||||
*/ |
||||
|
||||
enum AVOptionType{ |
||||
AV_OPT_TYPE_FLAGS, |
||||
AV_OPT_TYPE_INT, |
||||
AV_OPT_TYPE_INT64, |
||||
AV_OPT_TYPE_DOUBLE, |
||||
AV_OPT_TYPE_FLOAT, |
||||
AV_OPT_TYPE_STRING, |
||||
AV_OPT_TYPE_RATIONAL, |
||||
AV_OPT_TYPE_BINARY, ///< offset must point to a pointer immediately followed by an int for the length
|
||||
AV_OPT_TYPE_DICT, |
||||
AV_OPT_TYPE_UINT64, |
||||
AV_OPT_TYPE_CONST, |
||||
AV_OPT_TYPE_IMAGE_SIZE, ///< offset must point to two consecutive integers
|
||||
AV_OPT_TYPE_PIXEL_FMT, |
||||
AV_OPT_TYPE_SAMPLE_FMT, |
||||
AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational
|
||||
AV_OPT_TYPE_DURATION, |
||||
AV_OPT_TYPE_COLOR, |
||||
AV_OPT_TYPE_CHANNEL_LAYOUT, |
||||
AV_OPT_TYPE_BOOL, |
||||
}; |
||||
|
||||
/**
|
||||
* AVOption |
||||
*/ |
||||
typedef struct AVOption { |
||||
const char *name; |
||||
|
||||
/**
|
||||
* short English help text |
||||
* @todo What about other languages? |
||||
*/ |
||||
const char *help; |
||||
|
||||
/**
|
||||
* The offset relative to the context structure where the option |
||||
* value is stored. It should be 0 for named constants. |
||||
*/ |
||||
int offset; |
||||
enum AVOptionType type; |
||||
|
||||
/**
|
||||
* the default value for scalar options |
||||
*/ |
||||
union { |
||||
int64_t i64; |
||||
double dbl; |
||||
const char *str; |
||||
/* TODO those are unused now */ |
||||
AVRational q; |
||||
} default_val; |
||||
double min; ///< minimum valid value for the option
|
||||
double max; ///< maximum valid value for the option
|
||||
|
||||
int flags; |
||||
#define AV_OPT_FLAG_ENCODING_PARAM 1 ///< a generic parameter which can be set by the user for muxing or encoding
|
||||
#define AV_OPT_FLAG_DECODING_PARAM 2 ///< a generic parameter which can be set by the user for demuxing or decoding
|
||||
#define AV_OPT_FLAG_AUDIO_PARAM 8 |
||||
#define AV_OPT_FLAG_VIDEO_PARAM 16 |
||||
#define AV_OPT_FLAG_SUBTITLE_PARAM 32 |
||||
/**
|
||||
* The option is intended for exporting values to the caller. |
||||
*/ |
||||
#define AV_OPT_FLAG_EXPORT 64 |
||||
/**
|
||||
* The option may not be set through the AVOptions API, only read. |
||||
* This flag only makes sense when AV_OPT_FLAG_EXPORT is also set. |
||||
*/ |
||||
#define AV_OPT_FLAG_READONLY 128 |
||||
#define AV_OPT_FLAG_BSF_PARAM (1<<8) ///< a generic parameter which can be set by the user for bit stream filtering
|
||||
#define AV_OPT_FLAG_RUNTIME_PARAM (1<<15) ///< a generic parameter which can be set by the user at runtime
|
||||
#define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
|
||||
#define AV_OPT_FLAG_DEPRECATED (1<<17) ///< set if option is deprecated, users should refer to AVOption.help text for more information
|
||||
#define AV_OPT_FLAG_CHILD_CONSTS (1<<18) ///< set if option constants can also reside in child objects
|
||||
//FIXME think about enc-audio, ... style flags
|
||||
|
||||
/**
|
||||
* The logical unit to which the option belongs. Non-constant |
||||
* options and corresponding named constants share the same |
||||
* unit. May be NULL. |
||||
*/ |
||||
const char *unit; |
||||
} AVOption; |
||||
|
||||
/**
|
||||
* A single allowed range of values, or a single allowed value. |
||||
*/ |
||||
typedef struct AVOptionRange { |
||||
const char *str; |
||||
/**
|
||||
* Value range. |
||||
* For string ranges this represents the min/max length. |
||||
* For dimensions this represents the min/max pixel count or width/height in multi-component case. |
||||
*/ |
||||
double value_min, value_max; |
||||
/**
|
||||
* Value's component range. |
||||
* For string this represents the unicode range for chars, 0-127 limits to ASCII. |
||||
*/ |
||||
double component_min, component_max; |
||||
/**
|
||||
* Range flag. |
||||
* If set to 1 the struct encodes a range, if set to 0 a single value. |
||||
*/ |
||||
int is_range; |
||||
} AVOptionRange; |
||||
|
||||
/**
|
||||
* List of AVOptionRange structs. |
||||
*/ |
||||
typedef struct AVOptionRanges { |
||||
/**
|
||||
* Array of option ranges. |
||||
* |
||||
* Most of option types use just one component. |
||||
* Following describes multi-component option types: |
||||
* |
||||
* AV_OPT_TYPE_IMAGE_SIZE: |
||||
* component index 0: range of pixel count (width * height). |
||||
* component index 1: range of width. |
||||
* component index 2: range of height. |
||||
* |
||||
* @note To obtain multi-component version of this structure, user must |
||||
* provide AV_OPT_MULTI_COMPONENT_RANGE to av_opt_query_ranges or |
||||
* av_opt_query_ranges_default function. |
||||
* |
||||
* Multi-component range can be read as in following example: |
||||
* |
||||
* @code |
||||
* int range_index, component_index; |
||||
* AVOptionRanges *ranges; |
||||
* AVOptionRange *range[3]; //may require more than 3 in the future.
|
||||
* av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE); |
||||
* for (range_index = 0; range_index < ranges->nb_ranges; range_index++) { |
||||
* for (component_index = 0; component_index < ranges->nb_components; component_index++) |
||||
* range[component_index] = ranges->range[ranges->nb_ranges * component_index + range_index]; |
||||
* //do something with range here.
|
||||
* } |
||||
* av_opt_freep_ranges(&ranges); |
||||
* @endcode |
||||
*/ |
||||
AVOptionRange **range; |
||||
/**
|
||||
* Number of ranges per component. |
||||
*/ |
||||
int nb_ranges; |
||||
/**
|
||||
* Number of componentes. |
||||
*/ |
||||
int nb_components; |
||||
} AVOptionRanges; |
||||
|
||||
/**
|
||||
* Show the obj options. |
||||
* |
||||
* @param req_flags requested flags for the options to show. Show only the |
||||
* options for which it is opt->flags & req_flags. |
||||
* @param rej_flags rejected flags for the options to show. Show only the |
||||
* options for which it is !(opt->flags & req_flags). |
||||
* @param av_log_obj log context to use for showing the options |
||||
*/ |
||||
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags); |
||||
|
||||
/**
|
||||
* Set the values of all AVOption fields to their default values. |
||||
* |
||||
* @param s an AVOption-enabled struct (its first member must be a pointer to AVClass) |
||||
*/ |
||||
void av_opt_set_defaults(void *s); |
||||
|
||||
/**
|
||||
* Set the values of all AVOption fields to their default values. Only these |
||||
* AVOption fields for which (opt->flags & mask) == flags will have their |
||||
* default applied to s. |
||||
* |
||||
* @param s an AVOption-enabled struct (its first member must be a pointer to AVClass) |
||||
* @param mask combination of AV_OPT_FLAG_* |
||||
* @param flags combination of AV_OPT_FLAG_* |
||||
*/ |
||||
void av_opt_set_defaults2(void *s, int mask, int flags); |
||||
|
||||
/**
|
||||
* Parse the key/value pairs list in opts. For each key/value pair |
||||
* found, stores the value in the field in ctx that is named like the |
||||
* key. ctx must be an AVClass context, storing is done using |
||||
* AVOptions. |
||||
* |
||||
* @param opts options string to parse, may be NULL |
||||
* @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 |
||||
* @return the number of successfully set key/value pairs, or a negative |
||||
* value corresponding to an AVERROR code in case of error: |
||||
* AVERROR(EINVAL) if opts cannot be parsed, |
||||
* the error code issued by av_opt_set() if a key/value pair |
||||
* cannot be set |
||||
*/ |
||||
int av_set_options_string(void *ctx, const char *opts, |
||||
const char *key_val_sep, const char *pairs_sep); |
||||
|
||||
/**
|
||||
* Parse the key-value pairs list in opts. For each key=value pair found, |
||||
* set the value of the corresponding option in ctx. |
||||
* |
||||
* @param ctx the AVClass object to set options on |
||||
* @param opts the options string, key-value pairs separated by a |
||||
* delimiter |
||||
* @param shorthand a NULL-terminated array of options names for shorthand |
||||
* notation: if the first field in opts has no key part, |
||||
* the key is taken from the first element of shorthand; |
||||
* then again for the second, etc., until either opts is |
||||
* finished, shorthand is finished or a named option is |
||||
* found; after that, all options must be named |
||||
* @param key_val_sep a 0-terminated list of characters used to separate |
||||
* key from value, for example '=' |
||||
* @param pairs_sep a 0-terminated list of characters used to separate |
||||
* two pairs from each other, for example ':' or ',' |
||||
* @return the number of successfully set key=value pairs, or a negative |
||||
* value corresponding to an AVERROR code in case of error: |
||||
* AVERROR(EINVAL) if opts cannot be parsed, |
||||
* the error code issued by av_set_string3() if a key/value pair |
||||
* cannot be set |
||||
* |
||||
* Options names must use only the following characters: a-z A-Z 0-9 - . / _ |
||||
* Separators must use characters distinct from option names and from each |
||||
* other. |
||||
*/ |
||||
int av_opt_set_from_string(void *ctx, const char *opts, |
||||
const char *const *shorthand, |
||||
const char *key_val_sep, const char *pairs_sep); |
||||
/**
|
||||
* Free all allocated objects in obj. |
||||
*/ |
||||
void av_opt_free(void *obj); |
||||
|
||||
/**
|
||||
* Check whether a particular flag is set in a flags field. |
||||
* |
||||
* @param field_name the name of the flag field option |
||||
* @param flag_name the name of the flag to check |
||||
* @return non-zero if the flag is set, zero if the flag isn't set, |
||||
* isn't of the right type, or the flags field doesn't exist. |
||||
*/ |
||||
int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name); |
||||
|
||||
/**
|
||||
* Set all the options from a given dictionary on an object. |
||||
* |
||||
* @param obj a struct whose first element is a pointer to AVClass |
||||
* @param options options to process. This dictionary will be freed and replaced |
||||
* by a new one containing all options not found in obj. |
||||
* Of course this new dictionary needs to be freed by caller |
||||
* with av_dict_free(). |
||||
* |
||||
* @return 0 on success, a negative AVERROR if some option was found in obj, |
||||
* but could not be set. |
||||
* |
||||
* @see av_dict_copy() |
||||
*/ |
||||
int av_opt_set_dict(void *obj, struct AVDictionary **options); |
||||
|
||||
|
||||
/**
|
||||
* Set all the options from a given dictionary on an object. |
||||
* |
||||
* @param obj a struct whose first element is a pointer to AVClass |
||||
* @param options options to process. This dictionary will be freed and replaced |
||||
* by a new one containing all options not found in obj. |
||||
* Of course this new dictionary needs to be freed by caller |
||||
* with av_dict_free(). |
||||
* @param search_flags A combination of AV_OPT_SEARCH_*. |
||||
* |
||||
* @return 0 on success, a negative AVERROR if some option was found in obj, |
||||
* but could not be set. |
||||
* |
||||
* @see av_dict_copy() |
||||
*/ |
||||
int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags); |
||||
|
||||
/**
|
||||
* Extract a key-value pair from the beginning of a string. |
||||
* |
||||
* @param ropts pointer to the options string, will be updated to |
||||
* point to the rest of the string (one of the pairs_sep |
||||
* or the final NUL) |
||||
* @param key_val_sep a 0-terminated list of characters used to separate |
||||
* key from value, for example '=' |
||||
* @param pairs_sep a 0-terminated list of characters used to separate |
||||
* two pairs from each other, for example ':' or ',' |
||||
* @param flags flags; see the AV_OPT_FLAG_* values below |
||||
* @param rkey parsed key; must be freed using av_free() |
||||
* @param rval parsed value; must be freed using av_free() |
||||
* |
||||
* @return >=0 for success, or a negative value corresponding to an |
||||
* AVERROR code in case of error; in particular: |
||||
* AVERROR(EINVAL) if no key is present |
||||
* |
||||
*/ |
||||
int av_opt_get_key_value(const char **ropts, |
||||
const char *key_val_sep, const char *pairs_sep, |
||||
unsigned flags, |
||||
char **rkey, char **rval); |
||||
|
||||
enum { |
||||
|
||||
/**
|
||||
* Accept to parse a value without a key; the key will then be returned |
||||
* as NULL. |
||||
*/ |
||||
AV_OPT_FLAG_IMPLICIT_KEY = 1, |
||||
}; |
||||
|
||||
/**
|
||||
* @defgroup opt_eval_funcs Evaluating option strings |
||||
* @{ |
||||
* This group of functions can be used to evaluate option strings |
||||
* and get numbers out of them. They do the same thing as av_opt_set(), |
||||
* except the result is written into the caller-supplied pointer. |
||||
* |
||||
* @param obj a struct whose first element is a pointer to AVClass. |
||||
* @param o an option for which the string is to be evaluated. |
||||
* @param val string to be evaluated. |
||||
* @param *_out value of the string will be written here. |
||||
* |
||||
* @return 0 on success, a negative number on failure. |
||||
*/ |
||||
int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int *flags_out); |
||||
int av_opt_eval_int (void *obj, const AVOption *o, const char *val, int *int_out); |
||||
int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t *int64_out); |
||||
int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float *float_out); |
||||
int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double *double_out); |
||||
int av_opt_eval_q (void *obj, const AVOption *o, const char *val, AVRational *q_out); |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#define AV_OPT_SEARCH_CHILDREN (1 << 0) /**< Search in possible children of the |
||||
given object first. */ |
||||
/**
|
||||
* The obj passed to av_opt_find() is fake -- only a double pointer to AVClass |
||||
* instead of a required pointer to a struct containing AVClass. This is |
||||
* useful for searching for options without needing to allocate the corresponding |
||||
* object. |
||||
*/ |
||||
#define AV_OPT_SEARCH_FAKE_OBJ (1 << 1) |
||||
|
||||
/**
|
||||
* In av_opt_get, return NULL if the option has a pointer type and is set to NULL, |
||||
* rather than returning an empty string. |
||||
*/ |
||||
#define AV_OPT_ALLOW_NULL (1 << 2) |
||||
|
||||
/**
|
||||
* Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than |
||||
* one component for certain option types. |
||||
* @see AVOptionRanges for details. |
||||
*/ |
||||
#define AV_OPT_MULTI_COMPONENT_RANGE (1 << 12) |
||||
|
||||
/**
|
||||
* Look for an option in an object. Consider only options which |
||||
* have all the specified flags set. |
||||
* |
||||
* @param[in] obj A pointer to a struct whose first element is a |
||||
* pointer to an AVClass. |
||||
* Alternatively a double pointer to an AVClass, if |
||||
* AV_OPT_SEARCH_FAKE_OBJ search flag is set. |
||||
* @param[in] name The name of the option to look for. |
||||
* @param[in] unit When searching for named constants, name of the unit |
||||
* it belongs to. |
||||
* @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG). |
||||
* @param search_flags A combination of AV_OPT_SEARCH_*. |
||||
* |
||||
* @return A pointer to the option found, or NULL if no option |
||||
* was found. |
||||
* |
||||
* @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable |
||||
* directly with av_opt_set(). Use special calls which take an options |
||||
* AVDictionary (e.g. avformat_open_input()) to set options found with this |
||||
* flag. |
||||
*/ |
||||
const AVOption *av_opt_find(void *obj, const char *name, const char *unit, |
||||
int opt_flags, int search_flags); |
||||
|
||||
/**
|
||||
* Look for an option in an object. Consider only options which |
||||
* have all the specified flags set. |
||||
* |
||||
* @param[in] obj A pointer to a struct whose first element is a |
||||
* pointer to an AVClass. |
||||
* Alternatively a double pointer to an AVClass, if |
||||
* AV_OPT_SEARCH_FAKE_OBJ search flag is set. |
||||
* @param[in] name The name of the option to look for. |
||||
* @param[in] unit When searching for named constants, name of the unit |
||||
* it belongs to. |
||||
* @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG). |
||||
* @param search_flags A combination of AV_OPT_SEARCH_*. |
||||
* @param[out] target_obj if non-NULL, an object to which the option belongs will be |
||||
* written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present |
||||
* in search_flags. This parameter is ignored if search_flags contain |
||||
* AV_OPT_SEARCH_FAKE_OBJ. |
||||
* |
||||
* @return A pointer to the option found, or NULL if no option |
||||
* was found. |
||||
*/ |
||||
const AVOption *av_opt_find2(void *obj, const char *name, const char *unit, |
||||
int opt_flags, int search_flags, void **target_obj); |
||||
|
||||
/**
|
||||
* Iterate over all AVOptions belonging to obj. |
||||
* |
||||
* @param obj an AVOptions-enabled struct or a double pointer to an |
||||
* AVClass describing it. |
||||
* @param prev result of the previous call to av_opt_next() on this object |
||||
* or NULL |
||||
* @return next AVOption or NULL |
||||
*/ |
||||
const AVOption *av_opt_next(const void *obj, const AVOption *prev); |
||||
|
||||
/**
|
||||
* Iterate over AVOptions-enabled children of obj. |
||||
* |
||||
* @param prev result of a previous call to this function or NULL |
||||
* @return next AVOptions-enabled child or NULL |
||||
*/ |
||||
void *av_opt_child_next(void *obj, void *prev); |
||||
|
||||
#if FF_API_CHILD_CLASS_NEXT |
||||
/**
|
||||
* Iterate over potential AVOptions-enabled children of parent. |
||||
* |
||||
* @param prev result of a previous call to this function or NULL |
||||
* @return AVClass corresponding to next potential child or NULL |
||||
* |
||||
* @deprecated use av_opt_child_class_iterate |
||||
*/ |
||||
attribute_deprecated |
||||
const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev); |
||||
#endif |
||||
|
||||
/**
|
||||
* Iterate over potential AVOptions-enabled children of parent. |
||||
* |
||||
* @param iter a pointer where iteration state is stored. |
||||
* @return AVClass corresponding to next potential child or NULL |
||||
*/ |
||||
const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter); |
||||
|
||||
/**
|
||||
* @defgroup opt_set_funcs Option setting functions |
||||
* @{ |
||||
* Those functions set the field of obj with the given name to value. |
||||
* |
||||
* @param[in] obj A struct whose first element is a pointer to an AVClass. |
||||
* @param[in] name the name of the field to set |
||||
* @param[in] val The value to set. In case of av_opt_set() if the field is not |
||||
* of a string type, then the given string is parsed. |
||||
* SI postfixes and some named scalars are supported. |
||||
* If the field is of a numeric type, it has to be a numeric or named |
||||
* scalar. Behavior with more than one scalar and +- infix operators |
||||
* is undefined. |
||||
* If the field is of a flags type, it has to be a sequence of numeric |
||||
* scalars or named flags separated by '+' or '-'. Prefixing a flag |
||||
* with '+' causes it to be set without affecting the other flags; |
||||
* similarly, '-' unsets a flag. |
||||
* If the field is of a dictionary type, it has to be a ':' separated list of |
||||
* key=value parameters. Values containing ':' special characters must be |
||||
* escaped. |
||||
* @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN |
||||
* is passed here, then the option may be set on a child of obj. |
||||
* |
||||
* @return 0 if the value has been set, or an AVERROR code in case of |
||||
* error: |
||||
* AVERROR_OPTION_NOT_FOUND if no matching option exists |
||||
* AVERROR(ERANGE) if the value is out of range |
||||
* AVERROR(EINVAL) if the value is not valid |
||||
*/ |
||||
int av_opt_set (void *obj, const char *name, const char *val, int search_flags); |
||||
int av_opt_set_int (void *obj, const char *name, int64_t val, int search_flags); |
||||
int av_opt_set_double (void *obj, const char *name, double val, int search_flags); |
||||
int av_opt_set_q (void *obj, const char *name, AVRational val, int search_flags); |
||||
int av_opt_set_bin (void *obj, const char *name, const uint8_t *val, int size, int search_flags); |
||||
int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags); |
||||
int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags); |
||||
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags); |
||||
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags); |
||||
int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags); |
||||
/**
|
||||
* @note Any old dictionary present is discarded and replaced with a copy of the new one. The |
||||
* caller still owns val is and responsible for freeing it. |
||||
*/ |
||||
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags); |
||||
|
||||
/**
|
||||
* Set a binary option to an integer list. |
||||
* |
||||
* @param obj AVClass object to set options on |
||||
* @param name name of the binary option |
||||
* @param val pointer to an integer list (must have the correct type with |
||||
* regard to the contents of the list) |
||||
* @param term list terminator (usually 0 or -1) |
||||
* @param flags search flags |
||||
*/ |
||||
#define av_opt_set_int_list(obj, name, val, term, flags) \ |
||||
(av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \
|
||||
AVERROR(EINVAL) : \
|
||||
av_opt_set_bin(obj, name, (const uint8_t *)(val), \
|
||||
av_int_list_length(val, term) * sizeof(*(val)), flags)) |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
/**
|
||||
* @defgroup opt_get_funcs Option getting functions |
||||
* @{ |
||||
* Those functions get a value of the option with the given name from an object. |
||||
* |
||||
* @param[in] obj a struct whose first element is a pointer to an AVClass. |
||||
* @param[in] name name of the option to get. |
||||
* @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN |
||||
* is passed here, then the option may be found in a child of obj. |
||||
* @param[out] out_val value of the option will be written here |
||||
* @return >=0 on success, a negative error code otherwise |
||||
*/ |
||||
/**
|
||||
* @note the returned string will be av_malloc()ed and must be av_free()ed by the caller |
||||
* |
||||
* @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the |
||||
* option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT |
||||
* and is set to NULL, *out_val will be set to NULL instead of an allocated |
||||
* empty string. |
||||
*/ |
||||
int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val); |
||||
int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val); |
||||
int av_opt_get_double (void *obj, const char *name, int search_flags, double *out_val); |
||||
int av_opt_get_q (void *obj, const char *name, int search_flags, AVRational *out_val); |
||||
int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out); |
||||
int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt); |
||||
int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt); |
||||
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val); |
||||
int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout); |
||||
/**
|
||||
* @param[out] out_val The returned dictionary is a copy of the actual value and must |
||||
* be freed with av_dict_free() by the caller |
||||
*/ |
||||
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val); |
||||
/**
|
||||
* @} |
||||
*/ |
||||
/**
|
||||
* Gets a pointer to the requested field in a struct. |
||||
* This function allows accessing a struct even when its fields are moved or |
||||
* renamed since the application making the access has been compiled, |
||||
* |
||||
* @returns a pointer to the field, it can be cast to the correct type and read |
||||
* or written to. |
||||
*/ |
||||
void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name); |
||||
|
||||
/**
|
||||
* Free an AVOptionRanges struct and set it to NULL. |
||||
*/ |
||||
void av_opt_freep_ranges(AVOptionRanges **ranges); |
||||
|
||||
/**
|
||||
* Get a list of allowed ranges for the given option. |
||||
* |
||||
* The returned list may depend on other fields in obj like for example profile. |
||||
* |
||||
* @param flags is a bitmask of flags, undefined flags should not be set and should be ignored |
||||
* AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance |
||||
* AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges |
||||
* |
||||
* The result must be freed with av_opt_freep_ranges. |
||||
* |
||||
* @return number of compontents returned on success, a negative errro code otherwise |
||||
*/ |
||||
int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags); |
||||
|
||||
/**
|
||||
* Copy options from src object into dest object. |
||||
* |
||||
* Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object. |
||||
* Original memory allocated for such options is freed unless both src and dest options points to the same memory. |
||||
* |
||||
* @param dest Object to copy from |
||||
* @param src Object to copy into |
||||
* @return 0 on success, negative on error |
||||
*/ |
||||
int av_opt_copy(void *dest, const void *src); |
||||
|
||||
/**
|
||||
* Get a default list of allowed ranges for the given option. |
||||
* |
||||
* This list is constructed without using the AVClass.query_ranges() callback |
||||
* and can be used as fallback from within the callback. |
||||
* |
||||
* @param flags is a bitmask of flags, undefined flags should not be set and should be ignored |
||||
* AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance |
||||
* AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges |
||||
* |
||||
* The result must be freed with av_opt_free_ranges. |
||||
* |
||||
* @return number of compontents returned on success, a negative errro code otherwise |
||||
*/ |
||||
int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags); |
||||
|
||||
/**
|
||||
* Check if given option is set to its default value. |
||||
* |
||||
* Options o must belong to the obj. This function must not be called to check child's options state. |
||||
* @see av_opt_is_set_to_default_by_name(). |
||||
* |
||||
* @param obj AVClass object to check option on |
||||
* @param o option to be checked |
||||
* @return >0 when option is set to its default, |
||||
* 0 when option is not set its default, |
||||
* <0 on error |
||||
*/ |
||||
int av_opt_is_set_to_default(void *obj, const AVOption *o); |
||||
|
||||
/**
|
||||
* Check if given option is set to its default value. |
||||
* |
||||
* @param obj AVClass object to check option on |
||||
* @param name option name |
||||
* @param search_flags combination of AV_OPT_SEARCH_* |
||||
* @return >0 when option is set to its default, |
||||
* 0 when option is not set its default, |
||||
* <0 on error |
||||
*/ |
||||
int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags); |
||||
|
||||
|
||||
#define AV_OPT_SERIALIZE_SKIP_DEFAULTS 0x00000001 ///< Serialize options that are not set to default values only.
|
||||
#define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT 0x00000002 ///< Serialize options that exactly match opt_flags only.
|
||||
|
||||
/**
|
||||
* Serialize object's options. |
||||
* |
||||
* Create a string containing object's serialized options. |
||||
* Such string may be passed back to av_opt_set_from_string() in order to restore option values. |
||||
* A key/value or pairs separator occurring in the serialized value or |
||||
* name string are escaped through the av_escape() function. |
||||
* |
||||
* @param[in] obj AVClass object to serialize |
||||
* @param[in] opt_flags serialize options with all the specified flags set (AV_OPT_FLAG) |
||||
* @param[in] flags combination of AV_OPT_SERIALIZE_* flags |
||||
* @param[out] buffer Pointer to buffer that will be allocated with string containg serialized options. |
||||
* 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 |
||||
* @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same. |
||||
*/ |
||||
int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer, |
||||
const char key_val_sep, const char pairs_sep); |
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_OPT_H */ |
@ -0,0 +1,193 @@ |
||||
/*
|
||||
* 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_PARSEUTILS_H |
||||
#define AVUTIL_PARSEUTILS_H |
||||
|
||||
#include <time.h> |
||||
|
||||
#include "rational.h" |
||||
|
||||
/**
|
||||
* @file |
||||
* misc parsing utilities |
||||
*/ |
||||
|
||||
/**
|
||||
* Parse str and store the parsed ratio in q. |
||||
* |
||||
* Note that a ratio with infinite (1/0) or negative value is |
||||
* considered valid, so you should check on the returned value if you |
||||
* want to exclude those values. |
||||
* |
||||
* The undefined value can be expressed using the "0:0" string. |
||||
* |
||||
* @param[in,out] q pointer to the AVRational which will contain the ratio |
||||
* @param[in] str the string to parse: it has to be a string in the format |
||||
* num:den, a float number or an expression |
||||
* @param[in] max the maximum allowed numerator and denominator |
||||
* @param[in] log_offset log level offset which is applied to the log |
||||
* level of log_ctx |
||||
* @param[in] log_ctx parent logging context |
||||
* @return >= 0 on success, a negative error code otherwise |
||||
*/ |
||||
int av_parse_ratio(AVRational *q, const char *str, int max, |
||||
int log_offset, void *log_ctx); |
||||
|
||||
#define av_parse_ratio_quiet(rate, str, max) \ |
||||
av_parse_ratio(rate, str, max, AV_LOG_MAX_OFFSET, NULL) |
||||
|
||||
/**
|
||||
* Parse str and put in width_ptr and height_ptr the detected values. |
||||
* |
||||
* @param[in,out] width_ptr pointer to the variable which will contain the detected |
||||
* width value |
||||
* @param[in,out] height_ptr pointer to the variable which will contain the detected |
||||
* height value |
||||
* @param[in] str the string to parse: it has to be a string in the format |
||||
* width x height or a valid video size abbreviation. |
||||
* @return >= 0 on success, a negative error code otherwise |
||||
*/ |
||||
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str); |
||||
|
||||
/**
|
||||
* Parse str and store the detected values in *rate. |
||||
* |
||||
* @param[in,out] rate pointer to the AVRational which will contain the detected |
||||
* frame rate |
||||
* @param[in] str the string to parse: it has to be a string in the format |
||||
* rate_num / rate_den, a float number or a valid video rate abbreviation |
||||
* @return >= 0 on success, a negative error code otherwise |
||||
*/ |
||||
int av_parse_video_rate(AVRational *rate, const char *str); |
||||
|
||||
/**
|
||||
* Put the RGBA values that correspond to color_string in rgba_color. |
||||
* |
||||
* @param color_string a string specifying a color. It can be the name of |
||||
* a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence, |
||||
* possibly followed by "@" and a string representing the alpha |
||||
* component. |
||||
* The alpha component may be a string composed by "0x" followed by an |
||||
* hexadecimal number or a decimal number between 0.0 and 1.0, which |
||||
* represents the opacity value (0x00/0.0 means completely transparent, |
||||
* 0xff/1.0 completely opaque). |
||||
* If the alpha component is not specified then 0xff is assumed. |
||||
* The string "random" will result in a random color. |
||||
* @param slen length of the initial part of color_string containing the |
||||
* color. It can be set to -1 if color_string is a null terminated string |
||||
* containing nothing else than the color. |
||||
* @return >= 0 in case of success, a negative value in case of |
||||
* failure (for example if color_string cannot be parsed). |
||||
*/ |
||||
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, |
||||
void *log_ctx); |
||||
|
||||
/**
|
||||
* Get the name of a color from the internal table of hard-coded named |
||||
* colors. |
||||
* |
||||
* This function is meant to enumerate the color names recognized by |
||||
* av_parse_color(). |
||||
* |
||||
* @param color_idx index of the requested color, starting from 0 |
||||
* @param rgbp if not NULL, will point to a 3-elements array with the color value in RGB |
||||
* @return the color name string or NULL if color_idx is not in the array |
||||
*/ |
||||
const char *av_get_known_color_name(int color_idx, const uint8_t **rgb); |
||||
|
||||
/**
|
||||
* Parse timestr and return in *time a corresponding number of |
||||
* microseconds. |
||||
* |
||||
* @param timeval puts here the number of microseconds corresponding |
||||
* to the string in timestr. If the string represents a duration, it |
||||
* is the number of microseconds contained in the time interval. If |
||||
* the string is a date, is the number of microseconds since 1st of |
||||
* January, 1970 up to the time of the parsed date. If timestr cannot |
||||
* be successfully parsed, set *time to INT64_MIN. |
||||
|
||||
* @param timestr a string representing a date or a duration. |
||||
* - If a date the syntax is: |
||||
* @code |
||||
* [{YYYY-MM-DD|YYYYMMDD}[T|t| ]]{{HH:MM:SS[.m...]]]}|{HHMMSS[.m...]]]}}[Z] |
||||
* now |
||||
* @endcode |
||||
* If the value is "now" it takes the current time. |
||||
* Time is local time unless Z is appended, in which case it is |
||||
* interpreted as UTC. |
||||
* If the year-month-day part is not specified it takes the current |
||||
* year-month-day. |
||||
* - If a duration the syntax is: |
||||
* @code |
||||
* [-][HH:]MM:SS[.m...] |
||||
* [-]S+[.m...] |
||||
* @endcode |
||||
* @param duration flag which tells how to interpret timestr, if not |
||||
* zero timestr is interpreted as a duration, otherwise as a date |
||||
* @return >= 0 in case of success, a negative value corresponding to an |
||||
* AVERROR code otherwise |
||||
*/ |
||||
int av_parse_time(int64_t *timeval, const char *timestr, int duration); |
||||
|
||||
/**
|
||||
* Attempt to find a specific tag in a URL. |
||||
* |
||||
* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. |
||||
* Return 1 if found. |
||||
*/ |
||||
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info); |
||||
|
||||
/**
|
||||
* Simplified version of strptime |
||||
* |
||||
* Parse the input string p according to the format string fmt and |
||||
* store its results in the structure dt. |
||||
* This implementation supports only a subset of the formats supported |
||||
* by the standard strptime(). |
||||
* |
||||
* The supported input field descriptors are listed below. |
||||
* - %H: the hour as a decimal number, using a 24-hour clock, in the |
||||
* range '00' through '23' |
||||
* - %J: hours as a decimal number, in the range '0' through INT_MAX |
||||
* - %M: the minute as a decimal number, using a 24-hour clock, in the |
||||
* range '00' through '59' |
||||
* - %S: the second as a decimal number, using a 24-hour clock, in the |
||||
* range '00' through '59' |
||||
* - %Y: the year as a decimal number, using the Gregorian calendar |
||||
* - %m: the month as a decimal number, in the range '1' through '12' |
||||
* - %d: the day of the month as a decimal number, in the range '1' |
||||
* through '31' |
||||
* - %T: alias for '%H:%M:%S' |
||||
* - %%: a literal '%' |
||||
* |
||||
* @return a pointer to the first character not processed in this function |
||||
* call. In case the input string contains more characters than |
||||
* required by the format string the return value points right after |
||||
* the last consumed input character. In case the whole input string |
||||
* is consumed the return value points to the null byte at the end of |
||||
* the string. On failure NULL is returned. |
||||
*/ |
||||
char *av_small_strptime(const char *p, const char *fmt, struct tm *dt); |
||||
|
||||
/**
|
||||
* Convert the decomposed UTC time in tm to a time_t value. |
||||
*/ |
||||
time_t av_timegm(struct tm *tm); |
||||
|
||||
#endif /* AVUTIL_PARSEUTILS_H */ |
@ -0,0 +1,442 @@ |
||||
/*
|
||||
* pixel format descriptor |
||||
* Copyright (c) 2009 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_PIXDESC_H |
||||
#define AVUTIL_PIXDESC_H |
||||
|
||||
#include <inttypes.h> |
||||
|
||||
#include "attributes.h" |
||||
#include "pixfmt.h" |
||||
#include "version.h" |
||||
|
||||
typedef struct AVComponentDescriptor { |
||||
/**
|
||||
* Which of the 4 planes contains the component. |
||||
*/ |
||||
int plane; |
||||
|
||||
/**
|
||||
* Number of elements between 2 horizontally consecutive pixels. |
||||
* Elements are bits for bitstream formats, bytes otherwise. |
||||
*/ |
||||
int step; |
||||
|
||||
/**
|
||||
* Number of elements before the component of the first pixel. |
||||
* Elements are bits for bitstream formats, bytes otherwise. |
||||
*/ |
||||
int offset; |
||||
|
||||
/**
|
||||
* Number of least significant bits that must be shifted away |
||||
* to get the value. |
||||
*/ |
||||
int shift; |
||||
|
||||
/**
|
||||
* Number of bits in the component. |
||||
*/ |
||||
int depth; |
||||
|
||||
#if FF_API_PLUS1_MINUS1 |
||||
/** deprecated, use step instead */ |
||||
attribute_deprecated int step_minus1; |
||||
|
||||
/** deprecated, use depth instead */ |
||||
attribute_deprecated int depth_minus1; |
||||
|
||||
/** deprecated, use offset instead */ |
||||
attribute_deprecated int offset_plus1; |
||||
#endif |
||||
} AVComponentDescriptor; |
||||
|
||||
/**
|
||||
* Descriptor that unambiguously describes how the bits of a pixel are |
||||
* stored in the up to 4 data planes of an image. It also stores the |
||||
* subsampling factors and number of components. |
||||
* |
||||
* @note This is separate of the colorspace (RGB, YCbCr, YPbPr, JPEG-style YUV |
||||
* and all the YUV variants) AVPixFmtDescriptor just stores how values |
||||
* are stored not what these values represent. |
||||
*/ |
||||
typedef struct AVPixFmtDescriptor { |
||||
const char *name; |
||||
uint8_t nb_components; ///< The number of components each pixel has, (1-4)
|
||||
|
||||
/**
|
||||
* Amount to shift the luma width right to find the chroma width. |
||||
* For YV12 this is 1 for example. |
||||
* chroma_width = AV_CEIL_RSHIFT(luma_width, log2_chroma_w) |
||||
* The note above is needed to ensure rounding up. |
||||
* This value only refers to the chroma components. |
||||
*/ |
||||
uint8_t log2_chroma_w; |
||||
|
||||
/**
|
||||
* Amount to shift the luma height right to find the chroma height. |
||||
* For YV12 this is 1 for example. |
||||
* chroma_height= AV_CEIL_RSHIFT(luma_height, log2_chroma_h) |
||||
* The note above is needed to ensure rounding up. |
||||
* This value only refers to the chroma components. |
||||
*/ |
||||
uint8_t log2_chroma_h; |
||||
|
||||
/**
|
||||
* Combination of AV_PIX_FMT_FLAG_... flags. |
||||
*/ |
||||
uint64_t flags; |
||||
|
||||
/**
|
||||
* Parameters that describe how pixels are packed. |
||||
* If the format has 1 or 2 components, then luma is 0. |
||||
* If the format has 3 or 4 components: |
||||
* if the RGB flag is set then 0 is red, 1 is green and 2 is blue; |
||||
* otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V. |
||||
* |
||||
* If present, the Alpha channel is always the last component. |
||||
*/ |
||||
AVComponentDescriptor comp[4]; |
||||
|
||||
/**
|
||||
* Alternative comma-separated names. |
||||
*/ |
||||
const char *alias; |
||||
} AVPixFmtDescriptor; |
||||
|
||||
/**
|
||||
* Pixel format is big-endian. |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_BE (1 << 0) |
||||
/**
|
||||
* Pixel format has a palette in data[1], values are indexes in this palette. |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_PAL (1 << 1) |
||||
/**
|
||||
* All values of a component are bit-wise packed end to end. |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_BITSTREAM (1 << 2) |
||||
/**
|
||||
* Pixel format is an HW accelerated format. |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_HWACCEL (1 << 3) |
||||
/**
|
||||
* At least one pixel component is not in the first data plane. |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_PLANAR (1 << 4) |
||||
/**
|
||||
* The pixel format contains RGB-like data (as opposed to YUV/grayscale). |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_RGB (1 << 5) |
||||
|
||||
#if FF_API_PSEUDOPAL |
||||
/**
|
||||
* The pixel format is "pseudo-paletted". This means that it contains a |
||||
* fixed palette in the 2nd plane but the palette is fixed/constant for each |
||||
* PIX_FMT. This allows interpreting the data as if it was PAL8, which can |
||||
* in some cases be simpler. Or the data can be interpreted purely based on |
||||
* the pixel format without using the palette. |
||||
* An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8 |
||||
* |
||||
* @deprecated This flag is deprecated, and will be removed. When it is removed, |
||||
* the extra palette allocation in AVFrame.data[1] is removed as well. Only |
||||
* actual paletted formats (as indicated by AV_PIX_FMT_FLAG_PAL) will have a |
||||
* palette. Starting with FFmpeg versions which have this flag deprecated, the |
||||
* extra "pseudo" palette is already ignored, and API users are not required to |
||||
* allocate a palette for AV_PIX_FMT_FLAG_PSEUDOPAL formats (it was required |
||||
* before the deprecation, though). |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_PSEUDOPAL (1 << 6) |
||||
#endif |
||||
|
||||
/**
|
||||
* The pixel format has an alpha channel. This is set on all formats that |
||||
* support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always |
||||
* straight, never pre-multiplied. |
||||
* |
||||
* If a codec or a filter does not support alpha, it should set all alpha to |
||||
* opaque, or use the equivalent pixel formats without alpha component, e.g. |
||||
* AV_PIX_FMT_RGB0 (or AV_PIX_FMT_RGB24 etc.) instead of AV_PIX_FMT_RGBA. |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_ALPHA (1 << 7) |
||||
|
||||
/**
|
||||
* The pixel format is following a Bayer pattern |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_BAYER (1 << 8) |
||||
|
||||
/**
|
||||
* The pixel format contains IEEE-754 floating point values. Precision (double, |
||||
* single, or half) should be determined by the pixel size (64, 32, or 16 bits). |
||||
*/ |
||||
#define AV_PIX_FMT_FLAG_FLOAT (1 << 9) |
||||
|
||||
/**
|
||||
* Return the number of bits per pixel used by the pixel format |
||||
* described by pixdesc. Note that this is not the same as the number |
||||
* of bits per sample. |
||||
* |
||||
* The returned number of bits refers to the number of bits actually |
||||
* used for storing the pixel information, that is padding bits are |
||||
* not counted. |
||||
*/ |
||||
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc); |
||||
|
||||
/**
|
||||
* Return the number of bits per pixel for the pixel format |
||||
* described by pixdesc, including any padding or unused bits. |
||||
*/ |
||||
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc); |
||||
|
||||
/**
|
||||
* @return a pixel format descriptor for provided pixel format or NULL if |
||||
* this pixel format is unknown. |
||||
*/ |
||||
const AVPixFmtDescriptor *av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt); |
||||
|
||||
/**
|
||||
* Iterate over all pixel format descriptors known to libavutil. |
||||
* |
||||
* @param prev previous descriptor. NULL to get the first descriptor. |
||||
* |
||||
* @return next descriptor or NULL after the last descriptor |
||||
*/ |
||||
const AVPixFmtDescriptor *av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev); |
||||
|
||||
/**
|
||||
* @return an AVPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc |
||||
* is not a valid pointer to a pixel format descriptor. |
||||
*/ |
||||
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc); |
||||
|
||||
/**
|
||||
* Utility function to access log2_chroma_w log2_chroma_h from |
||||
* the pixel format AVPixFmtDescriptor. |
||||
* |
||||
* @param[in] pix_fmt the pixel format |
||||
* @param[out] h_shift store log2_chroma_w (horizontal/width shift) |
||||
* @param[out] v_shift store log2_chroma_h (vertical/height shift) |
||||
* |
||||
* @return 0 on success, AVERROR(ENOSYS) on invalid or unknown pixel format |
||||
*/ |
||||
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, |
||||
int *h_shift, int *v_shift); |
||||
|
||||
/**
|
||||
* @return number of planes in pix_fmt, a negative AVERROR if pix_fmt is not a |
||||
* valid pixel format. |
||||
*/ |
||||
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt); |
||||
|
||||
/**
|
||||
* @return the name for provided color range or NULL if unknown. |
||||
*/ |
||||
const char *av_color_range_name(enum AVColorRange range); |
||||
|
||||
/**
|
||||
* @return the AVColorRange value for name or an AVError if not found. |
||||
*/ |
||||
int av_color_range_from_name(const char *name); |
||||
|
||||
/**
|
||||
* @return the name for provided color primaries or NULL if unknown. |
||||
*/ |
||||
const char *av_color_primaries_name(enum AVColorPrimaries primaries); |
||||
|
||||
/**
|
||||
* @return the AVColorPrimaries value for name or an AVError if not found. |
||||
*/ |
||||
int av_color_primaries_from_name(const char *name); |
||||
|
||||
/**
|
||||
* @return the name for provided color transfer or NULL if unknown. |
||||
*/ |
||||
const char *av_color_transfer_name(enum AVColorTransferCharacteristic transfer); |
||||
|
||||
/**
|
||||
* @return the AVColorTransferCharacteristic value for name or an AVError if not found. |
||||
*/ |
||||
int av_color_transfer_from_name(const char *name); |
||||
|
||||
/**
|
||||
* @return the name for provided color space or NULL if unknown. |
||||
*/ |
||||
const char *av_color_space_name(enum AVColorSpace space); |
||||
|
||||
/**
|
||||
* @return the AVColorSpace value for name or an AVError if not found. |
||||
*/ |
||||
int av_color_space_from_name(const char *name); |
||||
|
||||
/**
|
||||
* @return the name for provided chroma location or NULL if unknown. |
||||
*/ |
||||
const char *av_chroma_location_name(enum AVChromaLocation location); |
||||
|
||||
/**
|
||||
* @return the AVChromaLocation value for name or an AVError if not found. |
||||
*/ |
||||
int av_chroma_location_from_name(const char *name); |
||||
|
||||
/**
|
||||
* Return the pixel format corresponding to name. |
||||
* |
||||
* If there is no pixel format with name name, then looks for a |
||||
* pixel format with the name corresponding to the native endian |
||||
* format of name. |
||||
* For example in a little-endian system, first looks for "gray16", |
||||
* then for "gray16le". |
||||
* |
||||
* Finally if no pixel format has been found, returns AV_PIX_FMT_NONE. |
||||
*/ |
||||
enum AVPixelFormat av_get_pix_fmt(const char *name); |
||||
|
||||
/**
|
||||
* Return the short name for a pixel format, NULL in case pix_fmt is |
||||
* unknown. |
||||
* |
||||
* @see av_get_pix_fmt(), av_get_pix_fmt_string() |
||||
*/ |
||||
const char *av_get_pix_fmt_name(enum AVPixelFormat pix_fmt); |
||||
|
||||
/**
|
||||
* Print in buf the string corresponding to the pixel format with |
||||
* number pix_fmt, or a header if pix_fmt is negative. |
||||
* |
||||
* @param buf the buffer where to write the string |
||||
* @param buf_size the size of buf |
||||
* @param pix_fmt the number of the pixel format to print the |
||||
* corresponding info string, or a negative value to print the |
||||
* corresponding header. |
||||
*/ |
||||
char *av_get_pix_fmt_string(char *buf, int buf_size, |
||||
enum AVPixelFormat pix_fmt); |
||||
|
||||
/**
|
||||
* Read a line from an image, and write the values of the |
||||
* pixel format component c to dst. |
||||
* |
||||
* @param data the array containing the pointers to the planes of the image |
||||
* @param linesize the array containing the linesizes of the image |
||||
* @param desc the pixel format descriptor for the image |
||||
* @param x the horizontal coordinate of the first pixel to read |
||||
* @param y the vertical coordinate of the first pixel to read |
||||
* @param w the width of the line to read, that is the number of |
||||
* values to write to dst |
||||
* @param read_pal_component if not zero and the format is a paletted |
||||
* format writes the values corresponding to the palette |
||||
* component c in data[1] to dst, rather than the palette indexes in |
||||
* data[0]. The behavior is undefined if the format is not paletted. |
||||
* @param dst_element_size size of elements in dst array (2 or 4 byte) |
||||
*/ |
||||
void av_read_image_line2(void *dst, const uint8_t *data[4], |
||||
const int linesize[4], const AVPixFmtDescriptor *desc, |
||||
int x, int y, int c, int w, int read_pal_component, |
||||
int dst_element_size); |
||||
|
||||
void av_read_image_line(uint16_t *dst, const uint8_t *data[4], |
||||
const int linesize[4], const AVPixFmtDescriptor *desc, |
||||
int x, int y, int c, int w, int read_pal_component); |
||||
|
||||
/**
|
||||
* Write the values from src to the pixel format component c of an |
||||
* image line. |
||||
* |
||||
* @param src array containing the values to write |
||||
* @param data the array containing the pointers to the planes of the |
||||
* image to write into. It is supposed to be zeroed. |
||||
* @param linesize the array containing the linesizes of the image |
||||
* @param desc the pixel format descriptor for the image |
||||
* @param x the horizontal coordinate of the first pixel to write |
||||
* @param y the vertical coordinate of the first pixel to write |
||||
* @param w the width of the line to write, that is the number of |
||||
* values to write to the image line |
||||
* @param src_element_size size of elements in src array (2 or 4 byte) |
||||
*/ |
||||
void av_write_image_line2(const void *src, uint8_t *data[4], |
||||
const int linesize[4], const AVPixFmtDescriptor *desc, |
||||
int x, int y, int c, int w, int src_element_size); |
||||
|
||||
void av_write_image_line(const uint16_t *src, uint8_t *data[4], |
||||
const int linesize[4], const AVPixFmtDescriptor *desc, |
||||
int x, int y, int c, int w); |
||||
|
||||
/**
|
||||
* Utility function to swap the endianness of a pixel format. |
||||
* |
||||
* @param[in] pix_fmt the pixel format |
||||
* |
||||
* @return pixel format with swapped endianness if it exists, |
||||
* otherwise AV_PIX_FMT_NONE |
||||
*/ |
||||
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt); |
||||
|
||||
#define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */ |
||||
#define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */ |
||||
#define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */ |
||||
#define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */ |
||||
#define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */ |
||||
#define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */ |
||||
|
||||
/**
|
||||
* Compute what kind of losses will occur when converting from one specific |
||||
* pixel format to another. |
||||
* When converting from one pixel format to another, information loss may occur. |
||||
* For example, when converting from RGB24 to GRAY, the color information will |
||||
* be lost. Similarly, other losses occur when converting from some formats to |
||||
* other formats. These losses can involve loss of chroma, but also loss of |
||||
* resolution, loss of color depth, loss due to the color space conversion, loss |
||||
* of the alpha bits or loss due to color quantization. |
||||
* av_get_fix_fmt_loss() informs you about the various types of losses |
||||
* which will occur when converting from one pixel format to another. |
||||
* |
||||
* @param[in] dst_pix_fmt destination pixel format |
||||
* @param[in] src_pix_fmt source pixel format |
||||
* @param[in] has_alpha Whether the source pixel format alpha channel is used. |
||||
* @return Combination of flags informing you what kind of losses will occur |
||||
* (maximum loss for an invalid dst_pix_fmt). |
||||
*/ |
||||
int av_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, |
||||
enum AVPixelFormat src_pix_fmt, |
||||
int has_alpha); |
||||
|
||||
/**
|
||||
* Compute what kind of losses will occur when converting from one specific |
||||
* pixel format to another. |
||||
* When converting from one pixel format to another, information loss may occur. |
||||
* For example, when converting from RGB24 to GRAY, the color information will |
||||
* be lost. Similarly, other losses occur when converting from some formats to |
||||
* other formats. These losses can involve loss of chroma, but also loss of |
||||
* resolution, loss of color depth, loss due to the color space conversion, loss |
||||
* of the alpha bits or loss due to color quantization. |
||||
* av_get_fix_fmt_loss() informs you about the various types of losses |
||||
* which will occur when converting from one pixel format to another. |
||||
* |
||||
* @param[in] dst_pix_fmt destination pixel format |
||||
* @param[in] src_pix_fmt source pixel format |
||||
* @param[in] has_alpha Whether the source pixel format alpha channel is used. |
||||
* @return Combination of flags informing you what kind of losses will occur |
||||
* (maximum loss for an invalid dst_pix_fmt). |
||||
*/ |
||||
enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, |
||||
enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr); |
||||
|
||||
#endif /* AVUTIL_PIXDESC_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 AVUTIL_PIXELUTILS_H |
||||
#define AVUTIL_PIXELUTILS_H |
||||
|
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
#include "common.h" |
||||
|
||||
/**
|
||||
* Sum of abs(src1[x] - src2[x]) |
||||
*/ |
||||
typedef int (*av_pixelutils_sad_fn)(const uint8_t *src1, ptrdiff_t stride1, |
||||
const uint8_t *src2, ptrdiff_t stride2); |
||||
|
||||
/**
|
||||
* Get a potentially optimized pointer to a Sum-of-absolute-differences |
||||
* function (see the av_pixelutils_sad_fn prototype). |
||||
* |
||||
* @param w_bits 1<<w_bits is the requested width of the block size |
||||
* @param h_bits 1<<h_bits is the requested height of the block size |
||||
* @param aligned If set to 2, the returned sad function will assume src1 and |
||||
* src2 addresses are aligned on the block size. |
||||
* If set to 1, the returned sad function will assume src1 is |
||||
* aligned on the block size. |
||||
* If set to 0, the returned sad function assume no particular |
||||
* alignment. |
||||
* @param log_ctx context used for logging, can be NULL |
||||
* |
||||
* @return a pointer to the SAD function or NULL in case of error (because of |
||||
* invalid parameters) |
||||
*/ |
||||
av_pixelutils_sad_fn av_pixelutils_get_sad_fn(int w_bits, int h_bits, |
||||
int aligned, void *log_ctx); |
||||
|
||||
#endif /* AVUTIL_PIXELUTILS_H */ |
@ -0,0 +1,616 @@ |
||||
/*
|
||||
* 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_PIXFMT_H |
||||
#define AVUTIL_PIXFMT_H |
||||
|
||||
/**
|
||||
* @file |
||||
* pixel format definitions |
||||
*/ |
||||
|
||||
#include "libavutil/avconfig.h" |
||||
#include "version.h" |
||||
|
||||
#define AVPALETTE_SIZE 1024 |
||||
#define AVPALETTE_COUNT 256 |
||||
|
||||
/**
|
||||
* Pixel format. |
||||
* |
||||
* @note |
||||
* AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA |
||||
* color is put together as: |
||||
* (A << 24) | (R << 16) | (G << 8) | B |
||||
* This is stored as BGRA on little-endian CPU architectures and ARGB on |
||||
* big-endian CPUs. |
||||
* |
||||
* @note |
||||
* If the resolution is not a multiple of the chroma subsampling factor |
||||
* then the chroma plane resolution must be rounded up. |
||||
* |
||||
* @par |
||||
* When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized |
||||
* image data is stored in AVFrame.data[0]. The palette is transported in |
||||
* AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is |
||||
* formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is |
||||
* also endian-specific). Note also that the individual RGB32 palette |
||||
* components stored in AVFrame.data[1] should be in the range 0..255. |
||||
* This is important as many custom PAL8 video codecs that were designed |
||||
* to run on the IBM VGA graphics adapter use 6-bit palette components. |
||||
* |
||||
* @par |
||||
* For all the 8 bits per pixel formats, an RGB32 palette is in data[1] like |
||||
* for pal8. This palette is filled in automatically by the function |
||||
* allocating the picture. |
||||
*/ |
||||
enum AVPixelFormat { |
||||
AV_PIX_FMT_NONE = -1, |
||||
AV_PIX_FMT_YUV420P, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
|
||||
AV_PIX_FMT_YUYV422, ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
|
||||
AV_PIX_FMT_RGB24, ///< packed RGB 8:8:8, 24bpp, RGBRGB...
|
||||
AV_PIX_FMT_BGR24, ///< packed RGB 8:8:8, 24bpp, BGRBGR...
|
||||
AV_PIX_FMT_YUV422P, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
|
||||
AV_PIX_FMT_YUV444P, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
|
||||
AV_PIX_FMT_YUV410P, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
|
||||
AV_PIX_FMT_YUV411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
|
||||
AV_PIX_FMT_GRAY8, ///< Y , 8bpp
|
||||
AV_PIX_FMT_MONOWHITE, ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
|
||||
AV_PIX_FMT_MONOBLACK, ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
|
||||
AV_PIX_FMT_PAL8, ///< 8 bits with AV_PIX_FMT_RGB32 palette
|
||||
AV_PIX_FMT_YUVJ420P, ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
|
||||
AV_PIX_FMT_YUVJ422P, ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
|
||||
AV_PIX_FMT_YUVJ444P, ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
|
||||
AV_PIX_FMT_UYVY422, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
|
||||
AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
|
||||
AV_PIX_FMT_BGR8, ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
|
||||
AV_PIX_FMT_BGR4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
|
||||
AV_PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
|
||||
AV_PIX_FMT_RGB8, ///< packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
|
||||
AV_PIX_FMT_RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
|
||||
AV_PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
|
||||
AV_PIX_FMT_NV12, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
|
||||
AV_PIX_FMT_NV21, ///< as above, but U and V bytes are swapped
|
||||
|
||||
AV_PIX_FMT_ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
|
||||
AV_PIX_FMT_RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
|
||||
AV_PIX_FMT_ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
|
||||
AV_PIX_FMT_BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
|
||||
|
||||
AV_PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian
|
||||
AV_PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian
|
||||
AV_PIX_FMT_YUV440P, ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
|
||||
AV_PIX_FMT_YUVJ440P, ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
|
||||
AV_PIX_FMT_YUVA420P, ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
|
||||
AV_PIX_FMT_RGB48BE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
|
||||
AV_PIX_FMT_RGB48LE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
|
||||
|
||||
AV_PIX_FMT_RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
|
||||
AV_PIX_FMT_RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
|
||||
AV_PIX_FMT_RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
|
||||
AV_PIX_FMT_RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
|
||||
|
||||
AV_PIX_FMT_BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
|
||||
AV_PIX_FMT_BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
|
||||
AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
|
||||
AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
|
||||
|
||||
#if FF_API_VAAPI |
||||
/** @name Deprecated pixel formats */ |
||||
/**@{*/ |
||||
AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
|
||||
AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
|
||||
AV_PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a VASurfaceID
|
||||
/**@}*/ |
||||
AV_PIX_FMT_VAAPI = AV_PIX_FMT_VAAPI_VLD, |
||||
#else |
||||
/**
|
||||
* Hardware acceleration through VA-API, data[3] contains a |
||||
* VASurfaceID. |
||||
*/ |
||||
AV_PIX_FMT_VAAPI, |
||||
#endif |
||||
|
||||
AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
|
||||
AV_PIX_FMT_DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
|
||||
|
||||
AV_PIX_FMT_RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
|
||||
AV_PIX_FMT_RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
|
||||
AV_PIX_FMT_BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
|
||||
AV_PIX_FMT_BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
|
||||
AV_PIX_FMT_YA8, ///< 8 bits gray, 8 bits alpha
|
||||
|
||||
AV_PIX_FMT_Y400A = AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8
|
||||
AV_PIX_FMT_GRAY8A= AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8
|
||||
|
||||
AV_PIX_FMT_BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
|
||||
AV_PIX_FMT_BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
|
||||
|
||||
/**
|
||||
* The following 12 formats have the disadvantage of needing 1 format for each bit depth. |
||||
* Notice that each 9/10 bits sample is stored in 16 bits with extra padding. |
||||
* If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately is better. |
||||
*/ |
||||
AV_PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
|
||||
AV_PIX_FMT_GBRP, ///< planar GBR 4:4:4 24bpp
|
||||
AV_PIX_FMT_GBR24P = AV_PIX_FMT_GBRP, // alias for #AV_PIX_FMT_GBRP
|
||||
AV_PIX_FMT_GBRP9BE, ///< planar GBR 4:4:4 27bpp, big-endian
|
||||
AV_PIX_FMT_GBRP9LE, ///< planar GBR 4:4:4 27bpp, little-endian
|
||||
AV_PIX_FMT_GBRP10BE, ///< planar GBR 4:4:4 30bpp, big-endian
|
||||
AV_PIX_FMT_GBRP10LE, ///< planar GBR 4:4:4 30bpp, little-endian
|
||||
AV_PIX_FMT_GBRP16BE, ///< planar GBR 4:4:4 48bpp, big-endian
|
||||
AV_PIX_FMT_GBRP16LE, ///< planar GBR 4:4:4 48bpp, little-endian
|
||||
AV_PIX_FMT_YUVA422P, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
|
||||
AV_PIX_FMT_YUVA444P, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
|
||||
AV_PIX_FMT_YUVA420P9BE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
|
||||
AV_PIX_FMT_YUVA420P9LE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
|
||||
AV_PIX_FMT_YUVA422P9BE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
|
||||
AV_PIX_FMT_YUVA422P9LE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
|
||||
AV_PIX_FMT_YUVA444P9BE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
|
||||
AV_PIX_FMT_YUVA444P9LE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
|
||||
AV_PIX_FMT_YUVA420P10BE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
|
||||
AV_PIX_FMT_YUVA420P10LE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
|
||||
AV_PIX_FMT_YUVA422P10BE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
|
||||
AV_PIX_FMT_YUVA422P10LE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
|
||||
AV_PIX_FMT_YUVA444P10BE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
|
||||
AV_PIX_FMT_YUVA444P10LE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
|
||||
AV_PIX_FMT_YUVA420P16BE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
|
||||
AV_PIX_FMT_YUVA420P16LE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
|
||||
AV_PIX_FMT_YUVA422P16BE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
|
||||
AV_PIX_FMT_YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
|
||||
AV_PIX_FMT_YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
|
||||
AV_PIX_FMT_YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
|
||||
|
||||
AV_PIX_FMT_VDPAU, ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface
|
||||
|
||||
AV_PIX_FMT_XYZ12LE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0
|
||||
AV_PIX_FMT_XYZ12BE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0
|
||||
AV_PIX_FMT_NV16, ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
|
||||
AV_PIX_FMT_NV20LE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
|
||||
AV_PIX_FMT_NV20BE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
|
||||
|
||||
AV_PIX_FMT_RGBA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
|
||||
AV_PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
|
||||
AV_PIX_FMT_BGRA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
|
||||
AV_PIX_FMT_BGRA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
|
||||
|
||||
AV_PIX_FMT_YVYU422, ///< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
|
||||
|
||||
AV_PIX_FMT_YA16BE, ///< 16 bits gray, 16 bits alpha (big-endian)
|
||||
AV_PIX_FMT_YA16LE, ///< 16 bits gray, 16 bits alpha (little-endian)
|
||||
|
||||
AV_PIX_FMT_GBRAP, ///< planar GBRA 4:4:4:4 32bpp
|
||||
AV_PIX_FMT_GBRAP16BE, ///< planar GBRA 4:4:4:4 64bpp, big-endian
|
||||
AV_PIX_FMT_GBRAP16LE, ///< planar GBRA 4:4:4:4 64bpp, little-endian
|
||||
/**
|
||||
* HW acceleration through QSV, data[3] contains a pointer to the |
||||
* mfxFrameSurface1 structure. |
||||
*/ |
||||
AV_PIX_FMT_QSV, |
||||
/**
|
||||
* HW acceleration though MMAL, data[3] contains a pointer to the |
||||
* MMAL_BUFFER_HEADER_T structure. |
||||
*/ |
||||
AV_PIX_FMT_MMAL, |
||||
|
||||
AV_PIX_FMT_D3D11VA_VLD, ///< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer
|
||||
|
||||
/**
|
||||
* HW acceleration through CUDA. data[i] contain CUdeviceptr pointers |
||||
* exactly as for system memory frames. |
||||
*/ |
||||
AV_PIX_FMT_CUDA, |
||||
|
||||
AV_PIX_FMT_0RGB, ///< packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
|
||||
AV_PIX_FMT_RGB0, ///< packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
|
||||
AV_PIX_FMT_0BGR, ///< packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
|
||||
AV_PIX_FMT_BGR0, ///< packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
|
||||
|
||||
AV_PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
|
||||
AV_PIX_FMT_GBRP12BE, ///< planar GBR 4:4:4 36bpp, big-endian
|
||||
AV_PIX_FMT_GBRP12LE, ///< planar GBR 4:4:4 36bpp, little-endian
|
||||
AV_PIX_FMT_GBRP14BE, ///< planar GBR 4:4:4 42bpp, big-endian
|
||||
AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian
|
||||
AV_PIX_FMT_YUVJ411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
|
||||
|
||||
AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
|
||||
AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
|
||||
AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
|
||||
AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
|
||||
AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
|
||||
AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
|
||||
AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
|
||||
AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
|
||||
AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
|
||||
AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
|
||||
AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
|
||||
AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
|
||||
|
||||
AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
|
||||
|
||||
AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
|
||||
AV_PIX_FMT_YUV440P12LE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
|
||||
AV_PIX_FMT_YUV440P12BE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
|
||||
AV_PIX_FMT_AYUV64LE, ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
|
||||
AV_PIX_FMT_AYUV64BE, ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
|
||||
|
||||
AV_PIX_FMT_VIDEOTOOLBOX, ///< hardware decoding through Videotoolbox
|
||||
|
||||
AV_PIX_FMT_P010LE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
|
||||
AV_PIX_FMT_P010BE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
|
||||
|
||||
AV_PIX_FMT_GBRAP12BE, ///< planar GBR 4:4:4:4 48bpp, big-endian
|
||||
AV_PIX_FMT_GBRAP12LE, ///< planar GBR 4:4:4:4 48bpp, little-endian
|
||||
|
||||
AV_PIX_FMT_GBRAP10BE, ///< planar GBR 4:4:4:4 40bpp, big-endian
|
||||
AV_PIX_FMT_GBRAP10LE, ///< planar GBR 4:4:4:4 40bpp, little-endian
|
||||
|
||||
AV_PIX_FMT_MEDIACODEC, ///< hardware decoding through MediaCodec
|
||||
|
||||
AV_PIX_FMT_GRAY12BE, ///< Y , 12bpp, big-endian
|
||||
AV_PIX_FMT_GRAY12LE, ///< Y , 12bpp, little-endian
|
||||
AV_PIX_FMT_GRAY10BE, ///< Y , 10bpp, big-endian
|
||||
AV_PIX_FMT_GRAY10LE, ///< Y , 10bpp, little-endian
|
||||
|
||||
AV_PIX_FMT_P016LE, ///< like NV12, with 16bpp per component, little-endian
|
||||
AV_PIX_FMT_P016BE, ///< like NV12, with 16bpp per component, big-endian
|
||||
|
||||
/**
|
||||
* Hardware surfaces for Direct3D11. |
||||
* |
||||
* This is preferred over the legacy AV_PIX_FMT_D3D11VA_VLD. The new D3D11 |
||||
* hwaccel API and filtering support AV_PIX_FMT_D3D11 only. |
||||
* |
||||
* data[0] contains a ID3D11Texture2D pointer, and data[1] contains the |
||||
* texture array index of the frame as intptr_t if the ID3D11Texture2D is |
||||
* an array texture (or always 0 if it's a normal texture). |
||||
*/ |
||||
AV_PIX_FMT_D3D11, |
||||
|
||||
AV_PIX_FMT_GRAY9BE, ///< Y , 9bpp, big-endian
|
||||
AV_PIX_FMT_GRAY9LE, ///< Y , 9bpp, little-endian
|
||||
|
||||
AV_PIX_FMT_GBRPF32BE, ///< IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian
|
||||
AV_PIX_FMT_GBRPF32LE, ///< IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian
|
||||
AV_PIX_FMT_GBRAPF32BE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian
|
||||
AV_PIX_FMT_GBRAPF32LE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian
|
||||
|
||||
/**
|
||||
* DRM-managed buffers exposed through PRIME buffer sharing. |
||||
* |
||||
* data[0] points to an AVDRMFrameDescriptor. |
||||
*/ |
||||
AV_PIX_FMT_DRM_PRIME, |
||||
/**
|
||||
* Hardware surfaces for OpenCL. |
||||
* |
||||
* data[i] contain 2D image objects (typed in C as cl_mem, used |
||||
* in OpenCL as image2d_t) for each plane of the surface. |
||||
*/ |
||||
AV_PIX_FMT_OPENCL, |
||||
|
||||
AV_PIX_FMT_GRAY14BE, ///< Y , 14bpp, big-endian
|
||||
AV_PIX_FMT_GRAY14LE, ///< Y , 14bpp, little-endian
|
||||
|
||||
AV_PIX_FMT_GRAYF32BE, ///< IEEE-754 single precision Y, 32bpp, big-endian
|
||||
AV_PIX_FMT_GRAYF32LE, ///< IEEE-754 single precision Y, 32bpp, little-endian
|
||||
|
||||
AV_PIX_FMT_YUVA422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
|
||||
AV_PIX_FMT_YUVA422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
|
||||
AV_PIX_FMT_YUVA444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
|
||||
AV_PIX_FMT_YUVA444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
|
||||
|
||||
AV_PIX_FMT_NV24, ///< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
|
||||
AV_PIX_FMT_NV42, ///< as above, but U and V bytes are swapped
|
||||
|
||||
/**
|
||||
* Vulkan hardware images. |
||||
* |
||||
* data[0] points to an AVVkFrame |
||||
*/ |
||||
AV_PIX_FMT_VULKAN, |
||||
|
||||
AV_PIX_FMT_Y210BE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian
|
||||
AV_PIX_FMT_Y210LE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
|
||||
|
||||
AV_PIX_FMT_X2RGB10LE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
|
||||
AV_PIX_FMT_X2RGB10BE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
|
||||
AV_PIX_FMT_NB ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
|
||||
}; |
||||
|
||||
#if AV_HAVE_BIGENDIAN |
||||
# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##be |
||||
#else |
||||
# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le |
||||
#endif |
||||
|
||||
#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA) |
||||
#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR) |
||||
#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA) |
||||
#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB) |
||||
#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0) |
||||
#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0) |
||||
|
||||
#define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE) |
||||
#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE) |
||||
#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE) |
||||
#define AV_PIX_FMT_GRAY14 AV_PIX_FMT_NE(GRAY14BE, GRAY14LE) |
||||
#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE) |
||||
#define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE) |
||||
#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE) |
||||
#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE) |
||||
#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE) |
||||
#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE) |
||||
#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE) |
||||
#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE) |
||||
#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE) |
||||
#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE) |
||||
#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE) |
||||
#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE) |
||||
|
||||
#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE) |
||||
#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE) |
||||
#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE) |
||||
#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE) |
||||
#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE) |
||||
#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE) |
||||
#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE) |
||||
#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE) |
||||
#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE) |
||||
#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE) |
||||
#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE) |
||||
#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE) |
||||
#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE) |
||||
#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE) |
||||
#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE) |
||||
#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE) |
||||
#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE) |
||||
|
||||
#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE) |
||||
#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE) |
||||
#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE) |
||||
#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE) |
||||
#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE) |
||||
#define AV_PIX_FMT_GBRAP10 AV_PIX_FMT_NE(GBRAP10BE, GBRAP10LE) |
||||
#define AV_PIX_FMT_GBRAP12 AV_PIX_FMT_NE(GBRAP12BE, GBRAP12LE) |
||||
#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE) |
||||
|
||||
#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE) |
||||
#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE) |
||||
#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE) |
||||
#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE) |
||||
|
||||
#define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE) |
||||
#define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE) |
||||
|
||||
#define AV_PIX_FMT_GRAYF32 AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE) |
||||
|
||||
#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE) |
||||
#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE) |
||||
#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE) |
||||
#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE) |
||||
#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE) |
||||
#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE) |
||||
#define AV_PIX_FMT_YUVA422P12 AV_PIX_FMT_NE(YUVA422P12BE, YUVA422P12LE) |
||||
#define AV_PIX_FMT_YUVA444P12 AV_PIX_FMT_NE(YUVA444P12BE, YUVA444P12LE) |
||||
#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE) |
||||
#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE) |
||||
#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE) |
||||
|
||||
#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE) |
||||
#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE) |
||||
#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE) |
||||
#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE) |
||||
#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE) |
||||
|
||||
#define AV_PIX_FMT_Y210 AV_PIX_FMT_NE(Y210BE, Y210LE) |
||||
#define AV_PIX_FMT_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE) |
||||
|
||||
/**
|
||||
* Chromaticity coordinates of the source primaries. |
||||
* These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1. |
||||
*/ |
||||
enum AVColorPrimaries { |
||||
AVCOL_PRI_RESERVED0 = 0, |
||||
AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
|
||||
AVCOL_PRI_UNSPECIFIED = 2, |
||||
AVCOL_PRI_RESERVED = 3, |
||||
AVCOL_PRI_BT470M = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
|
||||
|
||||
AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
|
||||
AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
|
||||
AVCOL_PRI_SMPTE240M = 7, ///< functionally identical to above
|
||||
AVCOL_PRI_FILM = 8, ///< colour filters using Illuminant C
|
||||
AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020
|
||||
AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
|
||||
AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428, |
||||
AVCOL_PRI_SMPTE431 = 11, ///< SMPTE ST 431-2 (2011) / DCI P3
|
||||
AVCOL_PRI_SMPTE432 = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3
|
||||
AVCOL_PRI_EBU3213 = 22, ///< EBU Tech. 3213-E / JEDEC P22 phosphors
|
||||
AVCOL_PRI_JEDEC_P22 = AVCOL_PRI_EBU3213, |
||||
AVCOL_PRI_NB ///< Not part of ABI
|
||||
}; |
||||
|
||||
/**
|
||||
* Color Transfer Characteristic. |
||||
* These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2. |
||||
*/ |
||||
enum AVColorTransferCharacteristic { |
||||
AVCOL_TRC_RESERVED0 = 0, |
||||
AVCOL_TRC_BT709 = 1, ///< also ITU-R BT1361
|
||||
AVCOL_TRC_UNSPECIFIED = 2, |
||||
AVCOL_TRC_RESERVED = 3, |
||||
AVCOL_TRC_GAMMA22 = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
|
||||
AVCOL_TRC_GAMMA28 = 5, ///< also ITU-R BT470BG
|
||||
AVCOL_TRC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
|
||||
AVCOL_TRC_SMPTE240M = 7, |
||||
AVCOL_TRC_LINEAR = 8, ///< "Linear transfer characteristics"
|
||||
AVCOL_TRC_LOG = 9, ///< "Logarithmic transfer characteristic (100:1 range)"
|
||||
AVCOL_TRC_LOG_SQRT = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
|
||||
AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4
|
||||
AVCOL_TRC_BT1361_ECG = 12, ///< ITU-R BT1361 Extended Colour Gamut
|
||||
AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC)
|
||||
AVCOL_TRC_BT2020_10 = 14, ///< ITU-R BT2020 for 10-bit system
|
||||
AVCOL_TRC_BT2020_12 = 15, ///< ITU-R BT2020 for 12-bit system
|
||||
AVCOL_TRC_SMPTE2084 = 16, ///< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
|
||||
AVCOL_TRC_SMPTEST2084 = AVCOL_TRC_SMPTE2084, |
||||
AVCOL_TRC_SMPTE428 = 17, ///< SMPTE ST 428-1
|
||||
AVCOL_TRC_SMPTEST428_1 = AVCOL_TRC_SMPTE428, |
||||
AVCOL_TRC_ARIB_STD_B67 = 18, ///< ARIB STD-B67, known as "Hybrid log-gamma"
|
||||
AVCOL_TRC_NB ///< Not part of ABI
|
||||
}; |
||||
|
||||
/**
|
||||
* YUV colorspace type. |
||||
* These values match the ones defined by ISO/IEC 23001-8_2013 § 7.3. |
||||
*/ |
||||
enum AVColorSpace { |
||||
AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
|
||||
AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
|
||||
AVCOL_SPC_UNSPECIFIED = 2, |
||||
AVCOL_SPC_RESERVED = 3, |
||||
AVCOL_SPC_FCC = 4, ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
|
||||
AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
|
||||
AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
|
||||
AVCOL_SPC_SMPTE240M = 7, ///< functionally identical to above
|
||||
AVCOL_SPC_YCGCO = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
|
||||
AVCOL_SPC_YCOCG = AVCOL_SPC_YCGCO, |
||||
AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system
|
||||
AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system
|
||||
AVCOL_SPC_SMPTE2085 = 11, ///< SMPTE 2085, Y'D'zD'x
|
||||
AVCOL_SPC_CHROMA_DERIVED_NCL = 12, ///< Chromaticity-derived non-constant luminance system
|
||||
AVCOL_SPC_CHROMA_DERIVED_CL = 13, ///< Chromaticity-derived constant luminance system
|
||||
AVCOL_SPC_ICTCP = 14, ///< ITU-R BT.2100-0, ICtCp
|
||||
AVCOL_SPC_NB ///< Not part of ABI
|
||||
}; |
||||
|
||||
/**
|
||||
* Visual content value range. |
||||
* |
||||
* These values are based on definitions that can be found in multiple |
||||
* specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance |
||||
* and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital |
||||
* Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit |
||||
* integer representation). At the time of writing, the BT.2100 one is |
||||
* recommended, as it also defines the full range representation. |
||||
* |
||||
* Common definitions: |
||||
* - For RGB and luminance planes such as Y in YCbCr and I in ICtCp, |
||||
* 'E' is the original value in range of 0.0 to 1.0. |
||||
* - For chrominance planes such as Cb,Cr and Ct,Cp, 'E' is the original |
||||
* value in range of -0.5 to 0.5. |
||||
* - 'n' is the output bit depth. |
||||
* - For additional definitions such as rounding and clipping to valid n |
||||
* bit unsigned integer range, please refer to BT.2100 (Table 9). |
||||
*/ |
||||
enum AVColorRange { |
||||
AVCOL_RANGE_UNSPECIFIED = 0, |
||||
|
||||
/**
|
||||
* Narrow or limited range content. |
||||
* |
||||
* - For luminance planes: |
||||
* |
||||
* (219 * E + 16) * 2^(n-8) |
||||
* |
||||
* F.ex. the range of 16-235 for 8 bits |
||||
* |
||||
* - For chrominance planes: |
||||
* |
||||
* (224 * E + 128) * 2^(n-8) |
||||
* |
||||
* F.ex. the range of 16-240 for 8 bits |
||||
*/ |
||||
AVCOL_RANGE_MPEG = 1, |
||||
|
||||
/**
|
||||
* Full range content. |
||||
* |
||||
* - For RGB and luminance planes: |
||||
* |
||||
* (2^n - 1) * E |
||||
* |
||||
* F.ex. the range of 0-255 for 8 bits |
||||
* |
||||
* - For chrominance planes: |
||||
* |
||||
* (2^n - 1) * E + 2^(n - 1) |
||||
* |
||||
* F.ex. the range of 1-255 for 8 bits |
||||
*/ |
||||
AVCOL_RANGE_JPEG = 2, |
||||
AVCOL_RANGE_NB ///< Not part of ABI
|
||||
}; |
||||
|
||||
/**
|
||||
* Location of chroma samples. |
||||
* |
||||
* Illustration showing the location of the first (top left) chroma sample of the |
||||
* image, the left shows only luma, the right |
||||
* shows the location of the chroma sample, the 2 could be imagined to overlay |
||||
* each other but are drawn separately due to limitations of ASCII |
||||
* |
||||
* 1st 2nd 1st 2nd horizontal luma sample positions |
||||
* v v v v |
||||
* ______ ______ |
||||
*1st luma line > |X X ... |3 4 X ... X are luma samples, |
||||
* | |1 2 1-6 are possible chroma positions |
||||
*2nd luma line > |X X ... |5 6 X ... 0 is undefined/unknown position |
||||
*/ |
||||
enum AVChromaLocation { |
||||
AVCHROMA_LOC_UNSPECIFIED = 0, |
||||
AVCHROMA_LOC_LEFT = 1, ///< MPEG-2/4 4:2:0, H.264 default for 4:2:0
|
||||
AVCHROMA_LOC_CENTER = 2, ///< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0
|
||||
AVCHROMA_LOC_TOPLEFT = 3, ///< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2
|
||||
AVCHROMA_LOC_TOP = 4, |
||||
AVCHROMA_LOC_BOTTOMLEFT = 5, |
||||
AVCHROMA_LOC_BOTTOM = 6, |
||||
AVCHROMA_LOC_NB ///< Not part of ABI
|
||||
}; |
||||
|
||||
#endif /* AVUTIL_PIXFMT_H */ |
@ -0,0 +1,43 @@ |
||||
/*
|
||||
* Copyright (c) 2009 Baptiste Coudurier <baptiste.coudurier@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_RANDOM_SEED_H |
||||
#define AVUTIL_RANDOM_SEED_H |
||||
|
||||
#include <stdint.h> |
||||
/**
|
||||
* @addtogroup lavu_crypto |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Get a seed to use in conjunction with random functions. |
||||
* This function tries to provide a good seed at a best effort bases. |
||||
* Its possible to call this function multiple times if more bits are needed. |
||||
* It can be quite slow, which is why it should only be used as seed for a faster |
||||
* PRNG. The quality of the seed depends on the platform. |
||||
*/ |
||||
uint32_t av_get_random_seed(void); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_RANDOM_SEED_H */ |
@ -0,0 +1,220 @@ |
||||
/*
|
||||
* rational numbers |
||||
* Copyright (c) 2003 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_math_rational |
||||
* Utilties for rational number calculation. |
||||
* @author Michael Niedermayer <michaelni@gmx.at> |
||||
*/ |
||||
|
||||
#ifndef AVUTIL_RATIONAL_H |
||||
#define AVUTIL_RATIONAL_H |
||||
|
||||
#include <stdint.h> |
||||
#include <limits.h> |
||||
#include "attributes.h" |
||||
|
||||
/**
|
||||
* @defgroup lavu_math_rational AVRational |
||||
* @ingroup lavu_math |
||||
* Rational number calculation. |
||||
* |
||||
* While rational numbers can be expressed as floating-point numbers, the |
||||
* conversion process is a lossy one, so are floating-point operations. On the |
||||
* other hand, the nature of FFmpeg demands highly accurate calculation of |
||||
* timestamps. This set of rational number utilities serves as a generic |
||||
* interface for manipulating rational numbers as pairs of numerators and |
||||
* denominators. |
||||
* |
||||
* Many of the functions that operate on AVRational's have the suffix `_q`, in |
||||
* reference to the mathematical symbol "ℚ" (Q) which denotes the set of all |
||||
* rational numbers. |
||||
* |
||||
* @{ |
||||
*/ |
||||
|
||||
/**
|
||||
* Rational number (pair of numerator and denominator). |
||||
*/ |
||||
typedef struct AVRational{ |
||||
int num; ///< Numerator
|
||||
int den; ///< Denominator
|
||||
} AVRational; |
||||
|
||||
/**
|
||||
* Create an AVRational. |
||||
* |
||||
* Useful for compilers that do not support compound literals. |
||||
* |
||||
* @note The return value is not reduced. |
||||
* @see av_reduce() |
||||
*/ |
||||
static inline AVRational av_make_q(int num, int den) |
||||
{ |
||||
AVRational r = { num, den }; |
||||
return r; |
||||
} |
||||
|
||||
/**
|
||||
* Compare two rationals. |
||||
* |
||||
* @param a First rational |
||||
* @param b Second rational |
||||
* |
||||
* @return One of the following values: |
||||
* - 0 if `a == b` |
||||
* - 1 if `a > b` |
||||
* - -1 if `a < b` |
||||
* - `INT_MIN` if one of the values is of the form `0 / 0` |
||||
*/ |
||||
static inline int av_cmp_q(AVRational a, AVRational b){ |
||||
const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den; |
||||
|
||||
if(tmp) return (int)((tmp ^ a.den ^ b.den)>>63)|1; |
||||
else if(b.den && a.den) return 0; |
||||
else if(a.num && b.num) return (a.num>>31) - (b.num>>31); |
||||
else return INT_MIN; |
||||
} |
||||
|
||||
/**
|
||||
* Convert an AVRational to a `double`. |
||||
* @param a AVRational to convert |
||||
* @return `a` in floating-point form |
||||
* @see av_d2q() |
||||
*/ |
||||
static inline double av_q2d(AVRational a){ |
||||
return a.num / (double) a.den; |
||||
} |
||||
|
||||
/**
|
||||
* Reduce a fraction. |
||||
* |
||||
* This is useful for framerate calculations. |
||||
* |
||||
* @param[out] dst_num Destination numerator |
||||
* @param[out] dst_den Destination denominator |
||||
* @param[in] num Source numerator |
||||
* @param[in] den Source denominator |
||||
* @param[in] max Maximum allowed values for `dst_num` & `dst_den` |
||||
* @return 1 if the operation is exact, 0 otherwise |
||||
*/ |
||||
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max); |
||||
|
||||
/**
|
||||
* Multiply two rationals. |
||||
* @param b First rational |
||||
* @param c Second rational |
||||
* @return b*c |
||||
*/ |
||||
AVRational av_mul_q(AVRational b, AVRational c) av_const; |
||||
|
||||
/**
|
||||
* Divide one rational by another. |
||||
* @param b First rational |
||||
* @param c Second rational |
||||
* @return b/c |
||||
*/ |
||||
AVRational av_div_q(AVRational b, AVRational c) av_const; |
||||
|
||||
/**
|
||||
* Add two rationals. |
||||
* @param b First rational |
||||
* @param c Second rational |
||||
* @return b+c |
||||
*/ |
||||
AVRational av_add_q(AVRational b, AVRational c) av_const; |
||||
|
||||
/**
|
||||
* Subtract one rational from another. |
||||
* @param b First rational |
||||
* @param c Second rational |
||||
* @return b-c |
||||
*/ |
||||
AVRational av_sub_q(AVRational b, AVRational c) av_const; |
||||
|
||||
/**
|
||||
* Invert a rational. |
||||
* @param q value |
||||
* @return 1 / q |
||||
*/ |
||||
static av_always_inline AVRational av_inv_q(AVRational q) |
||||
{ |
||||
AVRational r = { q.den, q.num }; |
||||
return r; |
||||
} |
||||
|
||||
/**
|
||||
* Convert a double precision floating point number to a rational. |
||||
* |
||||
* In case of infinity, the returned value is expressed as `{1, 0}` or |
||||
* `{-1, 0}` depending on the sign. |
||||
* |
||||
* @param d `double` to convert |
||||
* @param max Maximum allowed numerator and denominator |
||||
* @return `d` in AVRational form |
||||
* @see av_q2d() |
||||
*/ |
||||
AVRational av_d2q(double d, int max) av_const; |
||||
|
||||
/**
|
||||
* Find which of the two rationals is closer to another rational. |
||||
* |
||||
* @param q Rational to be compared against |
||||
* @param q1,q2 Rationals to be tested |
||||
* @return One of the following values: |
||||
* - 1 if `q1` is nearer to `q` than `q2` |
||||
* - -1 if `q2` is nearer to `q` than `q1` |
||||
* - 0 if they have the same distance |
||||
*/ |
||||
int av_nearer_q(AVRational q, AVRational q1, AVRational q2); |
||||
|
||||
/**
|
||||
* Find the value in a list of rationals nearest a given reference rational. |
||||
* |
||||
* @param q Reference rational |
||||
* @param q_list Array of rationals terminated by `{0, 0}` |
||||
* @return Index of the nearest value found in the array |
||||
*/ |
||||
int av_find_nearest_q_idx(AVRational q, const AVRational* q_list); |
||||
|
||||
/**
|
||||
* Convert an AVRational to a IEEE 32-bit `float` expressed in fixed-point |
||||
* format. |
||||
* |
||||
* @param q Rational to be converted |
||||
* @return Equivalent floating-point value, expressed as an unsigned 32-bit |
||||
* integer. |
||||
* @note The returned value is platform-indepedant. |
||||
*/ |
||||
uint32_t av_q2intfloat(AVRational q); |
||||
|
||||
/**
|
||||
* Return the best rational so that a and b are multiple of it. |
||||
* If the resulting denominator is larger than max_den, return def. |
||||
*/ |
||||
AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def); |
||||
|
||||
/**
|
||||
* @} |
||||
*/ |
||||
|
||||
#endif /* AVUTIL_RATIONAL_H */ |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue