openharmony/third_party_ffmpeg
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_ffmpeg synced 2024-11-24 03:39:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Pure, const and malloc attributes to libavutil.

Browse Source 
Patch by Zuxy Meng: zuxy meng gmail com
Original thread:
[FFmpeg-devel] [PATCH] Pure, const and malloc attributes to libavutil
Date: 03/18/2008 6:09 AM

Originally committed as revision 12489 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Zuxy Meng 2008-03-18 15:27:15 +00:00 committed by Benoit Fouet
parent 38c669d853
commit 6544f48f03
13 changed files with 78 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libavutil/adler32.h
View File

@ -24,6 +24,6 @@
#include <stdint.h>
unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf,
unsigned int len);
unsigned int len) av_pure;
#endif /* FFMPEG_ADLER32_H */

6
libavutil/bswap.h
View File

@ -40,7 +40,7 @@
# define LEGACY_REGS "=q"
#endif
static av_always_inline uint16_t bswap_16(uint16_t x)
static av_always_inline av_const uint16_t bswap_16(uint16_t x)
{
#if defined(ARCH_X86)
__asm("rorw $8, %0" :
@ -54,7 +54,7 @@ static av_always_inline uint16_t bswap_16(uint16_t x)
return x;
}
static av_always_inline uint32_t bswap_32(uint32_t x)
static av_always_inline av_const uint32_t bswap_32(uint32_t x)
{
#if defined(ARCH_X86)
#ifdef HAVE_BSWAP
@ -93,7 +93,7 @@ static av_always_inline uint32_t bswap_32(uint32_t x)
return x;
}
static inline uint64_t bswap_64(uint64_t x)
static inline uint64_t av_const bswap_64(uint64_t x)
{
#if 0
x= ((x<< 8)&0xFF00FF00FF00FF00ULL) | ((x>> 8)&0x00FF00FF00FF00FFULL);

32
libavutil/common.h
View File

@ -57,6 +57,22 @@
#endif
#endif
#ifndef av_pure
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
# define av_pure __attribute__((pure))
#else
# define av_pure
#endif
#endif
#ifndef av_const
#if defined(__GNUC__) && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ > 5)
# define av_const __attribute__((const))
#else
# define av_const
#endif
#endif
#ifdef HAVE_AV_CONFIG_H
# include "internal.h"
#endif /* HAVE_AV_CONFIG_H */
@ -94,7 +110,7 @@
/* misc math functions */
extern const uint8_t ff_log2_tab[256];
static inline int av_log2(unsigned int v)
static inline av_const int av_log2(unsigned int v)
{
int n = 0;
if (v & 0xffff0000) {
@ -110,7 +126,7 @@ static inline int av_log2(unsigned int v)
return n;
}
static inline int av_log2_16bit(unsigned int v)
static inline av_const int av_log2_16bit(unsigned int v)
{
int n = 0;
if (v & 0xff00) {
@ -123,7 +139,7 @@ static inline int av_log2_16bit(unsigned int v)
}
/* median of 3 */
static inline int mid_pred(int a, int b, int c)
static inline av_const int mid_pred(int a, int b, int c)
{
#ifdef HAVE_CMOV
int i=b;
@ -170,7 +186,7 @@ static inline int mid_pred(int a, int b, int c)
* @param amax maximum value of the clip range
* @return clipped value
*/
static inline int av_clip(int a, int amin, int amax)
static inline av_const int av_clip(int a, int amin, int amax)
{
if (a < amin) return amin;
else if (a > amax) return amax;
@ -182,7 +198,7 @@ static inline int av_clip(int a, int amin, int amax)
* @param a value to clip
* @return clipped value
*/
static inline uint8_t av_clip_uint8(int a)
static inline av_const uint8_t av_clip_uint8(int a)
{
if (a&(~255)) return (-a)>>31;
else return a;
@ -193,19 +209,19 @@ static inline uint8_t av_clip_uint8(int a)
* @param a value to clip
* @return clipped value
*/
static inline int16_t av_clip_int16(int a)
static inline av_const int16_t av_clip_int16(int a)
{
if ((a+32768) & ~65535) return (a>>31) ^ 32767;
else return a;
}
/* math */
int64_t ff_gcd(int64_t a, int64_t b);
int64_t av_const ff_gcd(int64_t a, int64_t b);
/**
* converts fourcc string to int
*/
static inline int ff_get_fourcc(const char *s){
static inline av_pure int ff_get_fourcc(const char *s){
#ifdef HAVE_AV_CONFIG_H
assert( strlen(s)==4 );
#endif

2
libavutil/crc.h
View File

@ -37,7 +37,7 @@ typedef enum {
int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size);
const AVCRC *av_crc_get_table(AVCRCId crc_id);
uint32_t av_crc(const AVCRC *ctx, uint32_t start_crc, const uint8_t *buffer, size_t length);
uint32_t av_crc(const AVCRC *ctx, uint32_t start_crc, const uint8_t *buffer, size_t length) av_pure;
#endif /* FFMPEG_CRC_H */

1
libavutil/des.c
View File

@ -19,6 +19,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <inttypes.h>
#include "common.h"
#include "des.h"
#define T(a, b, c, d, e, f, g, h) 64-a,64-b,64-c,64-d,64-e,64-f,64-g,64-h

2
libavutil/des.h
View File

@ -34,6 +34,6 @@
* If your input data is in 8-bit blocks treat it as big-endian
* (use e.g. AV_RB64 and AV_WB64).
*/
uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt);
uint64_t ff_des_encdec(uint64_t in, uint64_t key, int decrypt) av_const;
#endif /* FFMPEG_DES_H */

18
libavutil/integer.h
View File

@ -36,26 +36,26 @@ typedef struct AVInteger{
uint16_t v[AV_INTEGER_SIZE];
} AVInteger;
AVInteger av_add_i(AVInteger a, AVInteger b);
AVInteger av_sub_i(AVInteger a, AVInteger b);
AVInteger av_add_i(AVInteger a, AVInteger b) av_const;
AVInteger av_sub_i(AVInteger a, AVInteger b) av_const;
/**
* returns the rounded down value of the logarithm of base 2 of the given AVInteger.
* this is simply the index of the most significant bit which is 1. Or 0 of all bits are 0
*/
int av_log2_i(AVInteger a);
AVInteger av_mul_i(AVInteger a, AVInteger b);
int av_log2_i(AVInteger a) av_const;
AVInteger av_mul_i(AVInteger a, AVInteger b) av_const;
/**
* returns 0 if a==b, 1 if a>b and -1 if a<b.
*/
int av_cmp_i(AVInteger a, AVInteger b);
int av_cmp_i(AVInteger a, AVInteger b) av_const;
/**
* bitwise shift.
* @param s the number of bits by which the value should be shifted right, may be negative for shifting left
*/
AVInteger av_shr_i(AVInteger a, int s);
AVInteger av_shr_i(AVInteger a, int s) av_const;
/**
* returns a % b.
@ -66,18 +66,18 @@ AVInteger av_mod_i(AVInteger *quot, AVInteger a, AVInteger b);
/**
* returns a/b.
*/
AVInteger av_div_i(AVInteger a, AVInteger b);
AVInteger av_div_i(AVInteger a, AVInteger b) av_const;
/**
* converts the given int64_t to an AVInteger.
*/
AVInteger av_int2i(int64_t a);
AVInteger av_int2i(int64_t a) av_const;
/**
* converts the given AVInteger to an int64_t.
* if the AVInteger is too large to fit into an int64_t,
* then only the least significant 64bit will be used
*/
int64_t av_i2int(AVInteger a);
int64_t av_i2int(AVInteger a) av_const;
#endif /* FFMPEG_INTEGER_H */

12
libavutil/internal.h
View File

@ -172,7 +172,7 @@ extern const uint8_t ff_sqrt_tab[256];
static inline int av_log2_16bit(unsigned int v);
static inline unsigned int ff_sqrt(unsigned int a)
static inline av_const unsigned int ff_sqrt(unsigned int a)
{
unsigned int b;
@ -267,35 +267,35 @@ if((y)<(x)){\
}
#ifndef HAVE_LLRINT
static av_always_inline long long llrint(double x)
static av_always_inline av_const long long llrint(double x)
{
return rint(x);
}
#endif /* HAVE_LLRINT */
#ifndef HAVE_LRINT
static av_always_inline long int lrint(double x)
static av_always_inline av_const long int lrint(double x)
{
return rint(x);
}
#endif /* HAVE_LRINT */
#ifndef HAVE_LRINTF
static av_always_inline long int lrintf(float x)
static av_always_inline av_const long int lrintf(float x)
{
return (int)(rint(x));
}
#endif /* HAVE_LRINTF */
#ifndef HAVE_ROUND
static av_always_inline double round(double x)
static av_always_inline av_const double round(double x)
{
return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5);
}
#endif /* HAVE_ROUND */
#ifndef HAVE_ROUNDF
static av_always_inline float roundf(float x)
static av_always_inline av_const float roundf(float x)
{
return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5);
}

12
libavutil/intfloat_readwrite.h
View File

@ -30,11 +30,11 @@ typedef struct AVExtFloat {
uint8_t mantissa[8];
} AVExtFloat;
double av_int2dbl(int64_t v);
float av_int2flt(int32_t v);
double av_ext2dbl(const AVExtFloat ext);
int64_t av_dbl2int(double d);
int32_t av_flt2int(float d);
AVExtFloat av_dbl2ext(double d);
double av_int2dbl(int64_t v) av_const;
float av_int2flt(int32_t v) av_const;
double av_ext2dbl(const AVExtFloat ext) av_const;
int64_t av_dbl2int(double d) av_const;
int32_t av_flt2int(float d) av_const;
AVExtFloat av_dbl2ext(double d) av_const;
#endif /* FFMPEG_INTFLOAT_READWRITE_H */

6
libavutil/mathematics.h
View File

@ -36,17 +36,17 @@ enum AVRounding {
* rescale a 64bit integer with rounding to nearest.
* a simple a*b/c isn't possible as it can overflow
*/
int64_t av_rescale(int64_t a, int64_t b, int64_t c);
int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
/**
* rescale a 64bit integer with specified rounding.
* a simple a*b/c isn't possible as it can overflow
*/
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding);
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const;
/**
* rescale a 64bit integer by 2 rational numbers.
*/
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq);
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
#endif /* FFMPEG_MATHEMATICS_H */

12
libavutil/mem.h
View File

@ -42,6 +42,12 @@
#define DECLARE_ASM_CONST(n,t,v) static const t v
#endif
#ifdef __GNUC__
#define av_malloc_attrib __attribute__((__malloc__))
#else
#define av_malloc_attrib
#endif
/**
* Allocate a block of \p size bytes with alignment suitable for all
* memory accesses (including vectors if available on the CPU).
@ -50,7 +56,7 @@
* it.
* @see av_mallocz()
*/
void *av_malloc(unsigned int size);
void *av_malloc(unsigned int size) av_malloc_attrib;
/**
* Allocate or reallocate a block of memory.
@ -85,7 +91,7 @@ void av_free(void *ptr);
* it.
* @see av_malloc()
*/
void *av_mallocz(unsigned int size);
void *av_mallocz(unsigned int size) av_malloc_attrib;
/**
* Duplicate the string \p s.
@ -93,7 +99,7 @@ void *av_mallocz(unsigned int size);
* @return Pointer to a newly allocated string containing a
* copy of \p s or NULL if it cannot be allocated.
*/
char *av_strdup(const char *s);
char *av_strdup(const char *s) av_malloc_attrib;
/**
* Free a memory block which has been allocated with av_malloc(z)() or

10
libavutil/rational.h
View File

@ -78,7 +78,7 @@ int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max)
* @param c second rational.
* @return b*c.
*/
AVRational av_mul_q(AVRational b, AVRational c);
AVRational av_mul_q(AVRational b, AVRational c) av_const;
/**
* Divides one rational by another.
@ -86,7 +86,7 @@ AVRational av_mul_q(AVRational b, AVRational c);
* @param c second rational.
* @return b/c.
*/
AVRational av_div_q(AVRational b, AVRational c);
AVRational av_div_q(AVRational b, AVRational c) av_const;
/**
* Adds two rationals.
@ -94,7 +94,7 @@ AVRational av_div_q(AVRational b, AVRational c);
* @param c second rational.
* @return b+c.
*/
AVRational av_add_q(AVRational b, AVRational c);
AVRational av_add_q(AVRational b, AVRational c) av_const;
/**
* Subtracts one rational from another.
@ -102,7 +102,7 @@ AVRational av_add_q(AVRational b, AVRational c);
* @param c second rational.
* @return b-c.
*/
AVRational av_sub_q(AVRational b, AVRational c);
AVRational av_sub_q(AVRational b, AVRational c) av_const;
/**
* Converts a double precision floating point number to a rational.
@ -110,6 +110,6 @@ AVRational av_sub_q(AVRational b, AVRational c);
* @param max the maximum allowed numerator and denominator
* @return (AVRational) d.
*/
AVRational av_d2q(double d, int max);
AVRational av_d2q(double d, int max) av_const;
#endif /* FFMPEG_RATIONAL_H */

18
libavutil/softfloat.h
View File

@ -32,7 +32,7 @@ typedef struct SoftFloat{
int32_t mant;
}SoftFloat;
static SoftFloat av_normalize_sf(SoftFloat a){
static av_const SoftFloat av_normalize_sf(SoftFloat a){
if(a.mant){
#if 1
while((a.mant + 0x20000000U)<0x40000000U){
@ -54,7 +54,7 @@ static SoftFloat av_normalize_sf(SoftFloat a){
return a;
}
static inline SoftFloat av_normalize1_sf(SoftFloat a){
static inline av_const SoftFloat av_normalize1_sf(SoftFloat a){
#if 1
if(a.mant + 0x40000000 < 0){
a.exp++;
@ -76,7 +76,7 @@ static inline SoftFloat av_normalize1_sf(SoftFloat a){
* normalized then the output wont be worse then the other input
* if both are normalized then the output will be normalized
*/
static inline SoftFloat av_mul_sf(SoftFloat a, SoftFloat b){
static inline av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b){
a.exp += b.exp;
a.mant = (a.mant * (int64_t)b.mant) >> ONE_BITS;
return av_normalize1_sf(a);
@ -87,31 +87,31 @@ static inline SoftFloat av_mul_sf(SoftFloat a, SoftFloat b){
* b has to be normalized and not zero
* @return will not be more denormalized then a
*/
static SoftFloat av_div_sf(SoftFloat a, SoftFloat b){
static av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b){
a.exp -= b.exp+1;
a.mant = ((int64_t)a.mant<<(ONE_BITS+1)) / b.mant;
return av_normalize1_sf(a);
}
static inline int av_cmp_sf(SoftFloat a, SoftFloat b){
static inline av_const int av_cmp_sf(SoftFloat a, SoftFloat b){
int t= a.exp - b.exp;
if(t<0) return (a.mant >> (-t)) - b.mant ;
else return a.mant - (b.mant >> t);
}
static inline SoftFloat av_add_sf(SoftFloat a, SoftFloat b){
static inline av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b){
int t= a.exp - b.exp;
if(t<0) return av_normalize1_sf((SoftFloat){b.exp, b.mant + (a.mant >> (-t))});
else return av_normalize1_sf((SoftFloat){a.exp, a.mant + (b.mant >> t )});
}
static inline SoftFloat av_sub_sf(SoftFloat a, SoftFloat b){
static inline av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b){
return av_add_sf(a, (SoftFloat){b.exp, -b.mant});
}
//FIXME sqrt, log, exp, pow, sin, cos
static inline SoftFloat av_int2sf(int v, int frac_bits){
static inline av_const SoftFloat av_int2sf(int v, int frac_bits){
return av_normalize_sf((SoftFloat){ONE_BITS-frac_bits, v});
}
@ -119,7 +119,7 @@ static inline SoftFloat av_int2sf(int v, int frac_bits){
*
* rounding is to -inf
*/
static inline int av_sf2int(SoftFloat v, int frac_bits){
static inline av_const int av_sf2int(SoftFloat v, int frac_bits){
v.exp += frac_bits - ONE_BITS;
if(v.exp >= 0) return v.mant << v.exp ;
else return v.mant >>(-v.exp);