/*--------------------------------------------------------------------------*/
fint hov_forward_(fint* ftag,
fint* fm,
fint* fn,
fint* fd,
fint* fp,
fdouble* fbase,
fdouble* fx,
fdouble* fvalue,
fdouble* fy) {
int rc= -1;
int tag=*ftag, m=*fm, n=*fn, d=*fd, p=*fp;
double* base = myalloc1(n);
double* value = myalloc1(m);
double*** X = myalloc3(n,p,d);
double*** Y = myalloc3(m,p,d);
spread1(n,fbase,base);
spread3(n,p,d,fx,X);
rc= hov_forward(tag,m,n,d,p,base,X,value,Y);
pack3(m,p,d,Y,fy);
pack1(m,value,fvalue);
free((char*)**X);
free((char*)*X);
free((char*)X);
free((char*)**Y);
free((char*)*Y);
free((char*)Y);
free((char*)base);
free((char*)value);
return rc;
}
void deconv3(void *g, int gx, int gy, int gz, void *f, int fx, int fy, int fz, void *out) {
double *g2 = unpack3(g, gx, gy, gz, gy, gz);
double *f2 = unpack3(f, fx, fy, fz, gy, gz);
double ff[(gx - fx + 1) * gy * gz];
deconv(g2, gx * gy * gz, f2, fx * gy * gz, ff, gy * gz);
pack3(ff, gx - fx + 1, gy, gz, gy - fy + 1, gz - fz + 1, out);
free(g2);
free(f2);
}
void PackUnix::pack(OutputFile *fo)
{
Filter ft(ph.level);
ft.addvalue = 0;
b_len = 0;
progid = 0;
// set options
blocksize = opt->o_unix.blocksize;
if (blocksize <= 0)
blocksize = BLOCKSIZE;
if ((off_t)blocksize > file_size)
blocksize = file_size;
// init compression buffers
ibuf.alloc(blocksize);
obuf.allocForCompression(blocksize);
fi->seek(0, SEEK_SET);
pack1(fo, ft); // generate Elf header, etc.
p_info hbuf;
set_te32(&hbuf.p_progid, progid);
set_te32(&hbuf.p_filesize, file_size);
set_te32(&hbuf.p_blocksize, blocksize);
fo->write(&hbuf, sizeof(hbuf));
// append the compressed body
if (pack2(fo, ft)) {
// write block end marker (uncompressed size 0)
b_info hdr; memset(&hdr, 0, sizeof(hdr));
set_le32(&hdr.sz_cpr, UPX_MAGIC_LE32);
fo->write(&hdr, sizeof(hdr));
}
pack3(fo, ft); // append loader
pack4(fo, ft); // append PackHeader and overlay_offset; update Elf header
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
/* accodec(n, tau, d, Z[n][n][d+1], B[n][n][d+1], nz[n][n]) */
fint accodec_(fint* fn, /* space dimension */
fdouble* ftau, /* scaling defaults to 1.0 */
fint* fdeg, /* highest degree */
fdouble* fa, /* input tensor of "partial" Jacobians */
fdouble* fb) /* output tensor of "total" Jacobians */
{
int rc= 1;
int n=*fn, deg=*fdeg;
double tau=*ftau;
double*** A = myalloc3(n,n,deg);
double*** B = myalloc3(n,n,deg);
spread3(n,n,deg,fa,A);
accodec(n,tau,deg,A,B,0);
pack3(n,n,deg,B,fb);
free((char*)**A);
free((char*)*A);
free((char*)A);
free((char*)**B);
free((char*)*B);
free((char*)B);
return rc;
}
/*--------------------------------------------------------------------------*/
fint hov_reverse_(fint* ftag,
fint* fm,
fint* fn,
fint* fd,
fint* fq,
fdouble* fu,
fdouble* fz) {
int rc=-1;
int tag=*ftag, m=*fm, n=*fn, d=*fd, q=*fq;
double** U = myalloc2(q,m);
double*** Z = myalloc3(q,n,d+1);
short ** nop = 0;
spread2(q,m,fu,U);
rc=hov_reverse(tag,m,n,d,q,U,Z,nop);
pack3(q,n,d+1,Z,fz);
free((char*)**Z);
free((char*)*Z);
free((char*)Z);
free((char*)*U);
free((char*)U);
return rc;
}
/*-------------------------------------------------------------------*
* Function ACELP_12i40_44bits() *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *
* Algebraic codebook; 44 bits: 12 pulses in a frame of 40 samples. *
*-------------------------------------------------------------------*
* The code length is 40, containing 12 nonzero pulses: i0...i11. *
* 12 pulses can have two (2) possible amplitudes: +1 or -1. *
* 10 pulses can have eight (8) possible positions: *
* i2,i7 : 0, 5, 10, 15, 20, 25, 30, 35. --> t0 *
* i3,i8 : 1, 6, 11, 16, 21, 26, 31, 36. --> t1 *
* i4,i9 : 2, 7, 12, 17, 22, 27, 32, 37. --> t2 *
* i5,i10 : 3, 8, 13, 18, 23, 28, 33, 38. --> t3 *
* i6,i11 : 4, 9, 14, 19, 24, 29, 34, 39. --> t4 *
* *
* The 2 other pulses can be on the following track: *
* t0-t1,t1-t2,t2-t3,t3-t4,t4-t0. *
*-------------------------------------------------------------------*/
void ACELP_12i40_44bits(
Word16 x[], /* (i) Q0 : target vector */
Word16 cn[], /* (i) Q0 : residual after long term prediction */
Word16 H[], /* (i) Q12: impulse response of weighted synthesis filter */
Word16 code[], /* (o) Q12: algebraic (fixed) codebook excitation */
Word16 y[], /* (o) Q11: filtered fixed codebook excitation */
Word16 indx[] /* (o) : index 5 words: 13,10,7,7,7 = 44 bits */
)
{
Word16 i, j, k, ix, iy, itrk[3], track, pos, index, idx[NB_TRACK];
Word16 psk, ps, alpk, alp;
Word32 s, corr[NB_TRACK];
Word16 *p0, *p1, *h, *h_inv;
Word16 dn[L_SUBFR], sign[L_SUBFR], vec[L_SUBFR];
Word16 ip[12], codvec[12], pos_max[NB_TRACK];
Word16 cor_x[NB_POS], cor_y[NB_POS];
Word16 h_buf[4*L_SUBFR];
Word16 rrixix[NB_TRACK][NB_POS], rrixiy[NB_TRACK][MSIZE];
Word32 L_tmp;
h = h_buf;
h_inv = h_buf + (2*L_SUBFR);
for (i=0; i<L_SUBFR; i++) {
*h++ = 0;
*h_inv++ = 0;
}
/* Compute correlation between target x[] and H[] */
cor_h_x_e(H, x, dn);
/* find the sign of each pulse position */
set_sign(32767, cn, dn, sign, vec, pos_max, corr);
/* Compute correlations of h[] needed for the codebook search. */
cor_h_e(H, sign, vec, h, h_inv, rrixix, rrixiy);
/*-------------------------------------------------------------------*
* Search position for pulse i0 and i1. *
*-------------------------------------------------------------------*/
s = L_add(corr[4], corr[0]);
for (k=0; k<NB_TRACK-1; k++) corr[k] = L_add(corr[k], corr[k+1]);
corr[4] = s;
for (k=0; k<3; k++) {
s = corr[0];
track = 0;
for (i=1; i<NB_TRACK; i++) {
L_tmp = L_sub(corr[i], s);
if (L_tmp > 0) {
s = corr[i];
track = i;
}
}
corr[track] = -1;
itrk[k] = track;
}
/*-------------------------------------------------------------------*
* Deep first search: 3 iterations of 320 tests = 960 tests. *
* *
* Stages of deep first search: *
* stage 1 : fix i0 and i1 --> 2 positions is fixed previously. *
* stage 2 : fix i2 and i3 --> try 8x8 = 64 positions. *
* stage 3 : fix i4 and i5 --> try 8x8 = 64 positions. *
* stage 4 : fix i6 and i7 --> try 8x8 = 64 positions. *
* stage 5 : fix i8 and i9 --> try 8x8 = 64 positions. *
* stage 6 : fix i10 and i11 --> try 8x8 = 64 positions. *
*-------------------------------------------------------------------*/
/* stage 0: fix pulse i0 and i1 according to max of correlation */
psk = -1;
alpk = 1;
for (pos=0; pos<3; pos++) {
k = itrk[pos]; /* starting position index */
/* stage 1: fix pulse i0 and i1 according to max of correlation */
ix = pos_max[ipos[k]];
iy = pos_max[ipos[k+1]];
ps = add(dn[ix], dn[iy]);
i = mult(ix, Q15_1_5);
j = mult(iy, Q15_1_5);
alp = add(rrixix[ipos[k]][i], rrixix[ipos[k+1]][j]);
i = add(shl(i,3), j);
alp = add(alp, rrixiy[ipos[k]][i]);
ip[0] = ix;
ip[1] = iy;
for (i=0; i<L_SUBFR; i++) vec[i] = 0;
/* stage 2..5: fix pulse i2,i3,i4,i5,i6,i7,i8 and i9 */
for (j=2; j<12; j+=2) {
/*--------------------------------------------------*
* Store all impulse response of all fixed pulses *
* in vector vec[] for the "cor_h_vec()" function. *
*--------------------------------------------------*/
if (sign[ix] < 0) p0 = h_inv - ix;
else p0 = h - ix;
if (sign[iy] < 0) p1 = h_inv - iy;
else p1 = h - iy;
for (i=0; i<L_SUBFR; i++) {
vec[i] = add(vec[i], add(*p0, *p1));
p0++; p1++;
}
/*--------------------------------------------------*
* Calculate correlation of all possible positions *
* of the next 2 pulses with previous fixed pulses. *
* Each pulse can have 8 possible positions *
*--------------------------------------------------*/
cor_h_vec(h, vec, ipos[k+j], sign, rrixix, cor_x);
cor_h_vec(h, vec, ipos[k+j+1], sign, rrixix, cor_y);
/*--------------------------------------------------*
* Fix 2 pulses, try 8x8 = 64 positions. *
*--------------------------------------------------*/
search_ixiy(ipos[k+j], ipos[k+j+1], &ps, &alp, &ix, &iy,
dn, cor_x, cor_y, rrixiy);
ip[j] = ix;
ip[j+1] = iy;
}
/* memorise new codevector if it's better than the last one. */
ps = mult(ps,ps);
s = L_msu(L_mult(alpk,ps),psk,alp);
if (s > 0) {
psk = ps;
alpk = alp;
for (i=0; i<12; i++) codvec[i] = ip[i];
}
} /* end of for (pos=0; pos<3; pos++) */
/*-------------------------------------------------------------------*
* index of 12 pulses = 44 bits on 5 words *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *
* indx[0] =13 bits --> 3(track) + *
* 3(pos#11) + 3(pos#6) + 1(sign#1) + 3(pos#1) *
* indx[1] =10 bits --> 3(pos#12) + 3(pos#7) + 1(sign#2) + 3(pos#2) *
* indx[2] = 7 bits --> 3(pos#8) + 1(sign#3) + 3(pos#3) *
* indx[3] = 7 bits --> 3(pos#9) + 1(sign#4) + 3(pos#4) *
* indx[4] = 7 bits --> 3(pos#10)+ 1(sign#5) + 3(pos#5) *
*-------------------------------------------------------------------*/
build_code(codvec+2, sign, 10, H, code, y, idx);
for (k=0; k<2; k++) {
pos = codvec[k];
index = mult(pos, Q15_1_5); /* index = pos/5 */
track = sub(pos, extract_l(L_shr(L_mult(index, 5), 1)));
if (sign[pos] > 0) {
code[pos] = add(code[pos], 4096); /* 1.0 in Q12 */
for (i=pos, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], H[j]);
}
else {
code[pos] = sub(code[pos], 4096); /* 1.0 in Q12 */
for (i=pos, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], H[j]);
index = add(index, 8);
}
ix = shr(idx[track], (Word16)4) & (Word16)15;
iy = idx[track] & (Word16)15;
index = pack3(ix, iy, index);
if (k == 0) index = add(shl(track, 10), index);
indx[k] = index;
}
for (k=2; k<NB_TRACK; k++) {
track = add(track, 1);
if (track >= NB_TRACK) track = 0;
indx[k] = (idx[track] & (Word16)127);
}
return;
}
