diff options
Diffstat (limited to 'include/core')
-rw-r--r-- | include/core/SkFDot6.h | 58 | ||||
-rw-r--r-- | include/core/SkMath.h | 196 |
2 files changed, 63 insertions, 191 deletions
diff --git a/include/core/SkFDot6.h b/include/core/SkFDot6.h deleted file mode 100644 index aa588572f8..0000000000 --- a/include/core/SkFDot6.h +++ /dev/null @@ -1,58 +0,0 @@ - -/* - * Copyright 2006 The Android Open Source Project - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - - -#ifndef SkFDot6_DEFINED -#define SkFDot6_DEFINED - -#include "SkMath.h" - -typedef int32_t SkFDot6; - -#define SK_FDot6One (64) -#define SK_FDot6Half (32) - -#ifdef SK_DEBUG - inline SkFDot6 SkIntToFDot6(S16CPU x) { - SkASSERT(SkToS16(x) == x); - return x << 6; - } -#else - #define SkIntToFDot6(x) ((x) << 6) -#endif - -#define SkFDot6Floor(x) ((x) >> 6) -#define SkFDot6Ceil(x) (((x) + 63) >> 6) -#define SkFDot6Round(x) (((x) + 32) >> 6) - -#define SkFixedToFDot6(x) ((x) >> 10) - -inline SkFixed SkFDot6ToFixed(SkFDot6 x) { - SkASSERT((x << 10 >> 10) == x); - - return x << 10; -} - -#ifdef SK_SCALAR_IS_FLOAT - #define SkScalarToFDot6(x) (SkFDot6)((x) * 64) -#else - #define SkScalarToFDot6(x) ((x) >> 10) -#endif - -inline SkFixed SkFDot6Div(SkFDot6 a, SkFDot6 b) { - SkASSERT(b != 0); - - if (a == (int16_t)a) { - return (a << 16) / b; - } else { - return SkFixedDiv(a, b); - } -} - -#endif - diff --git a/include/core/SkMath.h b/include/core/SkMath.h index 7a4b707ce7..42f830cf2f 100644 --- a/include/core/SkMath.h +++ b/include/core/SkMath.h @@ -12,68 +12,51 @@ #include "SkTypes.h" -//! Returns the number of leading zero bits (0...32) -int SkCLZ_portable(uint32_t); - -/** Computes the 64bit product of a * b, and then shifts the answer down by - shift bits, returning the low 32bits. shift must be [0..63] - e.g. to perform a fixedmul, call SkMulShift(a, b, 16) -*/ -int32_t SkMulShift(int32_t a, int32_t b, unsigned shift); - -/** Computes numer1 * numer2 / denom in full 64 intermediate precision. - It is an error for denom to be 0. There is no special handling if - the result overflows 32bits. -*/ +/** + * Computes numer1 * numer2 / denom in full 64 intermediate precision. + * It is an error for denom to be 0. There is no special handling if + * the result overflows 32bits. + */ int32_t SkMulDiv(int32_t numer1, int32_t numer2, int32_t denom); -/** Computes (numer1 << shift) / denom in full 64 intermediate precision. - It is an error for denom to be 0. There is no special handling if - the result overflows 32bits. -*/ +/** + * Computes (numer1 << shift) / denom in full 64 intermediate precision. + * It is an error for denom to be 0. There is no special handling if + * the result overflows 32bits. + */ int32_t SkDivBits(int32_t numer, int32_t denom, int shift); -/** Return the integer square root of value, with a bias of bitBias -*/ +/** + * Return the integer square root of value, with a bias of bitBias + */ int32_t SkSqrtBits(int32_t value, int bitBias); -/** Return the integer square root of n, treated as a SkFixed (16.16) -*/ -#define SkSqrt32(n) SkSqrtBits(n, 15) +/////////////////////////////////////////////////////////////////////////////// -/** Return the integer cube root of value, with a bias of bitBias - */ -int32_t SkCubeRootBits(int32_t value, int bitBias); - -/** Returns -1 if n < 0, else returns 0 -*/ -#define SkExtractSign(n) ((int32_t)(n) >> 31) - -/** If sign == -1, returns -n, else sign must be 0, and returns n. - Typically used in conjunction with SkExtractSign(). -*/ -static inline int32_t SkApplySign(int32_t n, int32_t sign) { - SkASSERT(sign == 0 || sign == -1); - return (n ^ sign) - sign; -} +//! Returns the number of leading zero bits (0...32) +int SkCLZ_portable(uint32_t); -/** Return x with the sign of y */ -static inline int32_t SkCopySign32(int32_t x, int32_t y) { - return SkApplySign(x, SkExtractSign(x ^ y)); -} +#if defined(__arm__) + #define SkCLZ(x) __builtin_clz(x) +#endif + +#ifndef SkCLZ + #define SkCLZ(x) SkCLZ_portable(x) +#endif -/** Returns (value < 0 ? 0 : value) efficiently (i.e. no compares or branches) -*/ +/** + * Returns (value < 0 ? 0 : value) efficiently (i.e. no compares or branches) + */ static inline int SkClampPos(int value) { return value & ~(value >> 31); } /** Given an integer and a positive (max) integer, return the value - pinned against 0 and max, inclusive. - @param value The value we want returned pinned between [0...max] - @param max The positive max value - @return 0 if value < 0, max if value > max, else value -*/ + * pinned against 0 and max, inclusive. + * @param value The value we want returned pinned between [0...max] + * @param max The positive max value + * @return 0 if value < 0, max if value > max, else value + */ static inline int SkClampMax(int value, int max) { // ensure that max is positive SkASSERT(max >= 0); @@ -86,62 +69,33 @@ static inline int SkClampMax(int value, int max) { return value; } -/** Given a positive value and a positive max, return the value - pinned against max. - Note: only works as long as max - value doesn't wrap around - @return max if value >= max, else value -*/ -static inline unsigned SkClampUMax(unsigned value, unsigned max) { -#ifdef SK_CPU_HAS_CONDITIONAL_INSTR - if (value > max) { - value = max; - } - return value; -#else - int diff = max - value; - // clear diff if diff is positive - diff &= diff >> 31; - - return value + diff; -#endif -} - -/////////////////////////////////////////////////////////////////////////////// - -#if defined(__arm__) - #define SkCLZ(x) __builtin_clz(x) -#endif - -#ifndef SkCLZ - #define SkCLZ(x) SkCLZ_portable(x) -#endif - -/////////////////////////////////////////////////////////////////////////////// - -/** Returns the smallest power-of-2 that is >= the specified value. If value - is already a power of 2, then it is returned unchanged. It is undefined - if value is <= 0. -*/ +/** + * Returns the smallest power-of-2 that is >= the specified value. If value + * is already a power of 2, then it is returned unchanged. It is undefined + * if value is <= 0. + */ static inline int SkNextPow2(int value) { SkASSERT(value > 0); return 1 << (32 - SkCLZ(value - 1)); } -/** Returns the log2 of the specified value, were that value to be rounded up - to the next power of 2. It is undefined to pass 0. Examples: - SkNextLog2(1) -> 0 - SkNextLog2(2) -> 1 - SkNextLog2(3) -> 2 - SkNextLog2(4) -> 2 - SkNextLog2(5) -> 3 -*/ +/** + * Returns the log2 of the specified value, were that value to be rounded up + * to the next power of 2. It is undefined to pass 0. Examples: + * SkNextLog2(1) -> 0 + * SkNextLog2(2) -> 1 + * SkNextLog2(3) -> 2 + * SkNextLog2(4) -> 2 + * SkNextLog2(5) -> 3 + */ static inline int SkNextLog2(uint32_t value) { SkASSERT(value != 0); return 32 - SkCLZ(value - 1); } -/** Returns true if value is a power of 2. Does not explicitly check for - value <= 0. +/** + * Returns true if value is a power of 2. Does not explicitly check for + * value <= 0. */ static inline bool SkIsPow2(int value) { return (value & (value - 1)) == 0; @@ -149,10 +103,11 @@ static inline bool SkIsPow2(int value) { /////////////////////////////////////////////////////////////////////////////// -/** SkMulS16(a, b) multiplies a * b, but requires that a and b are both int16_t. - With this requirement, we can generate faster instructions on some - architectures. -*/ +/** + * SkMulS16(a, b) multiplies a * b, but requires that a and b are both int16_t. + * With this requirement, we can generate faster instructions on some + * architectures. + */ #ifdef SK_ARM_HAS_EDSP static inline int32_t SkMulS16(S16CPU x, S16CPU y) { SkASSERT((int16_t)x == x); @@ -176,39 +131,10 @@ static inline bool SkIsPow2(int value) { #endif #endif -/** Return a*b/255, truncating away any fractional bits. Only valid if both - a and b are 0..255 -*/ -static inline U8CPU SkMulDiv255Trunc(U8CPU a, U8CPU b) { - SkASSERT((uint8_t)a == a); - SkASSERT((uint8_t)b == b); - unsigned prod = SkMulS16(a, b) + 1; - return (prod + (prod >> 8)) >> 8; -} - -/** Return a*b/255, rounding any fractional bits. Only valid if both - a and b are 0..255 +/** + * Return a*b/((1 << shift) - 1), rounding any fractional bits. + * Only valid if a and b are unsigned and <= 32767 and shift is > 0 and <= 8 */ -static inline U8CPU SkMulDiv255Round(U8CPU a, U8CPU b) { - SkASSERT((uint8_t)a == a); - SkASSERT((uint8_t)b == b); - unsigned prod = SkMulS16(a, b) + 128; - return (prod + (prod >> 8)) >> 8; -} - -/** Return (a*b)/255, taking the ceiling of any fractional bits. Only valid if - both a and b are 0..255. The expected result equals (a * b + 254) / 255. - */ -static inline U8CPU SkMulDiv255Ceiling(U8CPU a, U8CPU b) { - SkASSERT((uint8_t)a == a); - SkASSERT((uint8_t)b == b); - unsigned prod = SkMulS16(a, b) + 255; - return (prod + (prod >> 8)) >> 8; -} - -/** Return a*b/((1 << shift) - 1), rounding any fractional bits. - Only valid if a and b are unsigned and <= 32767 and shift is > 0 and <= 8 -*/ static inline unsigned SkMul16ShiftRound(unsigned a, unsigned b, int shift) { SkASSERT(a <= 32767); SkASSERT(b <= 32767); @@ -217,10 +143,14 @@ static inline unsigned SkMul16ShiftRound(unsigned a, unsigned b, int shift) { return (prod + (prod >> shift)) >> shift; } -/** Just the rounding step in SkDiv255Round: round(value / 255) +/** + * Return a*b/255, rounding any fractional bits. Only valid if both + * a and b are 0..255 */ -static inline unsigned SkDiv255Round(unsigned prod) { - prod += 128; +static inline U8CPU SkMulDiv255Round(U8CPU a, U8CPU b) { + SkASSERT((uint8_t)a == a); + SkASSERT((uint8_t)b == b); + unsigned prod = SkMulS16(a, b) + 128; return (prod + (prod >> 8)) >> 8; } |