filter.c

Go to the documentation of this file.

 /******************************************************************

 iLBC Speech Coder ANSI-C Source Code

 filter.c

 Copyright (C) The Internet Society (2004).
 All Rights Reserved.

 ******************************************************************/

 #include "iLBC_define.h"

 /*----------------------------------------------------------------*
 * all-pole filter
 *---------------------------------------------------------------*/

 void AllPoleFilter(
 float *InOut, /* (i/o) on entrance InOut[-orderCoef] to
 InOut[-1] contain the state of the
 filter (delayed samples). InOut[0] to
 InOut[lengthInOut-1] contain the filter
 input, on en exit InOut[-orderCoef] to
 InOut[-1] is unchanged and InOut[0] to
 InOut[lengthInOut-1] contain filtered
 samples */
 float *Coef,/* (i) filter coefficients, Coef[0] is assumed
 to be 1.0 */
 int lengthInOut,/* (i) number of input/output samples */
 int orderCoef /* (i) number of filter coefficients */
 ){
 int n,k;

 for(n=0;n<lengthInOut;n++){
 for(k=1;k<=orderCoef;k++){
 *InOut -= Coef[k]*InOut[-k];





 }
 InOut++;
 }
 }

 /*----------------------------------------------------------------*
 * all-zero filter
 *---------------------------------------------------------------*/

 void AllZeroFilter(
 float *In, /* (i) In[0] to In[lengthInOut-1] contain
 filter input samples */
 float *Coef,/* (i) filter coefficients (Coef[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 the filter state, on exit Out[0]
 to Out[lengthInOut-1] contain filtered
 samples */
 ){
 int n,k;

 for(n=0;n<lengthInOut;n++){
 *Out = Coef[0]*In[0];
 for(k=1;k<=orderCoef;k++){
 *Out += Coef[k]*In[-k];
 }
 Out++;
 In++;
 }
 }

 /*----------------------------------------------------------------*
 * pole-zero filter
 *---------------------------------------------------------------*/

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

 /*----------------------------------------------------------------*
 * downsample (LP filter and decimation)
 *---------------------------------------------------------------*/

 void DownSample (
 float *In, /* (i) input samples */
 float *Coef, /* (i) filter coefficients */
 int lengthIn, /* (i) number of input samples */
 float *state, /* (i) filter state */
 float *Out /* (o) downsampled output */
 ){
 float o;
 float *Out_ptr = Out;
 float *Coef_ptr, *In_ptr;
 float *state_ptr;
 int i, j, stop;

 /* LP filter and decimate at the same time */

 for (i = DELAY_DS; i < lengthIn; i+=FACTOR_DS)
 {
 Coef_ptr = &Coef[0];
 In_ptr = &In[i];
 state_ptr = &state[FILTERORDER_DS-2];

 o = (float)0.0;

 stop = (i < FILTERORDER_DS) ? i + 1 : FILTERORDER_DS;

 for (j = 0; j < stop; j++)
 {
 o += *Coef_ptr++ * (*In_ptr--);
 }
 for (j = i + 1; j < FILTERORDER_DS; j++)
 {
 o += *Coef_ptr++ * (*state_ptr--);
 }






 *Out_ptr++ = o;
 }

 /* Get the last part (use zeros as input for the future) */

 for (i=(lengthIn+FACTOR_DS); i<(lengthIn+DELAY_DS);
 i+=FACTOR_DS) {

 o=(float)0.0;

 if (i<lengthIn) {
 Coef_ptr = &Coef[0];
 In_ptr = &In[i];
 for (j=0; j<FILTERORDER_DS; j++) {
 o += *Coef_ptr++ * (*Out_ptr--);
 }
 } else {
 Coef_ptr = &Coef[i-lengthIn];
 In_ptr = &In[lengthIn-1];
 for (j=0; j<FILTERORDER_DS-(i-lengthIn); j++) {
 o += *Coef_ptr++ * (*In_ptr--);
 }
 }
 *Out_ptr++ = o;
 }
 }