void ZeroPoleFilter( float *In, /* (i) In[0] to In[lengthInOut-1] contain filter input samples In[-orderCoef] to In[-1] contain state of all-zero section */ float *ZeroCoef,/* (i) filter coefficients for all-zero section (ZeroCoef[0] is assumed to be 1.0) */ float *PoleCoef,/* (i) filter coefficients for all-pole section (ZeroCoef[0] is assumed to be 1.0) */ int lengthInOut,/* (i) number of input/output samples */ int orderCoef, /* (i) number of filter coefficients */ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1] contain state of all-pole section. On exit Out[0] to Out[lengthInOut-1] contain filtered samples */ ){ AllZeroFilter(In,ZeroCoef,lengthInOut,orderCoef,Out); AllPoleFilter(Out,PoleCoef,lengthInOut,orderCoef); }
/********************* * * FUNCTION: IIRFilter * * DESCRIPTION: IIR filtering of a singal * * ***********************/ void IIRFilter(IIRFILTER_HANDLE hIIRFilter, FLOAT x[], FLOAT y[], INT32 iNrSamples ) { AllZeroFilter(hIIRFilter->hAlZeroFilter,x,y,iNrSamples); AllPoleFilter(hIIRFilter->hAlPoleFilter,y,y,iNrSamples); }
void iCBSearch( iLBC_Enc_Inst_t *iLBCenc_inst, /* (i) the encoder state structure */ int *index, /* (o) Codebook indices */ int *gain_index,/* (o) Gain quantization indices */ float *intarget,/* (i) Target vector for encoding */ float *mem, /* (i) Buffer for codebook construction */ int lMem, /* (i) Length of buffer */ int lTarget, /* (i) Length of vector */ int nStages, /* (i) Number of codebook stages */ float *weightDenum, /* (i) weighting filter coefficients */ float *weightState, /* (i) weighting filter state */ int block /* (i) the sub-block number */ ){ int i, j, icount, stage, best_index, range, counter; float max_measure, gain, measure, crossDot, ftmp; float gains[CB_NSTAGES]; float target[SUBL]; int base_index, sInd, eInd, base_size; int sIndAug=0, eIndAug=0; float buf[CB_MEML+SUBL+2*LPC_FILTERORDER]; float invenergy[CB_EXPAND*128], energy[CB_EXPAND*128]; float *pp, *ppi=0, *ppo=0, *ppe=0; float cbvectors[CB_MEML]; float tene, cene, cvec[SUBL]; float aug_vec[SUBL]; memset(cvec,0,SUBL*sizeof(float)); /* Determine size of codebook sections */ base_size=lMem-lTarget+1; if (lTarget==SUBL) { base_size=lMem-lTarget+1+lTarget/2; } /* setup buffer for weighting */ memcpy(buf,weightState,sizeof(float)*LPC_FILTERORDER); memcpy(buf+LPC_FILTERORDER,mem,lMem*sizeof(float)); memcpy(buf+LPC_FILTERORDER+lMem,intarget,lTarget*sizeof(float)); /* weighting */ AllPoleFilter(buf+LPC_FILTERORDER, weightDenum, lMem+lTarget, LPC_FILTERORDER); /* Construct the codebook and target needed */ memcpy(target, buf+LPC_FILTERORDER+lMem, lTarget*sizeof(float)); tene=0.0; for (i=0; i<lTarget; i++) { tene+=target[i]*target[i]; } /* Prepare search over one more codebook section. This section is created by filtering the original buffer with a filter. */ filteredCBvecs(cbvectors, buf+LPC_FILTERORDER, lMem); /* The Main Loop over stages */ for (stage=0; stage<nStages; stage++) { range = search_rangeTbl[block][stage]; /* initialize search measure */ max_measure = (float)-10000000.0; gain = (float)0.0; best_index = 0; /* Compute cross dot product between the target and the CB memory */ crossDot=0.0; pp=buf+LPC_FILTERORDER+lMem-lTarget; for (j=0; j<lTarget; j++) { crossDot += target[j]*(*pp++); } if (stage==0) { /* Calculate energy in the first block of 'lTarget' sampels. */ ppe = energy; ppi = buf+LPC_FILTERORDER+lMem-lTarget-1; ppo = buf+LPC_FILTERORDER+lMem-1; *ppe=0.0; pp=buf+LPC_FILTERORDER+lMem-lTarget; for (j=0; j<lTarget; j++) { *ppe+=(*pp)*(*pp); pp++; } if (*ppe>0.0) { invenergy[0] = (float) 1.0 / (*ppe + EPS); } else { invenergy[0] = (float) 0.0; } ppe++; measure=(float)-10000000.0; if (crossDot > 0.0) { measure = crossDot*crossDot*invenergy[0]; } } else { measure = crossDot*crossDot*invenergy[0]; } /* check if measure is better */ ftmp = crossDot*invenergy[0]; if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { best_index = 0; max_measure = measure; gain = ftmp; } /* loop over the main first codebook section, full search */ for (icount=1; icount<range; icount++) { /* calculate measure */ crossDot=0.0; pp = buf+LPC_FILTERORDER+lMem-lTarget-icount; for (j=0; j<lTarget; j++) { crossDot += target[j]*(*pp++); } if (stage==0) { *ppe++ = energy[icount-1] + (*ppi)*(*ppi) - (*ppo)*(*ppo); ppo--; ppi--; if (energy[icount]>0.0) { invenergy[icount] = (float)1.0/(energy[icount]+EPS); } else { invenergy[icount] = (float) 0.0; } measure=(float)-10000000.0; if (crossDot > 0.0) { measure = crossDot*crossDot*invenergy[icount]; } } else { measure = crossDot*crossDot*invenergy[icount]; } /* check if measure is better */ ftmp = crossDot*invenergy[icount]; if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { best_index = icount; max_measure = measure; gain = ftmp; } } /* Loop over augmented part in the first codebook * section, full search. * The vectors are interpolated. */ if (lTarget==SUBL) { /* Search for best possible cb vector and compute the CB-vectors' energy. */ searchAugmentedCB(20, 39, stage, base_size-lTarget/2, target, buf+LPC_FILTERORDER+lMem, &max_measure, &best_index, &gain, energy, invenergy); } /* set search range for following codebook sections */ base_index=best_index; /* unrestricted search */ if (CB_RESRANGE == -1) { sInd=0; eInd=range-1; sIndAug=20; eIndAug=39; } /* restriced search around best index from first codebook section */ else { /* Initialize search indices */ sIndAug=0; eIndAug=0; sInd=base_index-CB_RESRANGE/2; eInd=sInd+CB_RESRANGE; if (lTarget==SUBL) { if (sInd<0) { sIndAug = 40 + sInd; eIndAug = 39; sInd=0; } else if ( base_index < (base_size-20) ) { if (eInd > range) { sInd -= (eInd-range); eInd = range; } } else { /* base_index >= (base_size-20) */ if (sInd < (base_size-20)) { sIndAug = 20; sInd = 0; eInd = 0; eIndAug = 19 + CB_RESRANGE; if(eIndAug > 39) { eInd = eIndAug-39; eIndAug = 39; } } else { sIndAug = 20 + sInd - (base_size-20); eIndAug = 39; sInd = 0; eInd = CB_RESRANGE - (eIndAug-sIndAug+1); } } } else { /* lTarget = 22 or 23 */ if (sInd < 0) { eInd -= sInd; sInd = 0; } if(eInd > range) { sInd -= (eInd - range); eInd = range; } } } /* search of higher codebook section */ /* index search range */ counter = sInd; sInd += base_size; eInd += base_size; if (stage==0) { ppe = energy+base_size; *ppe=0.0; pp=cbvectors+lMem-lTarget; for (j=0; j<lTarget; j++) { *ppe+=(*pp)*(*pp); pp++; } ppi = cbvectors + lMem - 1 - lTarget; ppo = cbvectors + lMem - 1; for (j=0; j<(range-1); j++) { *(ppe+1) = *ppe + (*ppi)*(*ppi) - (*ppo)*(*ppo); ppo--; ppi--; ppe++; } } /* loop over search range */ for (icount=sInd; icount<eInd; icount++) { /* calculate measure */ crossDot=0.0; pp=cbvectors + lMem - (counter++) - lTarget; for (j=0;j<lTarget;j++) { crossDot += target[j]*(*pp++); } if (energy[icount]>0.0) { invenergy[icount] =(float)1.0/(energy[icount]+EPS); } else { invenergy[icount] =(float)0.0; } if (stage==0) { measure=(float)-10000000.0; if (crossDot > 0.0) { measure = crossDot*crossDot* invenergy[icount]; } } else { measure = crossDot*crossDot*invenergy[icount]; } /* check if measure is better */ ftmp = crossDot*invenergy[icount]; if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { best_index = icount; max_measure = measure; gain = ftmp; } } /* Search the augmented CB inside the limited range. */ if ((lTarget==SUBL)&&(sIndAug!=0)) { searchAugmentedCB(sIndAug, eIndAug, stage, 2*base_size-20, target, cbvectors+lMem, &max_measure, &best_index, &gain, energy, invenergy); } /* record best index */ index[stage] = best_index; /* gain quantization */ if (stage==0){ if (gain<0.0){ gain = 0.0; } if (gain>CB_MAXGAIN) { gain = (float)CB_MAXGAIN; } gain = gainquant(gain, 1.0, 32, &gain_index[stage]); } else { if (stage==1) { gain = gainquant(gain, (float)fabs(gains[stage-1]), 16, &gain_index[stage]); } else { gain = gainquant(gain, (float)fabs(gains[stage-1]), 8, &gain_index[stage]); } } /* Extract the best (according to measure) codebook vector */ if (lTarget==(STATE_LEN-iLBCenc_inst->state_short_len)) { if (index[stage]<base_size) { pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage]; } else { pp=cbvectors+lMem-lTarget- index[stage]+base_size; } } else { if (index[stage]<base_size) { if (index[stage]<(base_size-20)) { pp=buf+LPC_FILTERORDER+lMem- lTarget-index[stage]; } else { createAugmentedVec(index[stage]-base_size+40, buf+LPC_FILTERORDER+lMem,aug_vec); pp=aug_vec; } } else { int filterno, position; filterno=index[stage]/base_size; position=index[stage]-filterno*base_size; if (position<(base_size-20)) { pp=cbvectors+filterno*lMem-lTarget- index[stage]+filterno*base_size; } else { createAugmentedVec( index[stage]-(filterno+1)*base_size+40, cbvectors+filterno*lMem,aug_vec); pp=aug_vec; } } } /* Subtract the best codebook vector, according to measure, from the target vector */ for (j=0;j<lTarget;j++) { cvec[j] += gain*(*pp); target[j] -= gain*(*pp++); } /* record quantized gain */ gains[stage]=gain; }/* end of Main Loop. for (stage=0;... */ /* Gain adjustment for energy matching */ cene=0.0; for (i=0; i<lTarget; i++) { cene+=cvec[i]*cvec[i]; } j=gain_index[0]; for (i=gain_index[0]; i<32; i++) { ftmp=cene*gain_sq5Tbl[i]*gain_sq5Tbl[i]; if ((ftmp<(tene*gains[0]*gains[0])) && (gain_sq5Tbl[j]<(2.0*gains[0]))) { j=i; } } gain_index[0]=j; }
void AbsQuantW( iLBC_Enc_Inst_t *iLBCenc_inst, /* (i) Encoder instance */ float *in, /* (i) vector to encode */ float *syntDenum, /* (i) denominator of synthesis filter */ float *weightDenum, /* (i) denominator of weighting filter */ int *out, /* (o) vector of quantizer indexes */ int len, /* (i) length of vector to encode and vector of quantizer indexes */ int state_first /* (i) position of start state in the 80 vec */ ){ float *syntOut; float syntOutBuf[LPC_FILTERORDER+STATE_SHORT_LEN_30MS]; float toQ, xq; int n; int index; /* initialization of buffer for filtering */ memset(syntOutBuf, 0, LPC_FILTERORDER*sizeof(float)); /* initialization of pointer for filtering */ syntOut = &syntOutBuf[LPC_FILTERORDER]; /* synthesis and weighting filters on input */ if (state_first) { AllPoleFilter (in, weightDenum, SUBL, LPC_FILTERORDER); } else { AllPoleFilter (in, weightDenum, iLBCenc_inst->state_short_len-SUBL, LPC_FILTERORDER); } /* encoding loop */ for (n=0; n<len; n++) { /* time update of filter coefficients */ if ((state_first)&&(n==SUBL)){ syntDenum += (LPC_FILTERORDER+1); weightDenum += (LPC_FILTERORDER+1); /* synthesis and weighting filters on input */ AllPoleFilter (&in[n], weightDenum, len-n, LPC_FILTERORDER); } else if ((state_first==0)&& (n==(iLBCenc_inst->state_short_len-SUBL))) { syntDenum += (LPC_FILTERORDER+1); weightDenum += (LPC_FILTERORDER+1); /* synthesis and weighting filters on input */ AllPoleFilter (&in[n], weightDenum, len-n, LPC_FILTERORDER); } /* prediction of synthesized and weighted input */ syntOut[n] = 0.0; AllPoleFilter (&syntOut[n], weightDenum, 1, LPC_FILTERORDER); /* quantization */ toQ = in[n]-syntOut[n]; sort_sq(&xq, &index, toQ, state_sq3Tbl, 8); out[n]=index; syntOut[n] = state_sq3Tbl[out[n]]; /* update of the prediction filter */ AllPoleFilter(&syntOut[n], weightDenum, 1, LPC_FILTERORDER); } }