static FLOAT8
calc_sfb_noise(const FLOAT8 * xr, const FLOAT8 * xr34, unsigned int bw, int sf)
{
unsigned int j;
fi_union fi;
FLOAT8 temp;
FLOAT8 xfsf = 0.0;
FLOAT8 const sfpow = POW20(sf); /*pow(2.0,sf/4.0); */
FLOAT8 const sfpow34 = IPOW20(sf); /*pow(sfpow,-3.0/4.0); */
for (j = 0; j < bw; ++j) {
temp = xr34[j] * sfpow34;
if (temp > IXMAX_VAL)
return -1;
#ifdef TAKEHIRO_IEEE754_HACK
temp += MAGIC_FLOAT;
fi.f = temp;
fi.f = temp + (adj43asm - MAGIC_INT)[fi.i];
fi.i -= MAGIC_INT;
#else
XRPOW_FTOI(temp, fi.i);
XRPOW_FTOI(temp + QUANTFAC(fi.i), fi.i);
#endif
temp = fabs(xr[j]) - pow43[fi.i] * sfpow;
xfsf += temp * temp;
}
return xfsf;
}
void quantize_xrpow_ISO( const FLOAT8 *xr, int *ix, FLOAT8 istep )
{
/* quantize on xr^(3/4) instead of xr */
const FLOAT8 compareval0 = (1.0 - 0.4054)/istep;
int j;
/* depending on architecture, it may be worth calculating a few more
compareval's.
eg. compareval1 = (2.0 - 0.4054/istep);
.. and then after the first compare do this ...
if compareval1>*xr then ix = 1;
On a pentium166, it's only worth doing the one compare (as done here),
as the second compare becomes more expensive than just calculating
the value. Architectures with slow FP operations may want to add some
more comparevals. try it and send your diffs statistically speaking
73% of all xr*istep values give ix=0
16% will give 1
4% will give 2
*/
for (j=576;j>0;j--) {
if (compareval0 > *xr) {
*(ix++) = 0;
xr++;
} else {
/* *(ix++) = (int)( istep*(*(xr++)) + 0.4054); */
XRPOW_FTOI( istep*(*(xr++)) + ROUNDFAC , *(ix++) );
}
}
}
static FLOAT8
calc_sfb_noise_mq(const FLOAT8 * xr, const FLOAT8 * xr34, int bw, int sf, int mq, FLOAT8 * scratch)
{
int j, k;
fi_union fi;
FLOAT8 temp;
FLOAT8 xfsfm = 0.0, xfsf = 0.0;
FLOAT8 const sfpow = POW20(sf); /*pow(2.0,sf/4.0); */
FLOAT8 const sfpow34 = IPOW20(sf); /*pow(sfpow,-3.0/4.0); */
for (j = 0; j < bw; ++j) {
temp = xr34[j] * sfpow34;
if (temp > IXMAX_VAL)
return -1;
#ifdef TAKEHIRO_IEEE754_HACK
temp += MAGIC_FLOAT;
fi.f = temp;
fi.f = temp + (adj43asm - MAGIC_INT)[fi.i];
fi.i -= MAGIC_INT;
#else
XRPOW_FTOI(temp, fi.i);
XRPOW_FTOI(temp + QUANTFAC(fi.i), fi.i);
#endif
temp = fabs(xr[j]) - pow43[fi.i] * sfpow;
temp *= temp;
scratch[j] = temp;
if (xfsfm < temp)
xfsfm = temp;
xfsf += temp;
}
if (mq == 1)
return bw * select_kth(scratch, bw, bw * 13 / 16);
xfsf /= bw;
for (k = 1, j = 0; j < bw; ++j) {
if (scratch[j] > xfsf) {
xfsfm += scratch[j];
++k;
}
}
return xfsfm / k * bw;
}
inline static void
k_34_4(DOUBLEX x[4], int l3[4])
{
#ifdef TAKEHIRO_IEEE754_HACK
fi_union fi[4];
assert(x[0] <= IXMAX_VAL && x[1] <= IXMAX_VAL && x[2] <= IXMAX_VAL && x[3] <= IXMAX_VAL);
x[0] += MAGIC_FLOAT;
fi[0].f = x[0];
x[1] += MAGIC_FLOAT;
fi[1].f = x[1];
x[2] += MAGIC_FLOAT;
fi[2].f = x[2];
x[3] += MAGIC_FLOAT;
fi[3].f = x[3];
fi[0].f = x[0] + adj43asm[fi[0].i - MAGIC_INT];
fi[1].f = x[1] + adj43asm[fi[1].i - MAGIC_INT];
fi[2].f = x[2] + adj43asm[fi[2].i - MAGIC_INT];
fi[3].f = x[3] + adj43asm[fi[3].i - MAGIC_INT];
l3[0] = fi[0].i - MAGIC_INT;
l3[1] = fi[1].i - MAGIC_INT;
l3[2] = fi[2].i - MAGIC_INT;
l3[3] = fi[3].i - MAGIC_INT;
#else
assert(x[0] <= IXMAX_VAL && x[1] <= IXMAX_VAL && x[2] <= IXMAX_VAL && x[3] <= IXMAX_VAL);
XRPOW_FTOI(x[0], l3[0]);
XRPOW_FTOI(x[1], l3[1]);
XRPOW_FTOI(x[2], l3[2]);
XRPOW_FTOI(x[3], l3[3]);
x[0] += QUANTFAC(l3[0]);
x[1] += QUANTFAC(l3[1]);
x[2] += QUANTFAC(l3[2]);
x[3] += QUANTFAC(l3[3]);
XRPOW_FTOI(x[0], l3[0]);
XRPOW_FTOI(x[1], l3[1]);
XRPOW_FTOI(x[2], l3[2]);
XRPOW_FTOI(x[3], l3[3]);
#endif
}
static void Quantize(const double *xr, int *ix, double istep)
{
int j;
for (j = FRAME_LEN/8; j > 0; --j) {
double x1, x2, x3, x4, x5, x6, x7, x8;
int rx1, rx2, rx3, rx4, rx5, rx6, rx7, rx8;
x1 = *xr++ * istep;
x2 = *xr++ * istep;
XRPOW_FTOI(x1, rx1);
x3 = *xr++ * istep;
XRPOW_FTOI(x2, rx2);
x4 = *xr++ * istep;
XRPOW_FTOI(x3, rx3);
x5 = *xr++ * istep;
XRPOW_FTOI(x4, rx4);
x6 = *xr++ * istep;
XRPOW_FTOI(x5, rx5);
x7 = *xr++ * istep;
XRPOW_FTOI(x6, rx6);
x8 = *xr++ * istep;
XRPOW_FTOI(x7, rx7);
x1 += QUANTFAC(rx1);
XRPOW_FTOI(x8, rx8);
x2 += QUANTFAC(rx2);
XRPOW_FTOI(x1,*ix++);
x3 += QUANTFAC(rx3);
XRPOW_FTOI(x2,*ix++);
x4 += QUANTFAC(rx4);
XRPOW_FTOI(x3,*ix++);
x5 += QUANTFAC(rx5);
XRPOW_FTOI(x4,*ix++);
x6 += QUANTFAC(rx6);
XRPOW_FTOI(x5,*ix++);
x7 += QUANTFAC(rx7);
XRPOW_FTOI(x6,*ix++);
x8 += QUANTFAC(rx8);
XRPOW_FTOI(x7,*ix++);
XRPOW_FTOI(x8,*ix++);
}
}
static FLOAT8
calc_sfb_noise_ave(const FLOAT8 * xr, const FLOAT8 * xr34, int bw, int sf)
{
FLOAT8 xp;
FLOAT8 xe;
FLOAT8 xm;
#ifdef TAKEHIRO_IEEE754_HACK
FLOAT8 x0;
unsigned int index = 0;
#endif
int xx[3], j;
fi_union *fi = (fi_union *) xx;
FLOAT8 xfsf_eq = 0.0, xfsf_p1 = 0.0, xfsf_m1 = 0.0;
FLOAT8 const sfpow_eq = POW20(sf); /*pow(2.0,sf/4.0); */
FLOAT8 const sfpow_m1 = sfpow_eq * facm1;
FLOAT8 const sfpow_p1 = sfpow_eq * facp1;
FLOAT8 const sfpow34_eq = IPOW20(sf); /*pow(sfpow,-3.0/4.0); */
FLOAT8 const sfpow34_m1 = sfpow34_eq * fac34m1;
FLOAT8 const sfpow34_p1 = sfpow34_eq * fac34p1;
#ifdef TAKEHIRO_IEEE754_HACK
/*
* loop unrolled into "Duff's Device". Robert Hegemann
*/
j = (bw + 3) / 4;
switch (bw % 4) {
default:
case 0:
do {
DUFFBLOCK();
case 3:
DUFFBLOCK();
case 2:
DUFFBLOCK();
case 1:
DUFFBLOCK();
} while (--j);
}
#else
for (j = 0; j < bw; ++j) {
xm = xr34[j] * sfpow34_m1;
if (xm > IXMAX_VAL)
return -1;
XRPOW_FTOI(xm, fi[0].i);
XRPOW_FTOI(xm + QUANTFAC(fi[0].i), fi[0].i);
xm = fabs(xr[j]) - pow43[fi[0].i] * sfpow_m1;
xm *= xm;
xe = xr34[j] * sfpow34_eq;
XRPOW_FTOI(xe, fi[0].i);
XRPOW_FTOI(xe + QUANTFAC(fi[0].i), fi[0].i);
xe = fabs(xr[j]) - pow43[fi[0].i] * sfpow_eq;
xe *= xe;
xp = xr34[j] * sfpow34_p1;
XRPOW_FTOI(xp, fi[0].i);
XRPOW_FTOI(xp + QUANTFAC(fi[0].i), fi[0].i);
xp = fabs(xr[j]) - pow43[fi[0].i] * sfpow_p1;
xp *= xp;
xfsf_m1 += xm;
xfsf_eq += xe;
xfsf_p1 += xp;
}
#endif
if (xfsf_eq < xfsf_p1)
xfsf_eq = xfsf_p1;
if (xfsf_eq < xfsf_m1)
xfsf_eq = xfsf_m1;
return xfsf_eq;
}
void quantize_xrpow(const FLOAT8 *xr, int *ix, FLOAT8 istep) {
/* quantize on xr^(3/4) instead of xr */
/* from [email protected]. Reported to be 2x faster than
the above code (when not using ASM) on PowerPC */
int j;
for ( j = 576/8; j > 0; --j) {
FLOAT8 x1, x2, x3, x4, x5, x6, x7, x8;
int rx1, rx2, rx3, rx4, rx5, rx6, rx7, rx8;
x1 = *xr++ * istep;
x2 = *xr++ * istep;
XRPOW_FTOI(x1, rx1);
x3 = *xr++ * istep;
XRPOW_FTOI(x2, rx2);
x4 = *xr++ * istep;
XRPOW_FTOI(x3, rx3);
x5 = *xr++ * istep;
XRPOW_FTOI(x4, rx4);
x6 = *xr++ * istep;
XRPOW_FTOI(x5, rx5);
x7 = *xr++ * istep;
XRPOW_FTOI(x6, rx6);
x8 = *xr++ * istep;
XRPOW_FTOI(x7, rx7);
x1 += QUANTFAC(rx1);
XRPOW_FTOI(x8, rx8);
x2 += QUANTFAC(rx2);
XRPOW_FTOI(x1,*ix++);
x3 += QUANTFAC(rx3);
XRPOW_FTOI(x2,*ix++);
x4 += QUANTFAC(rx4);
XRPOW_FTOI(x3,*ix++);
x5 += QUANTFAC(rx5);
XRPOW_FTOI(x4,*ix++);
x6 += QUANTFAC(rx6);
XRPOW_FTOI(x5,*ix++);
x7 += QUANTFAC(rx7);
XRPOW_FTOI(x6,*ix++);
x8 += QUANTFAC(rx8);
XRPOW_FTOI(x7,*ix++);
XRPOW_FTOI(x8,*ix++);
}
}
