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 ); }