enhancer.h File Reference

#include "iLBC_define.h"

Include dependency graph for enhancer.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	enhancerInterface (float *out, float *in, iLBC_Dec_Inst_t *iLBCdec_inst)
float	xCorrCoef (float *target, float *regressor, int subl)

Function Documentation

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().

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().