helpfun.h File Reference

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

Go to the source code of this file.

Functions
void	autocorr (float *r, const float *x, int N, int order)
void	bwexpand (float *out, float *in, float coef, int length)
void	interpolate (float *out, float *in1, float *in2, float coef, int length)
void	levdurb (float *a, float *k, float *r, int order)
int	LSF_check (float *lsf, int dim, int NoAn)
void	sort_sq (float *xq, int *index, float x, const float *cb, int cb_size)
void	SplitVQ (float *qX, int *index, float *X, const float *CB, int nsplit, const int *dim, const int *cbsize)
void	vq (float *Xq, int *index, const float *CB, float *X, int n_cb, int dim)
void	window (float *z, const float *x, const float *y, int N)

Function Documentation

autocorr()

void autocorr	(	float *	r,
		const float *	x,
		int	N,
		int	order
	)

Definition at line 22 of file helpfun.c.

References order.

Referenced by SimpleAnalysis().

    {
       int     lag, n;
       float   sum;

       for (lag = 0; lag <= order; lag++) {
           sum = 0;
           for (n = 0; n < N - lag; n++) {
               sum += x[n] * x[n+lag];
           }
           r[lag] = sum;
       }





   }

bwexpand()

void bwexpand	(	float *	out,
		float *	in,
		float	coef,
		int	length
	)

Definition at line 136 of file helpfun.c.

Referenced by DecoderInterpolateLSF(), SimpleAnalysis(), and SimpleInterpolateLSF().

    {
       int i;





       float  chirp;

       chirp = coef;

       out[0] = in[0];
       for (i = 1; i < length; i++) {
           out[i] = chirp * in[i];
           chirp *= coef;
       }
   }

interpolate()

void interpolate	(	float *	out,
		float *	in1,
		float *	in2,
		float	coef,
		int	length
	)

Definition at line 114 of file helpfun.c.

Referenced by LSFinterpolate2a_dec(), and LSFinterpolate2a_enc().

    {
       int i;
       float invcoef;

       invcoef = (float)1.0 - coef;
       for (i = 0; i < length; i++) {
           out[i] = coef * in1[i] + invcoef * in2[i];
       }
   }

levdurb()

void levdurb	(	float *	a,
		float *	k,
		float *	r,
		int	order
	)

Definition at line 67 of file helpfun.c.

References EPS, and order.

Referenced by SimpleAnalysis().

    {
       float  sum, alpha;
       int     m, m_h, i;

       a[0] = 1.0;

       if (r[0] < EPS) { /* if r[0] <= 0, set LPC coeff. to zero */
           for (i = 0; i < order; i++) {
               k[i] = 0;
               a[i+1] = 0;
           }
       } else {
           a[1] = k[0] = -r[1]/r[0];
           alpha = r[0] + r[1] * k[0];
           for (m = 1; m < order; m++){
               sum = r[m + 1];
               for (i = 0; i < m; i++){
                   sum += a[i+1] * r[m - i];
               }





               k[m] = -sum / alpha;
               alpha += k[m] * sum;
               m_h = (m + 1) >> 1;
               for (i = 0; i < m_h; i++){
                   sum = a[i+1] + k[m] * a[m - i];
                   a[m - i] += k[m] * a[i+1];
                   a[i+1] = sum;
               }
               a[m+1] = k[m];
           }
       }
   }

LSF_check()

int LSF_check	(	float *	lsf,
		int	dim,
		int	NoAn
	)

Definition at line 272 of file helpfun.c.

Referenced by iLBC_decode(), and LPCencode().

    {
       int k,n,m, Nit=2, change=0,pos;
       static float eps=(float)0.039; /* 50 Hz */
       static float eps2=(float)0.0195;
       static float maxlsf=(float)3.14; /* 4000 Hz */
       static float minlsf=(float)0.01; /* 0 Hz */

       /* LSF separation check*/

       for (n=0; n<Nit; n++) { /* Run through a couple of times */
           for (m=0; m<NoAn; m++) { /* Number of analyses per frame */
               for (k=0; k<(dim-1); k++) {
                   pos=m*dim+k;

                   if ((lsf[pos+1]-lsf[pos])<eps) {

                       if (lsf[pos+1]<lsf[pos]) {
                           lsf[pos+1]= lsf[pos]+eps2;
                           lsf[pos]= lsf[pos+1]-eps2;
                       } else {
                           lsf[pos]-=eps2;
                           lsf[pos+1]+=eps2;
                       }
                       change=1;





                   }

                   if (lsf[pos]<minlsf) {
                       lsf[pos]=minlsf;
                       change=1;
                   }

                   if (lsf[pos]>maxlsf) {
                       lsf[pos]=maxlsf;
                       change=1;
                   }
               }
           }
       }

       return change;
   }

sort_sq()

void sort_sq	(	float *	xq,
		int *	index,
		float	x,
		const float *	cb,
		int	cb_size
	)

Definition at line 235 of file helpfun.c.

Referenced by AbsQuantW(), and StateSearchW().

    {
       int i;

       if (x <= cb[0]) {
           *index = 0;
           *xq = cb[0];
       } else {
           i = 0;
           while ((x > cb[i]) && i < cb_size - 1) {
               i++;





           }

           if (x > ((cb[i] + cb[i - 1])/2)) {
               *index = i;
               *xq = cb[i];
           } else {
               *index = i - 1;
               *xq = cb[i - 1];
           }
       }
   }

SplitVQ()

void SplitVQ	(	float *	qX,
		int *	index,
		float *	X,
		const float *	CB,
		int	nsplit,
		const int *	dim,
		const int *	cbsize
	)

Definition at line 209 of file helpfun.c.

References vq().

Referenced by SimplelsfQ().

    {
       int    cb_pos, X_pos, i;

       cb_pos = 0;
       X_pos= 0;
       for (i = 0; i < nsplit; i++) {
           vq(qX + X_pos, index + i, CB + cb_pos, X + X_pos,
               cbsize[i], dim[i]);
           X_pos += dim[i];
           cb_pos += dim[i] * cbsize[i];
       }
   }

vq()

void vq	(	float *	Xq,
		int *	index,
		const float *	CB,
		float *	X,
		int	n_cb,
		int	dim
	)

Definition at line 165 of file helpfun.c.

References FLOAT_MAX, and tmp().

Referenced by SplitVQ().

    {
       int     i, j;
       int     pos, minindex;
       float   dist, tmp, mindist;

       pos = 0;
       mindist = FLOAT_MAX;
       minindex = 0;
       for (j = 0; j < n_cb; j++) {
           dist = X[0] - CB[pos];
           dist *= dist;
           for (i = 1; i < dim; i++) {
               tmp = X[i] - CB[pos + i];
               dist += tmp*tmp;
           }

           if (dist < mindist) {
               mindist = dist;
               minindex = j;
           }
           pos += dim;
       }
       for (i = 0; i < dim; i++) {
           Xq[i] = CB[minindex*dim + i];
       }
       *index = minindex;





   }

window()

void window	(	float *	z,
		const float *	x,
		const float *	y,
		int	N
	)

Definition at line 50 of file helpfun.c.

    {
       int     i;

       for (i = 0; i < N; i++) {
           z[i] = x[i] * y[i];
       }
   }