/*****************************************************************************
|
*
|
* Copyright (c) 2008-2010, CoreCodec, Inc.
|
* 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.
|
* * Neither the name of CoreCodec, Inc. nor the
|
* names of its contributors may be used to endorse or promote products
|
* derived from this software without specific prior written permission.
|
*
|
* THIS SOFTWARE IS PROVIDED BY CoreCodec, Inc. ``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 CoreCodec, Inc. 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.
|
*
|
****************************************************************************/
|
|
#ifndef __HELPER_H
|
#define __HELPER_H
|
|
#ifdef TARGET_LINUX
|
#include <stddef.h>
|
#define OFS(name,item) offsetof(name,item)
|
#else
|
#define OFS(name,item) ((uintptr_t)&(((name*)NULL)->item))
|
#endif
|
|
#define ALIGN64(x) (((x) + 63) & ~63)
|
#define ALIGN16(x) (((x) + 15) & ~15)
|
#define ALIGN8(x) (((x) + 7) & ~7)
|
#define ALIGN4(x) (((x) + 3) & ~3)
|
#define ALIGN2(x) (((x) + 1) & ~1)
|
|
#define GET_R(x) ((uint8_t)(((x) >> 0) & 255))
|
#define GET_G(x) ((uint8_t)(((x) >> 8) & 255))
|
#define GET_B(x) ((uint8_t)(((x) >> 16) & 255))
|
|
#define SWAP32(a) ((((uint32_t)(a) >> 24) & 0x000000FF) | (((uint32_t)(a) >> 8) & 0x0000FF00)|\
|
(((uint32_t)(a) << 8) & 0x00FF0000) | (((uint32_t)(a) << 24) & 0xFF000000))
|
|
#define SWAP16(a) ((uint16_t)((((uint32_t)(a) >> 8) & 0xFF) | (((uint32_t)(a) << 8) & 0xFF00)))
|
#define SWAP64(a) (((uint64_t)SWAP32(a) << 32) | SWAP32((uint64_t)(a)>>32))
|
|
#define LSHIFT(v,n) ((v)<<(n))
|
#define RSHIFT(v,n) ((v)>>(n))
|
#define RLSHIFT(v,n) (((n)>=0)?RSHIFT(v,n):LSHIFT(v,-(n)))
|
#define RSHIFT_ROUND(v,n) (((v)+(1<<(n-1)))>>(n))
|
#define RSHIFT_ROUND_COND(v,n) ((n)>0 ? RSHIFT_ROUND(v,n) : v)
|
|
#ifdef IS_BIG_ENDIAN
|
#define INT64BE(a) (a)
|
#define INT64LE(a) SWAP64(a)
|
#define INT32BE(a) (a)
|
#define INT32LE(a) SWAP32(a)
|
#define INT16BE(a) (a)
|
#define INT16LE(a) SWAP16(a)
|
#else
|
#define INT64LE(a) (a)
|
#define INT64BE(a) SWAP64(a)
|
#define INT32LE(a) (a)
|
#define INT32BE(a) SWAP32(a)
|
#define INT16LE(a) (a)
|
#define INT16BE(a) SWAP16(a)
|
#endif
|
|
#define LOAD8(ptr,ofs) (((uint8_t*)(ptr))[ofs])
|
#if defined(CONFIG_UNALIGNED_ACCESS)
|
#define LOAD16LE(ptr) INT16LE(*(uint16_t*)(ptr))
|
#define LOAD16BE(ptr) INT16BE(*(uint16_t*)(ptr))
|
#define LOAD32LE(ptr) INT32LE(*(uint32_t*)(ptr))
|
#define LOAD32BE(ptr) INT32BE(*(uint32_t*)(ptr))
|
#define LOAD64LE(ptr) INT64LE(*(uint64_t*)(ptr))
|
#define LOAD64BE(ptr) INT64BE(*(uint64_t*)(ptr))
|
#else
|
#define LOAD16LE(ptr) ((uint16_t)((LOAD8(ptr,1)<<8)|LOAD8(ptr,0)))
|
#define LOAD16BE(ptr) ((uint16_t)((LOAD8(ptr,0)<<8)|LOAD8(ptr,1)))
|
#define LOAD32LE(ptr) ((LOAD8(ptr,3)<<24)|(LOAD8(ptr,2)<<16)|(LOAD8(ptr,1)<<8)|LOAD8(ptr,0))
|
#define LOAD32BE(ptr) ((LOAD8(ptr,0)<<24)|(LOAD8(ptr,1)<<16)|(LOAD8(ptr,2)<<8)|LOAD8(ptr,3))
|
#define LOAD64LE(ptr) ((((uint64_t)LOAD8(ptr,0)) )|(((uint64_t)LOAD8(ptr,1))<< 8)|(((uint64_t)LOAD8(ptr,2))<<16)|(((uint64_t)LOAD8(ptr,3))<<24)| \
|
(((uint64_t)LOAD8(ptr,4))<<32)|(((uint64_t)LOAD8(ptr,5))<<40)|(((uint64_t)LOAD8(ptr,6))<<48)|(((uint64_t)LOAD8(ptr,0))<<56))
|
#define LOAD64BE(ptr) ((((uint64_t)LOAD8(ptr,0))<<56)|(((uint64_t)LOAD8(ptr,1))<<48)|(((uint64_t)LOAD8(ptr,2))<<40)|(((uint64_t)LOAD8(ptr,3))<<32)| \
|
(((uint64_t)LOAD8(ptr,4))<<24)|(((uint64_t)LOAD8(ptr,5))<<16)|(((uint64_t)LOAD8(ptr,6))<< 8)|(((uint64_t)LOAD8(ptr,0)) ))
|
#endif
|
|
|
#define STORE8(p, o, i) ((uint8_t *) (p))[o] = (uint8_t) ((i) & 0xFF)
|
|
#if defined(CONFIG_UNALIGNED_ACCESS) && defined(IS_BIG_ENDIAN)
|
|
#define STORE16BE(p, i) *((uint16_t*)(p))=i
|
#define STORE32BE(p, i) *((uint32_t*)(p))=i
|
#define STORE64BE(p, i) *((uint64_t*)(p))=i
|
#else
|
#define STORE16BE(p, i) STORE8(p, 1, i), STORE8(p, 0, ((uint16_t)i) >> 8)
|
#define STORE32BE(p, i) STORE8(p, 3, i), STORE8(p, 2, ((uint32_t)i) >> 8), STORE8(p, 1, ((uint32_t) i) >> 16), STORE8(p, 0, ((uint32_t) i) >> 24)
|
#define STORE64BE(p, i) STORE8(p, 7, i), STORE8(p, 6, ((uint64_t)i) >> 8), STORE8(p, 5, ((uint64_t)i) >> 16), STORE8(p, 4, ((uint64_t)i) >> 24), \
|
STORE8(p, 3, ((uint64_t)i) >> 32), STORE8(p, 2, ((uint64_t)i) >> 40), STORE8(p, 1, ((uint64_t)i) >> 48), STORE8(p, 0, ((uint64_t)i) >> 56)
|
#endif
|
|
#if defined(CONFIG_UNALIGNED_ACCESS) && defined(IS_LITTLE_ENDIAN)
|
#define STORE16LE(p, i) *((uint16_t*)(p))=i
|
#define STORE32LE(p, i) *((uint32_t*)(p))=i
|
#define STORE64LE(p, i) *((uint64_t*)(p))=i
|
#else
|
#define STORE16LE(p, i) STORE8(p, 0, i), STORE8(p, 1, ((uint16_t)i) >> 8)
|
#define STORE32LE(p, i) STORE8(p, 0, i), STORE8(p, 1, ((uint32_t)i) >> 8), STORE8(p, 2, ((uint32_t)i) >> 16), STORE8(p, 3, ((uint32_t)i) >> 24)
|
#define STORE64LE(p, i) STORE8(p, 0, i), STORE8(p, 1, ((uint64_t)i) >> 8), STORE8(p, 2, ((uint64_t)i) >> 16), STORE8(p, 3, ((uint64_t)i) >> 24), \
|
STORE8(p, 4, ((uint64_t)i) >> 32), STORE8(p, 5, ((uint64_t)i) >> 40), STORE8(p, 6, ((uint64_t)i) >> 48), STORE8(p, 7, ((uint64_t)i) >> 56)
|
#endif
|
|
#ifdef IS_BIG_ENDIAN
|
#define LOAD16(ptr) LOAD16BE(ptr)
|
#define LOAD32(ptr) LOAD32BE(ptr)
|
#define LOAD64(ptr) LOAD64BE(ptr)
|
#define LOAD16SW(ptr) LOAD16LE(ptr)
|
#define LOAD32SW(ptr) LOAD32LE(ptr)
|
#define LOAD64SW(ptr) LOAD64LE(ptr)
|
#else
|
#define LOAD16(ptr) LOAD16LE(ptr)
|
#define LOAD32(ptr) LOAD32LE(ptr)
|
#define LOAD64(ptr) LOAD64LE(ptr)
|
#define LOAD16SW(ptr) LOAD16BE(ptr)
|
#define LOAD32SW(ptr) LOAD32BE(ptr)
|
#define LOAD64SW(ptr) LOAD64BE(ptr)
|
#endif
|
|
#if defined(__GNUC__) && defined(MIPS)
|
#undef LOAD32
|
static INLINE uint32_t LOAD32(const void* ptr) { uint32_t v; asm ("ulw %0,0(%1)\n" : "=&r" (v) : "r" (ptr)); return v; }
|
#endif
|
|
// a=(a+c+1)/2
|
// b=(b+d+1)/2
|
#define AVG32R(a,b,c,d) \
|
c^=a; \
|
d^=b; \
|
a|=c; \
|
b|=d; \
|
c &= 0xFEFEFEFE; \
|
d &= 0xFEFEFEFE; \
|
a-=c>>1; \
|
b-=d>>1;
|
|
#define AVG64R(a,b,c,d) \
|
c^=a; \
|
d^=b; \
|
a|=c; \
|
b|=d; \
|
c &= 0xFEFEFEFEFEFEFEFE; \
|
d &= 0xFEFEFEFEFEFEFEFE; \
|
a-=c>>1; \
|
b-=d>>1;
|
|
// a=(a+c)/2
|
// b=(b+d)/2
|
#ifdef ARM
|
#define AVG32NR(a,b,c,d) \
|
c^=a; \
|
d^=b; \
|
a &= ~c; \
|
b &= ~d; \
|
c &= 0xFEFEFEFE; \
|
d &= 0xFEFEFEFE; \
|
a+=c>>1; \
|
b+=d>>1;
|
#else
|
#define AVG32NR(a,b,c,d) \
|
c^=a; \
|
d^=b; \
|
a|=c; \
|
b|=d; \
|
a-=c & 0x01010101; \
|
b-=d & 0x01010101; \
|
c &= 0xFEFEFEFE; \
|
d &= 0xFEFEFEFE; \
|
a-=c>>1; \
|
b-=d>>1;
|
#endif
|
|
#define AVG64NR(a,b,c,d) \
|
c^=a; \
|
d^=b; \
|
a|=c; \
|
b|=d; \
|
a-=c & 0x0101010101010101; \
|
b-=d & 0x0101010101010101; \
|
c &= 0xFEFEFEFEFEFEFEFE; \
|
d &= 0xFEFEFEFEFEFEFEFE; \
|
a-=c>>1; \
|
b-=d>>1;
|
|
#define _abs(a) (((a)>=0)?(a):-(a))
|
|
static INLINE int MIDDLE(int a, int b, int c)
|
{
|
int bb = b;
|
|
if (a > b)
|
{
|
bb = a;
|
a = b;
|
}
|
|
if (bb > c)
|
bb = c;
|
|
if (a > bb)
|
bb = a;
|
|
return bb;
|
}
|
|
static INLINE size_t _log2(uint32_t data)
|
{
|
size_t i;
|
if (!data) ++data;
|
for (i=0;data;++i)
|
data >>= 1;
|
return i;
|
}
|
|
static INLINE int64_t Scale64(int64_t v,int64_t Num,int64_t Den)
|
{
|
if (Den)
|
return (v * Num) / Den;
|
return 0;
|
}
|
|
static INLINE int Scale32(int64_t v, int64_t Num, int64_t Den)
|
{
|
return (int)Scale64(v,Num,Den);
|
}
|
|
#define SWAPVAL(type,a,b) { type __t = (a); (a)=(b); (b)=__t; }
|
|
typedef int32_t datetime_t;
|
|
#define INVALID_DATETIME_T 0
|
#define MIN_DATETIME_T ((datetime_t) 0xFFFFFFFF)
|
#define MAX_DATETIME_T ((datetime_t) 0x7FFFFFFF)
|
|
static INLINE int Fix16Mul(int a,int b)
|
{
|
return (int)(((int64_t)(a<<8)*(int64_t)(b<<8))>>32);
|
}
|
|
static INLINE uint32_t _ones(uint32_t x)
|
{
|
x -= ((x >> 1) & 0x55555555);
|
x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
|
x = (((x >> 4) + x) & 0x0f0f0f0f);
|
x += (x >> 8);
|
x += (x >> 16);
|
return x & 0x0000003f;
|
}
|
|
static INLINE uint32_t _floor_log2(uint32_t x)
|
{
|
x |= (x >> 1);
|
x |= (x >> 2);
|
x |= (x >> 4);
|
x |= (x >> 8);
|
x |= (x >> 16);
|
return _ones(x) - 1;
|
}
|
|
#if !defined(min) && !defined(NOMINMAX)
|
# define min(x,y) ((x)>(y)?(y):(x))
|
#endif
|
|
#if !defined(max) && !defined(NOMINMAX)
|
# define max(x,y) ((x)<(y)?(y):(x))
|
#endif
|
|
#ifndef sign
|
# define sign(x) ((x)<0?-1:1)
|
#endif
|
|
#define abs_diff(x,y) ((x)>(y)?((x)-(y)):((y)-(x)))
|
|
#endif
|
