enhancer.c File Reference

#include <math.h>
#include <string.h>
#include "iLBC_define.h"
#include "constants.h"
#include "filter.h"

Include dependency graph for enhancer.c:

Go to the source code of this file.

Functions
void	enh_upsample (float *useq1, float *seq1, int dim1, int hfl)
void	enhancer (float *odata, float *idata, int idatal, int centerStartPos, float alpha0, float *period, float *plocs, int periodl)
int	enhancerInterface (float *out, float *in, iLBC_Dec_Inst_t *iLBCdec_inst)
void	getsseq (float *sseq, float *idata, int idatal, int centerStartPos, float *period, float *plocs, int periodl, int hl)
void	mycorr1 (float *corr, float *seq1, int dim1, const float *seq2, int dim2)
void	NearestNeighbor (int *index, float *array, float value, int arlength)
void	refiner (float *seg, float *updStartPos, float *idata, int idatal, int centerStartPos, float estSegPos, float period)
void	smath (float *odata, float *sseq, int hl, float alpha0)
float	xCorrCoef (float *target, float *regressor, int subl)

Function Documentation

enh_upsample()

void enh_upsample	(	float *	useq1,
		float *	seq1,
		int	dim1,
		int	hfl
	)

Definition at line 84 of file enhancer.c.

    {
       float *pu,*ps;
       int i,j,k,q,filterlength,hfl2;
       const float *polyp[ENH_UPS0]; /* pointers to
                                        polyphase columns */
       const float *pp;
 
       /* define pointers for filter */
 
       filterlength=2*hfl+1;
 
       if ( filterlength > dim1 ) {
           hfl2=(int) (dim1/2);
           for (j=0; j<ENH_UPS0; j++) {
               polyp[j]=polyphaserTbl+j*filterlength+hfl-hfl2;
           }
           hfl=hfl2;
           filterlength=2*hfl+1;
       }
       else {
           for (j=0; j<ENH_UPS0; j++) {
               polyp[j]=polyphaserTbl+j*filterlength;
           }
       }
 
       /* filtering: filter overhangs left side of sequence */
 
       pu=useq1;
       for (i=hfl; i<filterlength; i++) {
           for (j=0; j<ENH_UPS0; j++) {
               *pu=0.0;
               pp = polyp[j];
               ps = seq1+i;
               for (k=0; k<=i; k++) {
                   *pu += *ps-- * *pp++;
               }
               pu++;
           }
       }
 
       /* filtering: simple convolution=inner products */
 
       for (i=filterlength; i<dim1; i++) {
 
 
 
 
 
           for (j=0;j<ENH_UPS0; j++){
               *pu=0.0;
               pp = polyp[j];
               ps = seq1+i;
               for (k=0; k<filterlength; k++) {
                   *pu += *ps-- * *pp++;
               }
               pu++;
           }
       }
 
       /* filtering: filter overhangs right side of sequence */
 
       for (q=1; q<=hfl; q++) {
           for (j=0; j<ENH_UPS0; j++) {
               *pu=0.0;
               pp = polyp[j]+q;
               ps = seq1+dim1-1;
               for (k=0; k<filterlength-q; k++) {
                   *pu += *ps-- * *pp++;
               }
               pu++;
           }
       }
   }

References ENH_UPS0, and polyphaserTbl.

Referenced by refiner().

enhancer()

void enhancer	(	float *	odata,
		float *	idata,
		int	idatal,
		int	centerStartPos,
		float	alpha0,
		float *	period,
		float *	plocs,
		int	periodl
	)

Definition at line 455 of file enhancer.c.

    {
       float sseq[(2*ENH_HL+1)*ENH_BLOCKL];
 
       /* get said second sequence of segments */
 
       getsseq(sseq,idata,idatal,centerStartPos,period,
           plocs,periodl,ENH_HL);
 
       /* compute the smoothed output from said second sequence */
 
       smath(odata,sseq,ENH_HL,alpha0);
 
   }

References ENH_BLOCKL, ENH_HL, getsseq(), and smath().

Referenced by enhancerInterface().

enhancerInterface()

int enhancerInterface	(	float *	out,
		float *	in,
		iLBC_Dec_Inst_t *	iLBCdec_inst
	)

Definition at line 517 of file enhancer.c.

    {
       float *enh_buf, *enh_period;
       int iblock, isample;
       int lag=0, ilag, i, ioffset;
       float cc, maxcc;
       float ftmp1, ftmp2;
       float *inPtr, *enh_bufPtr1, *enh_bufPtr2;
       float plc_pred[ENH_BLOCKL];
 
       float lpState[6], downsampled[(ENH_NBLOCKS*ENH_BLOCKL+120)/2];
       int inLen=ENH_NBLOCKS*ENH_BLOCKL+120;
       int start, plc_blockl, inlag;
 
       enh_buf=iLBCdec_inst->enh_buf;
       enh_period=iLBCdec_inst->enh_period;
 
       memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl],
           (ENH_BUFL-iLBCdec_inst->blockl)*sizeof(float));
 
       memcpy(&enh_buf[ENH_BUFL-iLBCdec_inst->blockl], in,
           iLBCdec_inst->blockl*sizeof(float));
 
       if (iLBCdec_inst->mode==30)
           plc_blockl=ENH_BLOCKL;
       else
           plc_blockl=40;
 
       /* when 20 ms frame, move processing one block */
       ioffset=0;
       if (iLBCdec_inst->mode==20) ioffset=1;
 
       i=3-ioffset;
       memmove(enh_period, &enh_period[i],
           (ENH_NBLOCKS_TOT-i)*sizeof(float));
 
 
 
 
 
 
       /* Set state information to the 6 samples right before
          the samples to be downsampled. */
 
       memcpy(lpState,
           enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-126,
           6*sizeof(float));
 
       /* Down sample a factor 2 to save computations */
 
       DownSample(enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-120,
                   lpFilt_coefsTbl, inLen-ioffset*ENH_BLOCKL,
                   lpState, downsampled);
 
       /* Estimate the pitch in the down sampled domain. */
       for (iblock = 0; iblock<ENH_NBLOCKS-ioffset; iblock++) {
 
           lag = 10;
           maxcc = xCorrCoef(downsampled+60+iblock*
               ENH_BLOCKL_HALF, downsampled+60+iblock*
               ENH_BLOCKL_HALF-lag, ENH_BLOCKL_HALF);
           for (ilag=11; ilag<60; ilag++) {
               cc = xCorrCoef(downsampled+60+iblock*
                   ENH_BLOCKL_HALF, downsampled+60+iblock*
                   ENH_BLOCKL_HALF-ilag, ENH_BLOCKL_HALF);
 
               if (cc > maxcc) {
                   maxcc = cc;
                   lag = ilag;
               }
           }
 
           /* Store the estimated lag in the non-downsampled domain */
           enh_period[iblock+ENH_NBLOCKS_EXTRA+ioffset] = (float)lag*2;
 
 
       }
 
 
       /* PLC was performed on the previous packet */
       if (iLBCdec_inst->prev_enh_pl==1) {
 
           inlag=(int)enh_period[ENH_NBLOCKS_EXTRA+ioffset];
 
           lag = inlag-1;
           maxcc = xCorrCoef(in, in+lag, plc_blockl);
           for (ilag=inlag; ilag<=inlag+1; ilag++) {
               cc = xCorrCoef(in, in+ilag, plc_blockl);
 
 
 
 
 
 
               if (cc > maxcc) {
                   maxcc = cc;
                   lag = ilag;
               }
           }
 
           enh_period[ENH_NBLOCKS_EXTRA+ioffset-1]=(float)lag;
 
           /* compute new concealed residual for the old lookahead,
              mix the forward PLC with a backward PLC from
              the new frame */
 
           inPtr=&in[lag-1];
 
           enh_bufPtr1=&plc_pred[plc_blockl-1];
 
           if (lag>plc_blockl) {
               start=plc_blockl;
           } else {
               start=lag;
           }
 
           for (isample = start; isample>0; isample--) {
               *enh_bufPtr1-- = *inPtr--;
           }
 
           enh_bufPtr2=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
           for (isample = (plc_blockl-1-lag); isample>=0; isample--) {
               *enh_bufPtr1-- = *enh_bufPtr2--;
           }
 
           /* limit energy change */
           ftmp2=0.0;
           ftmp1=0.0;
           for (i=0;i<plc_blockl;i++) {
               ftmp2+=enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i]*
                   enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i];
               ftmp1+=plc_pred[i]*plc_pred[i];
           }
           ftmp1=(float)sqrt(ftmp1/(float)plc_blockl);
           ftmp2=(float)sqrt(ftmp2/(float)plc_blockl);
           if (ftmp1>(float)2.0*ftmp2 && ftmp1>0.0) {
               for (i=0;i<plc_blockl-10;i++) {
                   plc_pred[i]*=(float)2.0*ftmp2/ftmp1;
               }
               for (i=plc_blockl-10;i<plc_blockl;i++) {
                   plc_pred[i]*=(float)(i-plc_blockl+10)*
                       ((float)1.0-(float)2.0*ftmp2/ftmp1)/(float)(10)+
 
 
 
 
 
                       (float)2.0*ftmp2/ftmp1;
               }
           }
 
           enh_bufPtr1=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
           for (i=0; i<plc_blockl; i++) {
               ftmp1 = (float) (i+1) / (float) (plc_blockl+1);
               *enh_bufPtr1 *= ftmp1;
               *enh_bufPtr1 += ((float)1.0-ftmp1)*
                                   plc_pred[plc_blockl-1-i];
               enh_bufPtr1--;
           }
       }
 
       if (iLBCdec_inst->mode==20) {
           /* Enhancer with 40 samples delay */
           for (iblock = 0; iblock<2; iblock++) {
               enhancer(out+iblock*ENH_BLOCKL, enh_buf,
                   ENH_BUFL, (5+iblock)*ENH_BLOCKL+40,
                   ENH_ALPHA0, enh_period, enh_plocsTbl,
                       ENH_NBLOCKS_TOT);
           }
       } else if (iLBCdec_inst->mode==30) {
           /* Enhancer with 80 samples delay */
           for (iblock = 0; iblock<3; iblock++) {
               enhancer(out+iblock*ENH_BLOCKL, enh_buf,
                   ENH_BUFL, (4+iblock)*ENH_BLOCKL,
                   ENH_ALPHA0, enh_period, enh_plocsTbl,
                       ENH_NBLOCKS_TOT);
           }
       }
 
       return (lag*2);
   }

References iLBC_Dec_Inst_t_::blockl, DownSample(), ENH_ALPHA0, ENH_BLOCKL, ENH_BLOCKL_HALF, iLBC_Dec_Inst_t_::enh_buf, ENH_BUFL, ENH_NBLOCKS, ENH_NBLOCKS_EXTRA, ENH_NBLOCKS_TOT, iLBC_Dec_Inst_t_::enh_period, enh_plocsTbl, enhancer(), in, lpFilt_coefsTbl, iLBC_Dec_Inst_t_::mode, out, iLBC_Dec_Inst_t_::prev_enh_pl, and xCorrCoef().

Referenced by iLBC_decode().

getsseq()

void getsseq	(	float *	sseq,
		float *	idata,
		int	idatal,
		int	centerStartPos,
		float *	period,
		float *	plocs,
		int	periodl,
		int	hl
	)

Definition at line 372 of file enhancer.c.

    {
       int i,centerEndPos,q;
       float blockStartPos[2*ENH_HL+1];
       int lagBlock[2*ENH_HL+1];
       float plocs2[ENH_PLOCSL];
       float *psseq;
 
       centerEndPos=centerStartPos+ENH_BLOCKL-1;
 
       /* present */
 
       NearestNeighbor(lagBlock+hl,plocs,
           (float)0.5*(centerStartPos+centerEndPos),periodl);
 
       blockStartPos[hl]=(float)centerStartPos;
 
 
 
 
 
       psseq=sseq+ENH_BLOCKL*hl;
       memcpy(psseq, idata+centerStartPos, ENH_BLOCKL*sizeof(float));
 
       /* past */
 
       for (q=hl-1; q>=0; q--) {
           blockStartPos[q]=blockStartPos[q+1]-period[lagBlock[q+1]];
           NearestNeighbor(lagBlock+q,plocs,
               blockStartPos[q]+
               ENH_BLOCKL_HALF-period[lagBlock[q+1]], periodl);
 
 
           if (blockStartPos[q]-ENH_OVERHANG>=0) {
               refiner(sseq+q*ENH_BLOCKL, blockStartPos+q, idata,
                   idatal, centerStartPos, blockStartPos[q],
                   period[lagBlock[q+1]]);
           } else {
               psseq=sseq+q*ENH_BLOCKL;
               memset(psseq, 0, ENH_BLOCKL*sizeof(float));
           }
       }
 
       /* future */
 
       for (i=0; i<periodl; i++) {
           plocs2[i]=plocs[i]-period[i];
       }
       for (q=hl+1; q<=2*hl; q++) {
           NearestNeighbor(lagBlock+q,plocs2,
               blockStartPos[q-1]+ENH_BLOCKL_HALF,periodl);
 
           blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]];
           if (blockStartPos[q]+ENH_BLOCKL+ENH_OVERHANG<idatal) {
               refiner(sseq+ENH_BLOCKL*q, blockStartPos+q, idata,
                   idatal, centerStartPos, blockStartPos[q],
                   period[lagBlock[q]]);
           }
           else {
               psseq=sseq+q*ENH_BLOCKL;
               memset(psseq, 0, ENH_BLOCKL*sizeof(float));
           }
       }
   }

References ENH_BLOCKL, ENH_BLOCKL_HALF, ENH_HL, ENH_OVERHANG, ENH_PLOCSL, NearestNeighbor(), and refiner().

Referenced by enhancer().

mycorr1()

void mycorr1	(	float *	corr,
		float *	seq1,
		int	dim1,
		const float *	seq2,
		int	dim2
	)

Definition at line 58 of file enhancer.c.

    {
       int i,j;
 
       for (i=0; i<=dim1-dim2; i++) {
           corr[i]=0.0;
           for (j=0; j<dim2; j++) {
               corr[i] += seq1[i+j] * seq2[j];
           }
       }
   }

Referenced by refiner().

NearestNeighbor()

void NearestNeighbor	(	int *	index,
		float *	array,
		float	value,
		int	arlength
	)

Definition at line 25 of file enhancer.c.

    {
       int i;
       float bestcrit,crit;
 
       crit=array[0]-value;
       bestcrit=crit*crit;
       *index=0;
       for (i=1; i<arlength; i++) {
           crit=array[i]-value;
           crit=crit*crit;
 
           if (crit<bestcrit) {
               bestcrit=crit;
               *index=i;
           }
       }
   }

References array(), and value.

Referenced by getsseq().

refiner()

void refiner	(	float *	seg,
		float *	updStartPos,
		float *	idata,
		int	idatal,
		int	centerStartPos,
		float	estSegPos,
		float	period
	)

Definition at line 172 of file enhancer.c.

    {
       int estSegPosRounded,searchSegStartPos,searchSegEndPos,corrdim;
       int tloc,tloc2,i,st,en,fraction;
       float vect[ENH_VECTL],corrVec[ENH_CORRDIM],maxv;
       float corrVecUps[ENH_CORRDIM*ENH_UPS0];
 
 
 
 
 
       /* defining array bounds */
 
       estSegPosRounded=(int)(estSegPos - 0.5);
 
       searchSegStartPos=estSegPosRounded-ENH_SLOP;
 
       if (searchSegStartPos<0) {
           searchSegStartPos=0;
       }
       searchSegEndPos=estSegPosRounded+ENH_SLOP;
 
       if (searchSegEndPos+ENH_BLOCKL >= idatal) {
           searchSegEndPos=idatal-ENH_BLOCKL-1;
       }
       corrdim=searchSegEndPos-searchSegStartPos+1;
 
       /* compute upsampled correlation (corr33) and find
          location of max */
 
       mycorr1(corrVec,idata+searchSegStartPos,
           corrdim+ENH_BLOCKL-1,idata+centerStartPos,ENH_BLOCKL);
       enh_upsample(corrVecUps,corrVec,corrdim,ENH_FL0);
       tloc=0; maxv=corrVecUps[0];
       for (i=1; i<ENH_UPS0*corrdim; i++) {
 
           if (corrVecUps[i]>maxv) {
               tloc=i;
               maxv=corrVecUps[i];
           }
       }
 
       /* make vector can be upsampled without ever running outside
          bounds */
 
       *updStartPos= (float)searchSegStartPos +
           (float)tloc/(float)ENH_UPS0+(float)1.0;
       tloc2=(int)(tloc/ENH_UPS0);
 
       if (tloc>tloc2*ENH_UPS0) {
           tloc2++;
       }
       st=searchSegStartPos+tloc2-ENH_FL0;
 
       if (st<0) {
           memset(vect,0,-st*sizeof(float));
           memcpy(&vect[-st],idata, (ENH_VECTL+st)*sizeof(float));
       }
       else {
 
 
 
 
 
           en=st+ENH_VECTL;
 
           if (en>idatal) {
               memcpy(vect, &idata[st],
                   (ENH_VECTL-(en-idatal))*sizeof(float));
               memset(&vect[ENH_VECTL-(en-idatal)], 0,
                   (en-idatal)*sizeof(float));
           }
           else {
               memcpy(vect, &idata[st], ENH_VECTL*sizeof(float));
           }
       }
       fraction=tloc2*ENH_UPS0-tloc;
 
       /* compute the segment (this is actually a convolution) */
 
       mycorr1(seg,vect,ENH_VECTL,polyphaserTbl+(2*ENH_FL0+1)*fraction,
           2*ENH_FL0+1);
   }

References ENH_BLOCKL, ENH_CORRDIM, ENH_FL0, ENH_SLOP, ENH_UPS0, enh_upsample(), ENH_VECTL, mycorr1(), and polyphaserTbl.

Referenced by getsseq().

smath()

void smath	(	float *	odata,
		float *	sseq,
		int	hl,
		float	alpha0
	)

Definition at line 267 of file enhancer.c.

    {
       int i,k;
       float w00,w10,w11,A,B,C,*psseq,err,errs;
       float surround[BLOCKL_MAX]; /* shape contributed by other than
                                      current */
       float wt[2*ENH_HL+1];       /* waveform weighting to get
                                      surround shape */
       float denom;
 
       /* create shape of contribution from all waveforms except the
          current one */
 
       for (i=1; i<=2*hl+1; i++) {
           wt[i-1] = (float)0.5*(1 - (float)cos(2*PI*i/(2*hl+2)));
       }
       wt[hl]=0.0; /* for clarity, not used */
       for (i=0; i<ENH_BLOCKL; i++) {
           surround[i]=sseq[i]*wt[0];
       }
 
 
 
 
 
       for (k=1; k<hl; k++) {
           psseq=sseq+k*ENH_BLOCKL;
           for(i=0;i<ENH_BLOCKL; i++) {
               surround[i]+=psseq[i]*wt[k];
           }
       }
       for (k=hl+1; k<=2*hl; k++) {
           psseq=sseq+k*ENH_BLOCKL;
           for(i=0;i<ENH_BLOCKL; i++) {
               surround[i]+=psseq[i]*wt[k];
           }
       }
 
       /* compute some inner products */
 
       w00 = w10 = w11 = 0.0;
       psseq=sseq+hl*ENH_BLOCKL; /* current block  */
       for (i=0; i<ENH_BLOCKL;i++) {
           w00+=psseq[i]*psseq[i];
           w11+=surround[i]*surround[i];
           w10+=surround[i]*psseq[i];
       }
 
       if (fabs(w11) < 1.0) {
           w11=1.0;
       }
       C = (float)sqrt( w00/w11);
 
       /* first try enhancement without power-constraint */
 
       errs=0.0;
       psseq=sseq+hl*ENH_BLOCKL;
       for (i=0; i<ENH_BLOCKL; i++) {
           odata[i]=C*surround[i];
           err=psseq[i]-odata[i];
           errs+=err*err;
       }
 
       /* if constraint violated by first try, add constraint */
 
       if (errs > alpha0 * w00) {
           if ( w00 < 1) {
               w00=1;
           }
           denom = (w11*w00-w10*w10)/(w00*w00);
 
           if (denom > 0.0001) { /* eliminates numerical problems
                                    for if smooth */
 
 
 
 
 
               A = (float)sqrt( (alpha0- alpha0*alpha0/4)/denom);
               B = -alpha0/2 - A * w10/w00;
               B = B+1;
           }
           else { /* essentially no difference between cycles;
                     smoothing not needed */
               A= 0.0;
               B= 1.0;
           }
 
           /* create smoothed sequence */
 
           psseq=sseq+hl*ENH_BLOCKL;
           for (i=0; i<ENH_BLOCKL; i++) {
               odata[i]=A*surround[i]+B*psseq[i];
           }
       }
   }

References BLOCKL_MAX, cos, ENH_BLOCKL, ENH_HL, errs, and PI.

Referenced by enhancer().

xCorrCoef()

float xCorrCoef	(	float *	target,
		float *	regressor,
		int	subl
	)

Definition at line 485 of file enhancer.c.

    {
       int i;
       float ftmp1, ftmp2;
 
       ftmp1 = 0.0;
       ftmp2 = 0.0;
       for (i=0; i<subl; i++) {
           ftmp1 += target[i]*regressor[i];
           ftmp2 += regressor[i]*regressor[i];
       }
 
       if (ftmp1 > 0.0) {
           return (float)(ftmp1*ftmp1/ftmp2);
       }
 
 
 
 
 
       else {
           return (float)0.0;
       }
   }

Referenced by enhancerInterface(), and iLBC_decode().