static int
commonllp64(int unused, Fhdr *fp, ExecHdr *hp)
{
int32 pgsize;
uvlong entry;
hswal(&hp->e, sizeof(Exec)/sizeof(int32), beswal);
if(!(hp->e.exechdr.magic & HDR_MAGIC))
return 0;
/*
* There can be more magic here if the
* header ever needs more expansion.
* For now just catch use of any of the
* unused bits.
*/
if((hp->e.exechdr.magic & ~DYN_MAGIC)>>16)
return 0;
union {
char *p;
uvlong *v;
} u;
u.p = (char*)&hp->e.exechdr;
entry = beswav(*u.v);
pgsize = mach->pgsize;
settext(fp, entry, pgsize+fp->hdrsz, hp->e.exechdr.text, fp->hdrsz);
setdata(fp, _round(pgsize+fp->txtsz+fp->hdrsz, pgsize),
hp->e.exechdr.data, fp->txtsz+fp->hdrsz, hp->e.exechdr.bss);
setsym(fp, fp->datoff+fp->datsz, hp->e.exechdr.syms, 0, hp->e.exechdr.spsz, 0, hp->e.exechdr.pcsz);
if(hp->e.exechdr.magic & DYN_MAGIC) {
fp->txtaddr = 0;
fp->dataddr = fp->txtsz;
return 1;
}
commonboot(fp);
return 1;
}
/*
* SSIM(x,y)=(2*ux*uy + C1)*(2sxy + C2) / (ux^2 + uy^2 + C1)*(sx^2 + sy^2 + C2)
* where,
* ux = SUM(w*x)
* sx = (SUM(w*(x-ux)^2)^0.5
* sxy = SUM(w*(x-ux)*(y-uy))
*
* Returns mean SSIM. MSSIM(X,Y) = 1/M * SUM(SSIM(x,y))
*/
float iqa_ssim(const unsigned char *ref, const unsigned char *cmp, int w, int h, int stride,
int gaussian, const struct iqa_ssim_args *args)
{
int scale;
int x,y,src_offset,offset;
float *ref_f,*cmp_f;
struct _kernel low_pass;
struct _kernel window;
float result;
double ssim_sum=0.0;
struct _map_reduce mr;
/* Initialize algorithm parameters */
scale = _max( 1, _round( (float)_min(w,h) / 256.0f ) );
if (args) {
if(args->f)
scale = args->f;
mr.map = _ssim_map;
mr.reduce = _ssim_reduce;
mr.context = (void*)&ssim_sum;
}
window.kernel = (float*)g_square_window;
window.w = window.h = SQUARE_LEN;
window.normalized = 1;
window.bnd_opt = KBND_SYMMETRIC;
if (gaussian) {
window.kernel = (float*)g_gaussian_window;
window.w = window.h = GAUSSIAN_LEN;
}
/* Convert image values to floats. Forcing stride = width. */
ref_f = (float*)malloc(w*h*sizeof(float));
cmp_f = (float*)malloc(w*h*sizeof(float));
if (!ref_f || !cmp_f) {
if (ref_f) free(ref_f);
if (cmp_f) free(cmp_f);
return INFINITY;
}
for (y=0; y<h; ++y) {
src_offset = y*stride;
offset = y*w;
for (x=0; x<w; ++x, ++offset, ++src_offset) {
ref_f[offset] = (float)ref[src_offset];
cmp_f[offset] = (float)cmp[src_offset];
}
}
/* Scale the images down if required */
if (scale > 1) {
/* Generate simple low-pass filter */
low_pass.kernel = (float*)malloc(scale*scale*sizeof(float));
if (!low_pass.kernel) {
free(ref_f);
free(cmp_f);
return INFINITY;
}
low_pass.w = low_pass.h = scale;
low_pass.normalized = 0;
low_pass.bnd_opt = KBND_SYMMETRIC;
for (offset=0; offset<scale*scale; ++offset)
low_pass.kernel[offset] = 1.0f/(scale*scale);
/* Resample */
if (_iqa_decimate(ref_f, w, h, scale, &low_pass, 0, 0, 0) ||
_iqa_decimate(cmp_f, w, h, scale, &low_pass, 0, &w, &h)) { /* Update w/h */
free(ref_f);
free(cmp_f);
free(low_pass.kernel);
return INFINITY;
}
free(low_pass.kernel);
}
result = _iqa_ssim(ref_f, cmp_f, w, h, &window, &mr, args);
free(ref_f);
free(cmp_f);
return result;
}
void agc(
int16_t *sig_in, /* (i) : postfilter input signal */
int16_t *sig_out, /* (i/o) : postfilter output signal */
int16_t l_trm /* (i) : subframe size */
)
{
static int16_t past_gain=4096; /* past_gain = 1.0 (Q12) */
int16_t i, exp;
int16_t gain_in, gain_out, g0, gain; /* Q12 */
int32_t s;
int16_t signal[L_SUBFR];
/* calculate gain_out with exponent */
for(i=0; i<l_trm; i++)
signal[i] = shr(sig_out[i], 2);
s = 0;
for(i=0; i<l_trm; i++)
s = L_mac(s, signal[i], signal[i]);
if (s == 0) {
past_gain = 0;
return;
}
exp = sub(norm_l(s), 1);
gain_out = _round(L_shl(s, exp));
/* calculate gain_in with exponent */
for(i=0; i<l_trm; i++)
signal[i] = shr(sig_in[i], 2);
s = 0;
for(i=0; i<l_trm; i++)
s = L_mac(s, signal[i], signal[i]);
if (s == 0) {
g0 = 0;
}
else {
i = norm_l(s);
gain_in = _round(L_shl(s, i));
exp = sub(exp, i);
/*---------------------------------------------------*
* g0(Q12) = (1-AGC_FAC) * sqrt(gain_in/gain_out); *
*---------------------------------------------------*/
s = L_deposit_l(div_s(gain_out,gain_in)); /* Q15 */
s = L_shl(s, 7); /* s(Q22) = gain_out / gain_in */
s = L_shr(s, exp); /* Q22, add exponent */
/* i(Q12) = s(Q19) = 1 / sqrt(s(Q22)) */
s = Inv_sqrt(s); /* Q19 */
i = _round(L_shl(s,9)); /* Q12 */
/* g0(Q12) = i(Q12) * (1-AGC_FAC)(Q15) */
g0 = mult(i, AGC_FAC1); /* Q12 */
}
/* compute gain(n) = AGC_FAC gain(n-1) + (1-AGC_FAC)gain_in/gain_out */
/* sig_out(n) = gain(n) sig_out(n) */
gain = past_gain;
for(i=0; i<l_trm; i++) {
gain = mult(gain, AGC_FAC);
gain = add(gain, g0);
sig_out[i] = extract_h(L_shl(L_mult(sig_out[i], gain), 3));
}
past_gain = gain;
return;
}
void pit_pst_filt(
int16_t *signal, /* (i) : input signal */
int16_t *scal_sig, /* (i) : input signal (scaled, divided by 4) */
int16_t t0_min, /* (i) : minimum value in the searched range */
int16_t t0_max, /* (i) : maximum value in the searched range */
int16_t L_subfr, /* (i) : size of filtering */
int16_t *signal_pst /* (o) : harmonically postfiltered signal */
)
{
int16_t i, j, t0;
int16_t g0, gain, cmax, en, en0;
int16_t *p, *p1, *deb_sig;
int32_t corr, cor_max, ener, ener0, temp;
int32_t L_temp;
/*---------------------------------------------------------------------------*
* Compute the correlations for all delays *
* and select the delay which maximizes the correlation *
*---------------------------------------------------------------------------*/
deb_sig = &scal_sig[-t0_min];
cor_max = MIN_32;
t0 = t0_min; /* Only to remove warning from some compilers */
for (i=t0_min; i<=t0_max; i++)
{
corr = 0;
p = scal_sig;
p1 = deb_sig;
for (j=0; j<L_subfr; j++)
corr = L_mac(corr, *p++, *p1++);
L_temp = L_sub(corr, cor_max);
if (L_temp > (int32_t)0)
{
cor_max = corr;
t0 = i;
}
deb_sig--;
}
/* Compute the energy of the signal delayed by t0 */
ener = 1;
p = scal_sig - t0;
for ( i=0; i<L_subfr ;i++, p++)
ener = L_mac(ener, *p, *p);
/* Compute the signal energy in the present subframe */
ener0 = 1;
p = scal_sig;
for ( i=0; i<L_subfr; i++, p++)
ener0 = L_mac(ener0, *p, *p);
if (cor_max < 0)
{
cor_max = 0;
}
/* scale "cor_max", "ener" and "ener0" on 16 bits */
temp = cor_max;
if (ener > temp)
{
temp = ener;
}
if (ener0 > temp)
{
temp = ener0;
}
j = norm_l(temp);
cmax = _round(L_shl(cor_max, j));
en = _round(L_shl(ener, j));
en0 = _round(L_shl(ener0, j));
/* prediction gain (dB)= -10 log(1-cor_max*cor_max/(ener*ener0)) */
/* temp = (cor_max * cor_max) - (0.5 * ener * ener0) */
temp = L_mult(cmax, cmax);
temp = L_sub(temp, L_shr(L_mult(en, en0), 1));
if (temp < (int32_t)0) /* if prediction gain < 3 dB */
{ /* switch off pitch postfilter */
for (i = 0; i < L_subfr; i++)
signal_pst[i] = signal[i];
return;
}
if (sub(cmax, en) > 0) /* if pitch gain > 1 */
{
g0 = INV_GAMMAP;
gain = GAMMAP_2;
}
else {
cmax = shr(mult(cmax, GAMMAP), 1); /* cmax(Q14) = cmax(Q15) * GAMMAP */
en = shr(en, 1); /* Q14 */
i = add(cmax, en);
if(i > 0)
{
gain = div_s(cmax, i); /* gain(Q15) = cor_max/(cor_max+ener) */
g0 = sub(32767, gain); /* g0(Q15) = 1 - gain */
}
else
{
g0 = 32767;
gain = 0;
}
}
for (i = 0; i < L_subfr; i++)
{
/* signal_pst[i] = g0*signal[i] + gain*signal[i-t0]; */
signal_pst[i] = add(mult(g0, signal[i]), mult(gain, signal[i-t0]));
}
return;
}
sLONG VFontMetrics::GetNormalizedLineHeight() const
{
return _round(fAscent) + _round(fDescent) + _round(fExternalLeading);
}
sLONG VFontMetrics::GetNormalizedTextHeight() const
{
return _round(fAscent) + _round(fDescent);
}
int compute_ssim(const number_t *ref, const number_t *cmp, int w, int h,
int ref_stride, int cmp_stride, double *score,
double *l_score, double *c_score, double *s_score)
{
int ret = 1;
int scale;
int x,y,src_offset,offset;
float *ref_f,*cmp_f;
struct _kernel low_pass;
struct _kernel window;
float result = INFINITY;
float l, c, s;
double ssim_sum=0.0;
struct _map_reduce mr;
/* check stride */
int stride = ref_stride; /* stride in bytes */
if (stride != cmp_stride)
{
printf("error: for ssim, ref_stride (%d) != dis_stride (%d) bytes.\n", ref_stride, cmp_stride);
fflush(stdout);
goto fail_or_end;
}
stride /= sizeof(float); /* stride_ in pixels */
/* specify some default parameters */
const struct iqa_ssim_args *args = 0; /* 0 for default */
int gaussian = 1; /* 0 for 8x8 square window, 1 for 11x11 circular-symmetric Gaussian window (default) */
/* initialize algorithm parameters */
scale = _max( 1, _round( (float)_min(w,h) / 256.0f ) );
if (args) {
if(args->f) {
scale = args->f;
}
mr.map = _ssim_map;
mr.reduce = _ssim_reduce;
mr.context = (void*)&ssim_sum;
}
window.kernel = (float*)g_square_window;
window.kernel_h = (float*)g_square_window_h;
window.kernel_v = (float*)g_square_window_v;
window.w = window.h = SQUARE_LEN;
window.normalized = 1;
window.bnd_opt = KBND_SYMMETRIC;
if (gaussian) {
window.kernel = (float*)g_gaussian_window;
window.kernel_h = (float*)g_gaussian_window_h;
window.kernel_v = (float*)g_gaussian_window_v;
window.w = window.h = GAUSSIAN_LEN;
}
/* convert image values to floats, forcing stride = width. */
ref_f = (float*)malloc(w*h*sizeof(float));
cmp_f = (float*)malloc(w*h*sizeof(float));
if (!ref_f || !cmp_f) {
if (ref_f) free(ref_f);
if (cmp_f) free(cmp_f);
printf("error: unable to malloc ref_f or cmp_f.\n");
fflush(stdout);
goto fail_or_end;
}
for (y=0; y<h; ++y) {
src_offset = y * stride;
offset = y * w;
for (x=0; x<w; ++x, ++offset, ++src_offset) {
ref_f[offset] = (float)ref[src_offset];
cmp_f[offset] = (float)cmp[src_offset];
}
}
/* scale the images down if required */
if (scale > 1) {
/* generate simple low-pass filter */
low_pass.kernel = (float*)malloc(scale*scale*sizeof(float));
low_pass.kernel_h = (float*)malloc(scale*sizeof(float)); /* zli-nflx */
low_pass.kernel_v = (float*)malloc(scale*sizeof(float)); /* zli-nflx */
if (!(low_pass.kernel && low_pass.kernel_h && low_pass.kernel_v)) { /* zli-nflx */
free(ref_f);
free(cmp_f);
if (low_pass.kernel) free(low_pass.kernel); /* zli-nflx */
if (low_pass.kernel_h) free(low_pass.kernel_h); /* zli-nflx */
if (low_pass.kernel_v) free(low_pass.kernel_v); /* zli-nflx */
printf("error: unable to malloc low-pass filter kernel.\n");
fflush(stdout);
goto fail_or_end;
}
low_pass.w = low_pass.h = scale;
low_pass.normalized = 0;
low_pass.bnd_opt = KBND_SYMMETRIC;
for (offset=0; offset<scale*scale; ++offset)
low_pass.kernel[offset] = 1.0f/(scale*scale);
for (offset=0; offset<scale; ++offset) /* zli-nflx */
low_pass.kernel_h[offset] = 1.0f/(scale); /* zli-nflx */
for (offset=0; offset<scale; ++offset) /* zli-nflx */
low_pass.kernel_v[offset] = 1.0f/(scale); /* zli-nflx */
/* resample */
if (_iqa_decimate(ref_f, w, h, scale, &low_pass, 0, 0, 0) ||
_iqa_decimate(cmp_f, w, h, scale, &low_pass, 0, &w, &h)) { /* update w/h */
free(ref_f);
free(cmp_f);
free(low_pass.kernel);
free(low_pass.kernel_h); /* zli-nflx */
free(low_pass.kernel_v); /* zli-nflx */
printf("error: decimation fails on ref_f or cmp_f.\n");
fflush(stdout);
goto fail_or_end;
}
free(low_pass.kernel);
free(low_pass.kernel_h); /* zli-nflx */
free(low_pass.kernel_v); /* zli-nflx */
}
result = _iqa_ssim(ref_f, cmp_f, w, h, &window, &mr, args, &l, &c, &s);
free(ref_f);
free(cmp_f);
*score = (double)result;
*l_score = (double)l;
*c_score = (double)c;
*s_score = (double)s;
ret = 0;
fail_or_end:
return ret;
}
static int16_t D4i40_17_fast(/*(o) : Index of pulses positions. */
int16_t dn[], /* (i) : Correlations between h[] and Xn[]. */
int16_t rr[], /* (i) : Correlations of impulse response h[]. */
int16_t h[], /* (i) Q12: Impulse response of filters. */
int16_t cod[], /* (o) Q13: Selected algebraic codeword. */
int16_t y[], /* (o) Q12: Filtered algebraic codeword. */
int16_t *sign /* (o) : Signs of 4 pulses. */
)
{
int16_t i0, i1, i2, i3, ip0, ip1, ip2, ip3;
int16_t i, j, ix, iy, track, trk, max;
int16_t prev_i0, i1_offset;
int16_t psk, ps, ps0, ps1, ps2, sq, sq2;
int16_t alpk, alp, alp_16;
int32_t s, alp0, alp1, alp2;
int16_t *p0, *p1, *p2, *p3, *p4;
int16_t sign_dn[L_SUBFR], sign_dn_inv[L_SUBFR], *psign;
int16_t tmp_vect[NB_POS];
int16_t *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
int16_t *rri0i1, *rri0i2, *rri0i3, *rri0i4;
int16_t *rri1i2, *rri1i3, *rri1i4;
int16_t *rri2i3, *rri2i4;
int16_t *ptr_rri0i3_i4;
int16_t *ptr_rri1i3_i4;
int16_t *ptr_rri2i3_i4;
int16_t *ptr_rri3i3_i4;
/* Init pointers */
rri0i0 = rr;
rri1i1 = rri0i0 + NB_POS;
rri2i2 = rri1i1 + NB_POS;
rri3i3 = rri2i2 + NB_POS;
rri4i4 = rri3i3 + NB_POS;
rri0i1 = rri4i4 + NB_POS;
rri0i2 = rri0i1 + MSIZE;
rri0i3 = rri0i2 + MSIZE;
rri0i4 = rri0i3 + MSIZE;
rri1i2 = rri0i4 + MSIZE;
rri1i3 = rri1i2 + MSIZE;
rri1i4 = rri1i3 + MSIZE;
rri2i3 = rri1i4 + MSIZE;
rri2i4 = rri2i3 + MSIZE;
/*-----------------------------------------------------------------------*
* Chose the sign of the impulse. *
*-----------------------------------------------------------------------*/
for (i=0; i<L_SUBFR; i++)
{
if (dn[i] >= 0)
{
sign_dn[i] = MAX_16;
sign_dn_inv[i] = MIN_16;
}
else
{
sign_dn[i] = MIN_16;
sign_dn_inv[i] = MAX_16;
dn[i] = negate(dn[i]);
}
}
/*-------------------------------------------------------------------*
* Modification of rrixiy[] to take signs into account. *
*-------------------------------------------------------------------*/
p0 = rri0i1;
p1 = rri0i2;
p2 = rri0i3;
p3 = rri0i4;
for(i0=0; i0<L_SUBFR; i0+=STEP)
{
psign = sign_dn;
if (psign[i0] < 0) psign = sign_dn_inv;
for(i1=1; i1<L_SUBFR; i1+=STEP)
{
*p0 = mult(*p0, psign[i1]);
*p0 = *p0 + 1;
*p1 = mult(*p1, psign[i1+1]);
*p1 = *p1 + 1;
*p2 = mult(*p2, psign[i1+2]);
*p2 = *p2 + 1;
*p3 = mult(*p3, psign[i1+3]);
*p3 = *p3 + 1;
}
}
p0 = rri1i2;
p1 = rri1i3;
p2 = rri1i4;
for(i1=1; i1<L_SUBFR; i1+=STEP)
{
psign = sign_dn;
if (psign[i1] < 0) psign = sign_dn_inv;
for(i2=2; i2<L_SUBFR; i2+=STEP)
{
*p0 = mult(*p0, psign[i2]);
*p0 = *p0 + 1;
*p1 = mult(*p1, psign[i2+1]);
*p1 = *p1 + 1;
*p2 = mult(*p2, psign[i2+2]);
*p2 = *p2 + 1;
}
}
p0 = rri2i3;
p1 = rri2i4;
for(i2=2; i2<L_SUBFR; i2+=STEP)
{
psign = sign_dn;
if (psign[i2] < 0) psign = sign_dn_inv;
for(i3=3; i3<L_SUBFR; i3+=STEP)
{
*p0 = mult(*p0, psign[i3]);
*p0 = *p0 + 1;
*p1 = mult(*p1, psign[i3+1]);
*p1 = *p1 + 1;
}
}
/*-------------------------------------------------------------------*
* Search the optimum positions of the four pulses which maximize *
* square(correlation) / energy *
*-------------------------------------------------------------------*/
psk = -1;
alpk = 1;
ptr_rri0i3_i4 = rri0i3;
ptr_rri1i3_i4 = rri1i3;
ptr_rri2i3_i4 = rri2i3;
ptr_rri3i3_i4 = rri3i3;
/* Initializations only to remove warning from some compilers */
ip0=0; ip1=1; ip2=2; ip3=3; ix=0; iy=0; ps=0;
/* search 2 times: track 3 and 4 */
for (track=3, trk=0; track<5; track++, trk++)
{
/*------------------------------------------------------------------*
* depth first search 3, phase A: track 2 and 3/4. *
*------------------------------------------------------------------*/
sq = -1;
alp = 1;
/* i0 loop: 2 positions in track 2 */
prev_i0 = -1;
for (i=0; i<2; i++)
{
max = -1;
/* search "dn[]" maximum position in track 2 */
for (j=2; j<L_SUBFR; j+=STEP)
{
if ((sub(dn[j], max) > 0) && (sub(prev_i0,j) != 0))
{
max = dn[j];
i0 = j;
}
}
prev_i0 = i0;
j = mult(i0, 6554); /* j = i0/5 */
p0 = rri2i2 + j;
ps1 = dn[i0];
alp1 = L_mult(*p0, _1_4);
/* i1 loop: 8 positions in track 2 */
p0 = ptr_rri2i3_i4 + shl(j, 3);
p1 = ptr_rri3i3_i4;
for (i1=track; i1<L_SUBFR; i1+=STEP)
{
ps2 = add(ps1, dn[i1]); /* index increment = STEP */
/* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */
alp2 = L_mac(alp1, *p0++, _1_2);
alp2 = L_mac(alp2, *p1++, _1_4);
sq2 = mult(ps2, ps2);
alp_16 = _round(alp2);
s = L_msu(L_mult(alp,sq2),sq,alp_16);
if (s > 0)
{
sq = sq2;
ps = ps2;
alp = alp_16;
ix = i0;
iy = i1;
}
}
}
i0 = ix;
i1 = iy;
i1_offset = shl(mult(i1, 6554), 3); /* j = 8*(i1/5) */
/*------------------------------------------------------------------*
* depth first search 3, phase B: track 0 and 1. *
*------------------------------------------------------------------*/
ps0 = ps;
alp0 = L_mult(alp, _1_4);
sq = -1;
alp = 1;
/* build vector for next loop to decrease complexity */
p0 = rri1i2 + mult(i0, 6554);
p1 = ptr_rri1i3_i4 + mult(i1, 6554);
p2 = rri1i1;
p3 = tmp_vect;
for (i3=1; i3<L_SUBFR; i3+=STEP)
{
/* rrv[i3] = rr[i3][i3] + rr[i0][i3] + rr[i1][i3]; */
s = L_mult(*p0, _1_4); p0 += NB_POS;
s = L_mac(s, *p1, _1_4); p1 += NB_POS;
s = L_mac(s, *p2++, _1_8);
*p3++ = _round(s);
}
/* i2 loop: 8 positions in track 0 */
p0 = rri0i2 + mult(i0, 6554);
p1 = ptr_rri0i3_i4 + mult(i1, 6554);
p2 = rri0i0;
p3 = rri0i1;
for (i2=0; i2<L_SUBFR; i2+=STEP)
{
ps1 = add(ps0, dn[i2]); /* index increment = STEP */
/* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */
alp1 = L_mac(alp0, *p0, _1_8); p0 += NB_POS;
alp1 = L_mac(alp1, *p1, _1_8); p1 += NB_POS;
alp1 = L_mac(alp1, *p2++, _1_16);
/* i3 loop: 8 positions in track 1 */
p4 = tmp_vect;
for (i3=1; i3<L_SUBFR; i3+=STEP)
{
ps2 = add(ps1, dn[i3]); /* index increment = STEP */
/* alp1 = alp0 + rr[i0][i3] + rr[i1][i3] + rr[i2][i3] + 1/2*rr[i3][i3]; */
alp2 = L_mac(alp1, *p3++, _1_8);
alp2 = L_mac(alp2, *p4++, _1_2);
sq2 = mult(ps2, ps2);
alp_16 = _round(alp2);
s = L_msu(L_mult(alp,sq2),sq,alp_16);
if (s > 0)
{
sq = sq2;
alp = alp_16;
ix = i2;
iy = i3;
}
}
}
/*----------------------------------------------------------------*
* depth first search 3: compare codevector with the best case. *
*----------------------------------------------------------------*/
s = L_msu(L_mult(alpk,sq),psk,alp);
if (s > 0)
{
psk = sq;
alpk = alp;
ip2 = i0;
ip3 = i1;
ip0 = ix;
ip1 = iy;
}
/*------------------------------------------------------------------*
* depth first search 4, phase A: track 3 and 0. *
*------------------------------------------------------------------*/
sq = -1;
alp = 1;
/* i0 loop: 2 positions in track 3/4 */
prev_i0 = -1;
for (i=0; i<2; i++)
{
max = -1;
/* search "dn[]" maximum position in track 3/4 */
for (j=track; j<L_SUBFR; j+=STEP)
{
if ((sub(dn[j], max) > 0) && (sub(prev_i0,j) != 0))
{
max = dn[j];
i0 = j;
}
}
prev_i0 = i0;
j = mult(i0, 6554); /* j = i0/5 */
p0 = ptr_rri3i3_i4 + j;
ps1 = dn[i0];
alp1 = L_mult(*p0, _1_4);
/* i1 loop: 8 positions in track 0 */
p0 = ptr_rri0i3_i4 + j;
p1 = rri0i0;
for (i1=0; i1<L_SUBFR; i1+=STEP)
{
ps2 = add(ps1, dn[i1]); /* index increment = STEP */
/* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */
alp2 = L_mac(alp1, *p0, _1_2); p0 += NB_POS;
alp2 = L_mac(alp2, *p1++, _1_4);
sq2 = mult(ps2, ps2);
alp_16 = _round(alp2);
s = L_msu(L_mult(alp,sq2),sq,alp_16);
if (s > 0)
{
sq = sq2;
ps = ps2;
alp = alp_16;
ix = i0;
iy = i1;
}
}
}
i0 = ix;
i1 = iy;
i1_offset = shl(mult(i1, 6554), 3); /* j = 8*(i1/5) */
/*------------------------------------------------------------------*
* depth first search 4, phase B: track 1 and 2. *
*------------------------------------------------------------------*/
ps0 = ps;
alp0 = L_mult(alp, _1_4);
sq = -1;
alp = 1;
/* build vector for next loop to decrease complexity */
p0 = ptr_rri2i3_i4 + mult(i0, 6554);
p1 = rri0i2 + i1_offset;
p2 = rri2i2;
p3 = tmp_vect;
for (i3=2; i3<L_SUBFR; i3+=STEP)
{
/* rrv[i3] = rr[i3][i3] + rr[i0][i3] + rr[i1][i3]; */
s = L_mult(*p0, _1_4); p0 += NB_POS;
s = L_mac(s, *p1++, _1_4);
s = L_mac(s, *p2++, _1_8);
*p3++ = _round(s);
}
/* i2 loop: 8 positions in track 1 */
p0 = ptr_rri1i3_i4 + mult(i0, 6554);
p1 = rri0i1 + i1_offset;
p2 = rri1i1;
p3 = rri1i2;
for (i2=1; i2<L_SUBFR; i2+=STEP)
{
ps1 = add(ps0, dn[i2]); /* index increment = STEP */
/* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */
alp1 = L_mac(alp0, *p0, _1_8); p0 += NB_POS;
alp1 = L_mac(alp1, *p1++, _1_8);
alp1 = L_mac(alp1, *p2++, _1_16);
/* i3 loop: 8 positions in track 2 */
p4 = tmp_vect;
for (i3=2; i3<L_SUBFR; i3+=STEP)
{
ps2 = add(ps1, dn[i3]); /* index increment = STEP */
/* alp1 = alp0 + rr[i0][i3] + rr[i1][i3] + rr[i2][i3] + 1/2*rr[i3][i3]; */
alp2 = L_mac(alp1, *p3++, _1_8);
alp2 = L_mac(alp2, *p4++, _1_2);
sq2 = mult(ps2, ps2);
alp_16 = _round(alp2);
s = L_msu(L_mult(alp,sq2),sq,alp_16);
if (s > 0)
{
sq = sq2;
alp = alp_16;
ix = i2;
iy = i3;
}
}
}
/*----------------------------------------------------------------*
* depth first search 1: compare codevector with the best case. *
*----------------------------------------------------------------*/
s = L_msu(L_mult(alpk,sq),psk,alp);
if (s > 0)
{
psk = sq;
alpk = alp;
ip3 = i0;
ip0 = i1;
ip1 = ix;
ip2 = iy;
}
ptr_rri0i3_i4 = rri0i4;
ptr_rri1i3_i4 = rri1i4;
ptr_rri2i3_i4 = rri2i4;
ptr_rri3i3_i4 = rri4i4;
}
/* Set the sign of impulses */
i0 = sign_dn[ip0];
i1 = sign_dn[ip1];
i2 = sign_dn[ip2];
i3 = sign_dn[ip3];
/* Find the codeword corresponding to the selected positions */
for(i=0; i<L_SUBFR; i++) {
cod[i] = 0;
}
cod[ip0] = shr(i0, 2); /* From Q15 to Q13 */
cod[ip1] = shr(i1, 2);
cod[ip2] = shr(i2, 2);
cod[ip3] = shr(i3, 2);
/* find the filtered codeword */
for (i = 0; i < ip0; i++) y[i] = 0;
if(i0 > 0)
for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = h[j];
else
for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = negate(h[j]);
if(i1 > 0)
for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], h[j]);
else
for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], h[j]);
if(i2 > 0)
for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], h[j]);
else
for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], h[j]);
if(i3 > 0)
for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], h[j]);
else
for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], h[j]);
/* find codebook index; 17-bit address */
i = 0;
if(i0 > 0) i = add(i, 1);
if(i1 > 0) i = add(i, 2);
if(i2 > 0) i = add(i, 4);
if(i3 > 0) i = add(i, 8);
*sign = i;
ip0 = mult(ip0, 6554); /* ip0/5 */
ip1 = mult(ip1, 6554); /* ip1/5 */
ip2 = mult(ip2, 6554); /* ip2/5 */
i = mult(ip3, 6554); /* ip3/5 */
j = add(i, shl(i, 2)); /* j = i*5 */
j = sub(ip3, add(j, 3)); /* j= ip3%5 -3 */
ip3 = add(shl(i, 1), j);
i = add(ip0, shl(ip1, 3));
i = add(i , shl(ip2, 6));
i = add(i , shl(ip3, 9));
return i;
}
void _roundjson(json &j, int n) {
if (j.is_object())
for (auto &i : j)
if (i.is_number_float())
i = _round(i,n);
}
void WaveEquationSolver::PerturbationCoord(float x, float y)
{
int i = (int)_round( x/m_gridStep );
int j = (int)_round( y/m_gridStep );
PerturbationIdx( i,j );
}
