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.

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(), lpFilt_coefsTbl, iLBC_Dec_Inst_t_::mode, iLBC_Dec_Inst_t_::prev_enh_pl, and xCorrCoef().

Referenced by iLBC_decode().

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

xCorrCoef()

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

Definition at line 485 of file enhancer.c.

Referenced by enhancerInterface(), and iLBC_decode().

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