340 lines
8.6 KiB
C++
340 lines
8.6 KiB
C++
/* libs/pixelflinger/fixed.cpp
|
|
**
|
|
** Copyright 2006, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <private/pixelflinger/ggl_context.h>
|
|
#include <private/pixelflinger/ggl_fixed.h>
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
int32_t gglRecipQNormalized(int32_t x, int* exponent)
|
|
{
|
|
const int32_t s = x>>31;
|
|
uint32_t a = s ? -x : x;
|
|
|
|
// the result will overflow, so just set it to the biggest/inf value
|
|
if (ggl_unlikely(a <= 2LU)) {
|
|
*exponent = 0;
|
|
return s ? FIXED_MIN : FIXED_MAX;
|
|
}
|
|
|
|
// Newton-Raphson iteration:
|
|
// x = r*(2 - a*r)
|
|
|
|
const int32_t lz = gglClz(a);
|
|
a <<= lz; // 0.32
|
|
uint32_t r = a;
|
|
// note: if a == 0x80000000, this means x was a power-of-2, in this
|
|
// case we don't need to compute anything. We get the reciprocal for
|
|
// (almost) free.
|
|
if (a != 0x80000000) {
|
|
r = (0x2E800 << (30-16)) - (r>>(2-1)); // 2.30, r = 2.90625 - 2*a
|
|
// 0.32 + 2.30 = 2.62 -> 2.30
|
|
// 2.30 + 2.30 = 4.60 -> 2.30
|
|
r = (((2LU<<30) - uint32_t((uint64_t(a)*r) >> 32)) * uint64_t(r)) >> 30;
|
|
r = (((2LU<<30) - uint32_t((uint64_t(a)*r) >> 32)) * uint64_t(r)) >> 30;
|
|
}
|
|
|
|
// shift right 1-bit to make room for the sign bit
|
|
*exponent = 30-lz-1;
|
|
r >>= 1;
|
|
return s ? -r : r;
|
|
}
|
|
|
|
int32_t gglRecipQ(GGLfixed x, int q)
|
|
{
|
|
int shift;
|
|
x = gglRecipQNormalized(x, &shift);
|
|
shift += 16-q;
|
|
x += 1L << (shift-1); // rounding
|
|
x >>= shift;
|
|
return x;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
GGLfixed gglFastDivx(GGLfixed n, GGLfixed d)
|
|
{
|
|
if ((d>>24) && ((d>>24)+1)) {
|
|
n >>= 8;
|
|
d >>= 8;
|
|
}
|
|
return gglMulx(n, gglRecip(d));
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
static const GGLfixed ggl_sqrt_reciproc_approx_tab[8] = {
|
|
// 1/sqrt(x) with x = 1-N/16, N=[8...1]
|
|
0x16A09, 0x15555, 0x143D1, 0x134BF, 0x1279A, 0x11C01, 0x111AC, 0x10865
|
|
};
|
|
|
|
GGLfixed gglSqrtRecipx(GGLfixed x)
|
|
{
|
|
if (x == 0) return FIXED_MAX;
|
|
if (x == FIXED_ONE) return x;
|
|
const GGLfixed a = x;
|
|
const int32_t lz = gglClz(x);
|
|
x = ggl_sqrt_reciproc_approx_tab[(a>>(28-lz))&0x7];
|
|
const int32_t exp = lz - 16;
|
|
if (exp <= 0) x >>= -exp>>1;
|
|
else x <<= (exp>>1) + (exp & 1);
|
|
if (exp & 1) {
|
|
x = gglMulx(x, ggl_sqrt_reciproc_approx_tab[0])>>1;
|
|
}
|
|
// 2 Newton-Raphson iterations: x = x/2*(3-(a*x)*x)
|
|
x = gglMulx((x>>1),(0x30000 - gglMulx(gglMulx(a,x),x)));
|
|
x = gglMulx((x>>1),(0x30000 - gglMulx(gglMulx(a,x),x)));
|
|
return x;
|
|
}
|
|
|
|
GGLfixed gglSqrtx(GGLfixed a)
|
|
{
|
|
// Compute a full precision square-root (24 bits accuracy)
|
|
GGLfixed r = 0;
|
|
GGLfixed bit = 0x800000;
|
|
int32_t bshift = 15;
|
|
do {
|
|
GGLfixed temp = bit + (r<<1);
|
|
if (bshift >= 8) temp <<= (bshift-8);
|
|
else temp >>= (8-bshift);
|
|
if (a >= temp) {
|
|
r += bit;
|
|
a -= temp;
|
|
}
|
|
bshift--;
|
|
} while (bit>>=1);
|
|
return r;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
static const GGLfixed ggl_log_approx_tab[] = {
|
|
// -ln(x)/ln(2) with x = N/16, N=[8...16]
|
|
0xFFFF, 0xd47f, 0xad96, 0x8a62, 0x6a3f, 0x4caf, 0x3151, 0x17d6, 0x0000
|
|
};
|
|
|
|
static const GGLfixed ggl_alog_approx_tab[] = { // domain [0 - 1.0]
|
|
0xffff, 0xeac0, 0xd744, 0xc567, 0xb504, 0xa5fe, 0x9837, 0x8b95, 0x8000
|
|
};
|
|
|
|
GGLfixed gglPowx(GGLfixed x, GGLfixed y)
|
|
{
|
|
// prerequisite: 0 <= x <= 1, and y >=0
|
|
|
|
// pow(x,y) = 2^(y*log2(x))
|
|
// = 2^(y*log2(x*(2^exp)*(2^-exp))))
|
|
// = 2^(y*(log2(X)-exp))
|
|
// = 2^(log2(X)*y - y*exp)
|
|
// = 2^( - (-log2(X)*y + y*exp) )
|
|
|
|
int32_t exp = gglClz(x) - 16;
|
|
GGLfixed f = x << exp;
|
|
x = (f & 0x0FFF)<<4;
|
|
f = (f >> 12) & 0x7;
|
|
GGLfixed p = gglMulAddx(
|
|
ggl_log_approx_tab[f+1] - ggl_log_approx_tab[f], x,
|
|
ggl_log_approx_tab[f]);
|
|
p = gglMulAddx(p, y, y*exp);
|
|
exp = gglFixedToIntFloor(p);
|
|
if (exp < 31) {
|
|
p = gglFracx(p);
|
|
x = (p & 0x1FFF)<<3;
|
|
p >>= 13;
|
|
p = gglMulAddx(
|
|
ggl_alog_approx_tab[p+1] - ggl_alog_approx_tab[p], x,
|
|
ggl_alog_approx_tab[p]);
|
|
p >>= exp;
|
|
} else {
|
|
p = 0;
|
|
}
|
|
return p;
|
|
// ( powf((a*65536.0f), (b*65536.0f)) ) * 65536.0f;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
int32_t gglDivQ(GGLfixed n, GGLfixed d, int32_t i)
|
|
{
|
|
//int32_t r =int32_t((int64_t(n)<<i)/d);
|
|
const int32_t ds = n^d;
|
|
if (n<0) n = -n;
|
|
if (d<0) d = -d;
|
|
int nd = gglClz(d) - gglClz(n);
|
|
i += nd + 1;
|
|
if (nd > 0) d <<= nd;
|
|
else n <<= -nd;
|
|
uint32_t q = 0;
|
|
|
|
int j = i & 7;
|
|
i >>= 3;
|
|
|
|
// gcc deals with the code below pretty well.
|
|
// we get 3.75 cycles per bit in the main loop
|
|
// and 8 cycles per bit in the termination loop
|
|
if (ggl_likely(i)) {
|
|
n -= d;
|
|
do {
|
|
q <<= 8;
|
|
if (n>=0) q |= 128;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 64;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 32;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 16;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 8;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 4;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 2;
|
|
else n += d;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 1;
|
|
else n += d;
|
|
|
|
if (--i == 0)
|
|
goto finish;
|
|
|
|
n = n*2 - d;
|
|
} while(true);
|
|
do {
|
|
q <<= 1;
|
|
n = n*2 - d;
|
|
if (n>=0) q |= 1;
|
|
else n += d;
|
|
finish: ;
|
|
} while (j--);
|
|
return (ds<0) ? -q : q;
|
|
}
|
|
|
|
n -= d;
|
|
if (n>=0) q |= 1;
|
|
else n += d;
|
|
j--;
|
|
goto finish;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
// assumes that the int32_t values of a, b, and c are all positive
|
|
// use when both a and b are larger than c
|
|
|
|
template <typename T>
|
|
static inline void swap(T& a, T& b) {
|
|
T t(a);
|
|
a = b;
|
|
b = t;
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
int32_t slow_muldiv(uint32_t a, uint32_t b, uint32_t c)
|
|
{
|
|
// first we compute a*b as a 64-bit integer
|
|
// (GCC generates umull with the code below)
|
|
uint64_t ab = uint64_t(a)*b;
|
|
uint32_t hi = ab>>32;
|
|
uint32_t lo = ab;
|
|
uint32_t result;
|
|
|
|
// now perform the division
|
|
if (hi >= c) {
|
|
overflow:
|
|
result = 0x7fffffff; // basic overflow
|
|
} else if (hi == 0) {
|
|
result = lo/c; // note: c can't be 0
|
|
if ((result >> 31) != 0) // result must fit in 31 bits
|
|
goto overflow;
|
|
} else {
|
|
uint32_t r = hi;
|
|
int bits = 31;
|
|
result = 0;
|
|
do {
|
|
r = (r << 1) | (lo >> 31);
|
|
lo <<= 1;
|
|
result <<= 1;
|
|
if (r >= c) {
|
|
r -= c;
|
|
result |= 1;
|
|
}
|
|
} while (bits--);
|
|
}
|
|
return int32_t(result);
|
|
}
|
|
|
|
// assumes a >= 0 and c >= b >= 0
|
|
static inline
|
|
int32_t quick_muldiv(int32_t a, int32_t b, int32_t c)
|
|
{
|
|
int32_t r = 0, q = 0, i;
|
|
int leading = gglClz(a);
|
|
i = 32 - leading;
|
|
a <<= leading;
|
|
do {
|
|
r <<= 1;
|
|
if (a < 0)
|
|
r += b;
|
|
a <<= 1;
|
|
q <<= 1;
|
|
if (r >= c) {
|
|
r -= c;
|
|
q++;
|
|
}
|
|
asm(""::); // gcc generates better code this way
|
|
if (r >= c) {
|
|
r -= c;
|
|
q++;
|
|
}
|
|
}
|
|
while (--i);
|
|
return q;
|
|
}
|
|
|
|
// this function computes a*b/c with 64-bit intermediate accuracy
|
|
// overflows (e.g. division by 0) are handled and return INT_MAX
|
|
|
|
int32_t gglMulDivi(int32_t a, int32_t b, int32_t c)
|
|
{
|
|
int32_t result;
|
|
int32_t sign = a^b^c;
|
|
|
|
if (a < 0) a = -a;
|
|
if (b < 0) b = -b;
|
|
if (c < 0) c = -c;
|
|
|
|
if (a < b) {
|
|
swap(a, b);
|
|
}
|
|
|
|
if (b <= c) result = quick_muldiv(a, b, c);
|
|
else result = slow_muldiv((uint32_t)a, (uint32_t)b, (uint32_t)c);
|
|
|
|
if (sign < 0)
|
|
result = -result;
|
|
|
|
return result;
|
|
}
|