openh264/codec/encoder/core/inc/macros.h

/*!
 * \copy
 *     Copyright (c)  2009-2013, Cisco Systems
 *     All rights reserved.
 *
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions
 *     are met:
 *
 *        * Redistributions of source code must retain the above copyright
 *          notice, this list of conditions and the following disclaimer.
 *
 *        * Redistributions in binary form must reproduce the above copyright
 *          notice, this list of conditions and the following disclaimer in
 *          the documentation and/or other materials provided with the
 *          distribution.
 *
 *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *     POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * \file	macros.h
 *
 * \brief	MACRO based tool utilization
 *
 * \date	3/13/2009 Created
 *
 *************************************************************************************
 */
#ifndef WELS_MACRO_UTILIZATIONS_H__
#define WELS_MACRO_UTILIZATIONS_H__

//#include <math.h>
#include "typedefs.h"

namespace WelsSVCEnc {
#if defined(_MSC_VER)
#if _MSC_VER <= 1200
#define ALLOC_ALLIGN_MEM(name,size,type,alignment) \
			type name##_storage[size+(alignment)-1]; \
			type * name = (type *) (((int32_t) name##_storage+(alignment - 1)) & ~((int32_t)(alignment)-1))

#define ALLOC_ALLIGN_MEM_2(name,sizex,sizey,type,alignment) \
			type name##_storage[(sizex)*(sizey)+(alignment)-1]; \
			type * name = (type *) (((int32_t) name##_storage+(alignment - 1)) & ~((int32_t)(alignment)-1))
#else //_MSC_VER <= 1200
#define ALLOC_ALLIGN_MEM(name,size,type,alignment) \
			__declspec(align(alignment)) type name[size]

#define ALLOC_ALLIGN_MEM_2(name,sizex,sizey,type,alignment) \
		__declspec(align(alignment)) type name[(sizex)*(sizey)]
#endif//_MSC_VER <= 1200

#elif defined(__GNUC__)

#define ALLOC_ALLIGN_MEM(name,size,type,alignment) \
		type name[size] __attribute__((aligned(alignment)))
#define ALLOC_ALLIGN_MEM_2(name,sizex,sizey,type,alignment) \
		type name[(sizex)*(sizey)] __attribute__((aligned(alignment)))

#endif//_MSC_VER


#if defined(_MSC_VER)

#if(_MSC_VER < 1700)
#define inline	__inline
#endif

#define __FASTCALL   __fastcall
#define ALIGNED_DECLARE( type, var, n ) __declspec(align(n)) type var
#define __align8(t,v) __declspec(align(8)) t v
#define __align16(t,v) __declspec(align(16)) t v
#elif defined(__GNUC__)
#if !defined(MAC_POWERPC)
#define __FASTCALL    __attribute__ ((fastcall))
#else
#define __FASTCALL	// mean NULL for mac ppc
#endif//MAC_POWERPC    
#define ALIGNED_DECLARE( type, var, n ) type var __attribute__((aligned(n)))
#define __align8(t,v) t v __attribute__ ((aligned (8)))
#define __align16(t,v) t v __attribute__ ((aligned (16)))
#endif//_MSC_VER

#if defined(_MACH_PLATFORM) || defined(__GNUC__)
#define ALIGNED_DECLARE_MATRIX_2D(name,sizex,sizey,type,alignment) \
	type name[(sizex)*(sizey)] __attribute__((aligned(alignment)))
#else //_MSC_VER <= 1200
#define ALIGNED_DECLARE_MATRIX_2D(name,sizex,sizey,type,alignment) \
__declspec(align(alignment)) type name[(sizex)*(sizey)]
#endif//#if _MACH_PLATFORM

#if defined(_MACH_PLATFORM) || defined(__GNUC__)
#define ALIGNED_DECLARE_MATRIX_1D(name,size,type,alignment) \
	type name[size] __attribute__((aligned(alignment)))
#else //_MSC_VER <= 1200
#define ALIGNED_DECLARE_MATRIX_1D(name,size,type,alignment) \
	__declspec(align(alignment)) type name[(size)]
#endif//#if _MACH_PLATFORM

//#if !defined(SIZEOFRGB24)
//#define SIZEOFRGB24(cx, cy)	(3 * (cx) * (cy))
//#endif//SIZEOFRGB24

//#if !defined(SIZEOFRGB32)
//#define SIZEOFRGB32(cx, cy)	(4 * (cx) * (cy))
//#endif//SIZEOFRGB32

#ifndef	WELS_ALIGN
#define WELS_ALIGN(x, n)	(((x)+(n)-1)&~((n)-1))
#endif//WELS_ALIGN

#ifndef WELS_MAX
//#define WELS_MAX(x, y)	((x) > (y) ? (x) : (y))
//#define WELS_MAX(x, y)	((x) - (((x)-(y))&(((x)-(y))>>31)))
#define WELS_MAX(x, y)	((x) ^ (((x)^(y))& -((x)<(y))))		// WELS_MAX(x, y)
#endif//WELS_MAX

#ifndef WELS_MIN
//#define WELS_MIN(x, y)	((x) < (y) ? (x) : (y))
//#define WELS_MIN(x, y)	((y) + (((x)-(y))&(((x)-(y))>>31)))
#define WELS_MIN(x, y)	((y) ^ (((x)^(y))& -((x)<(y))))		// WELS_MIN(x, y)
#endif//WELS_MIN

#ifndef WELS_ROUND
#define WELS_ROUND(x)	((int32_t)((x)+0.5f+EPSN))
#endif//WELS_ROUND

static inline int32_t WELS_CEIL (float v) {
const int32_t n = (int32_t)v;	// floor value
return ((v > EPSN + n) ? (1 + n) : n);	// (int32_t)ceil(v);
}

static inline int32_t WELS_FLOOR (float v) {
return (int32_t)v;
}


#define WELS_NON_ZERO_COUNT_AVERAGE(iC,iA,iB) {	\
    iC = iA + iB + 1;                           \
	iC >>= (int32_t)( iA != -1 && iB != -1);    \
	iC += (iA == -1 && iB == -1);               \
}

/*
 * log base 2 of v and ceil/floor extension
 */

static inline int32_t WELS_CEILLOG2 (uint32_t v) {
int32_t r = 0;
--v;
while (v > 0) {
  ++r;
  v >>= 1;
}
return r;
}

static inline int32_t WELS_FLOORLOG2 (uint32_t v) {
int32_t r = 0;
while (v > 1) {
  ++r;
  v >>= 1;
}
return r;
}

static inline int32_t WELS_LOG2 (uint32_t v) {
int32_t r = 0;
while (v >>= 1) {
  ++r;
}
return r;

}

static inline BOOL_T WELS_POWER2_IF (uint32_t v) {
return (v && ! (v & (v - 1)));
}

static inline int32_t WELS_MEDIAN (int32_t x,  int32_t y, int32_t z) {
int32_t t = (x - y) & ((x - y) >> 31);
x -= t;
y += t;
y -= (y - z) & ((y - z) >> 31);
y += (x - y) & ((x - y) >> 31);
return y;
}

#ifndef BUTTERFLY1x2
#define BUTTERFLY1x2(b) (((b)<<8) | (b))
#endif//BUTTERFLY1x2

#ifndef BUTTERFLY2x4
#define BUTTERFLY2x4(wd) (((uint32_t)(wd)<<16) |(wd))
#endif//BUTTERFLY2x4

#ifndef BUTTERFLY4x8
#define BUTTERFLY4x8(dw) (((uint64_t)(dw)<<32) | (dw))
#endif//BUTTERFLY4x8

//when RS accumulation, should clip rs among range of [-255, 255]
#ifndef CLIP_RS
#define CLIP_RS( value ) ( WELS_MAX( WELS_MIN( value, 255 ), -255 ) )
#endif //CLIP_RS

//#ifndef NEG_NUM
//#define NEG_NUM( num ) (1+(~(num)))
//#endif// NEG_NUM

#ifndef WELS_CLIP1
#define WELS_CLIP1(x) (((x) & ~255) ? (-(x) >> 31) : (x))
#endif//WELS_CLIP1

#ifndef WELS_SIGN
#define WELS_SIGN(a) ((int32_t)(a) >> 31)	// General: (a)>>(sizeof(int)*CHAR_BIT-1), CHAR_BIT= the number of bits per byte (normally 8)
#endif //WELS_SIGN

static inline int32_t WELS_ABS (int32_t a) {
const int32_t sign = WELS_SIGN (a);
return ((a + sign) ^ sign);
}

// wels_tostring
//#ifndef wels_tostring
//#define wels_tostring(s)	#s
//#endif //wels_tostring

// WELS_CLIP3
#ifndef WELS_CLIP3
#define WELS_CLIP3(x, y, z)		((x) < (y) ? (y) : ((x) > (z) ? (z) : (x)))
#endif //WELS_CLIP3

#define CLIP3_QP_0_51(q)		WELS_CLIP3(q, 0, 51)	// ((q) < (0) ? (0) : ((q) > (51) ? (51) : (q)))

// Bitwise routines
// n: ulong
// b: bit order
static inline bool_t BITWISE_ENABLED (const uint32_t n, const uint8_t b) {
const uint8_t bit = (b & 0x1f);	// maximal bit position 31 for uint32_t 4 bytes
#if defined(WORDS_BIGENDIAN)
/*
 * 31 .. 24, 23 .. 16, 15 .. 8, 7 .. 0
 * 7 .. 0, 15 .. 8, 23 .. 16, 31 .. 24
 */
const uint8_t map = 24 + ((bit & 7) << 1) - bit;	// BIG_ENDIAN map
return (bool_t) ((n & (1 << map)) >> map);	// BIG_ENDIAN
#else
return ((n & (1 << bit)) >> bit) ? true : false;	// LITTLE_ENDIAN
#endif//WORDS_BIGENDIAN
}

#define   CALC_BI_STRIDE(width,bitcount)  ((((width * bitcount) + 31) & ~31) >> 3)

//////////////////////////////////////////////////////////

#ifdef    WORDS_BIGENDIAN

static inline uint32_t ENDIAN_FIX (uint32_t x) {
return x;
}

#else


#if defined(WIN32) && !defined(WIN64)
static inline uint32_t ENDIAN_FIX (uint32_t x) {
__asm {
  mov   eax,  x
  bswap   eax
  mov   x,    eax
}
return x;
}
#else  // GCC
static inline uint32_t ENDIAN_FIX (uint32_t x) {
#ifdef X86_ARCH
__asm__ __volatile__ ("bswap %0":"+r" (x));
#else
x = ((x & 0xff000000) >> 24) | ((x & 0xff0000) >> 8) |
    ((x & 0xff00) << 8) | ((x & 0xff) << 24);
#endif
return x;
}


#endif

#endif

// wels_swap16

// wels_swap32

// sad, satd, avg might being in other header

/*
 * Description: to check variable validation and return the specified result
 *	result:		value to be return
 *	case_if:	negative condition to be verified
 */
#ifndef WELS_VERIFY_RETURN_IF
#define WELS_VERIFY_RETURN_IF(result, case_if) \
	if ( case_if ){ \
		return result; \
	}
#endif//#if WELS_VERIFY_RETURN_IF

/*
 *	Description: to check variable validation and return the specified result
 *		with correspoinding process advance.
 *	 result:	value to be return
 *	 case_if:	negative condition to be verified
 *	 proc:		process need perform
 */
#ifndef WELS_VERIFY_RETURN_PROC_IF
#define WELS_VERIFY_RETURN_PROC_IF(result, case_if, proc) \
	if ( case_if ){ \
		proc;	\
		return result;	\
	}
#endif//#if WELS_VERIFY_RETURN_PROC_IF

/*
 * Description:	to check variable validation and return
 *	case_if:	negtive condition to be verified
 *	return:		NONE
 */
#ifndef WELS_VERIFY_IF
#define WELS_VERIFY_IF(case_if) \
	if ( case_if ){ \
		return; \
	}
#endif//#if WELS_VERIFY_IF

/*
 * Description:	to check variable validation and return with correspoinding process advance.
 *	case_if:	negtive condition to be verified
 *	proc:		process need preform
 *	return:		NONE
 */
#ifndef WELS_VERIFY_PROC_IF
#define WELS_VERIFY_PROC_IF(case_if, proc) \
	if ( case_if ){ \
		proc; \
		return; \
	}
#endif//#if WELS_VERIFY_IF

/*
 * Description: to safe free a ptr with free function pointer
 *  p:			pointer to be destroyed
 *	free_fn:	free function pointer used
 */
#ifndef WELS_SAFE_FREE_P
#define WELS_SAFE_FREE_P(p, free_fn) \
	do{ \
		if ( NULL != (p) ){ \
			free_fn( (p) ); \
			(p) = NULL; \
		} \
	}while( 0 );
#endif//#if WELS_SAFE_FREE_P

/*
 * Description: to safe free an array ptr with free function pointer
 *	arr:		pointer to an array, something like "**p";
 *	num:		number of elements in array
 *  free_fn:	free function pointer
 */
#ifndef WELS_SAFE_FREE_ARR
#define WELS_SAFE_FREE_ARR(arr, num, free_fn) \
	do{ \
		if ( NULL != (arr) ){ \
			int32_t iidx = 0; \
			while( iidx < num ){ \
				if ( NULL != (arr)[iidx] ){ \
					free_fn( (arr)[iidx] ); \
					(arr)[iidx] = NULL; \
				} \
				++ iidx; \
			} \
			free_fn((arr)); \
			(arr) = NULL; \
		} \
	}while( 0 );
#endif//#if WELS_SAFE_FREE_ARR

}

#endif//WELS_MACRO_UTILIZATIONS_H__