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

       iLBC Speech Coder ANSI-C Source Code

       helpfun.c

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

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

#include <math.h>

#include "iLBC_define.h"
#include "constants.h"

   /*----------------------------------------------------------------*
    *  calculation of auto correlation
    *---------------------------------------------------------------*/

void autocorr(float *r,         /* (o) autocorrelation vector */
  const float *x,               /* (i) data vector */
  int N,                        /* (i) length of data vector */
  int order                     /* largest lag for calculated
                                   autocorrelations */
  )
{
  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;
  }





}

   /*----------------------------------------------------------------*
    *  window multiplication
    *---------------------------------------------------------------*/

void window(float *z,           /* (o) the windowed data */
  const float *x,               /* (i) the original data vector */
  const float *y,               /* (i) the window */
  int N                         /* (i) length of all vectors */
  )
{
  int i;

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

   /*----------------------------------------------------------------*
    *  levinson-durbin solution for lpc coefficients
    *---------------------------------------------------------------*/

void levdurb(float *a,          /* (o) lpc coefficient vector starting
                                   with 1.0 */
  float *k,                     /* (o) reflection coefficients */
  float *r,                     /* (i) autocorrelation vector */
  int order                     /* (i) order of lpc filter */
  )
{
  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];
    }
  }
}

   /*----------------------------------------------------------------*
    *  interpolation between vectors
    *---------------------------------------------------------------*/

void interpolate(float *out,    /* (o) the interpolated vector */
  float *in1,                   /* (i) the first vector for the
                                   interpolation */
  float *in2,                   /* (i) the second vector for the
                                   interpolation */
  float coef,                   /* (i) interpolation weights */
  int length                    /* (i) length of all vectors */
  )
{
  int i;
  float invcoef;

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

   /*----------------------------------------------------------------*
    *  lpc bandwidth expansion
    *---------------------------------------------------------------*/

void bwexpand(float *out,       /* (o) the bandwidth expanded lpc
                                   coefficients */
  float *in,                    /* (i) the lpc coefficients before bandwidth
                                   expansion */
  float coef,                   /* (i) the bandwidth expansion factor */
  int length                    /* (i) the length of lpc coefficient vectors */
  )
{
  int i;





  float chirp;

  chirp = coef;

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

   /*----------------------------------------------------------------*
    *  vector quantization
    *---------------------------------------------------------------*/

void vq(float *Xq,              /* (o) the quantized vector */
  int *index,                   /* (o) the quantization index */
  const float *CB,              /* (i) the vector quantization codebook */
  float *X,                     /* (i) the vector to quantize */
  int n_cb,                     /* (i) the number of vectors in the codebook */
  int dim                       /* (i) the dimension of all vectors */
  )
{
  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;





}

   /*----------------------------------------------------------------*
    *  split vector quantization
    *---------------------------------------------------------------*/

void SplitVQ(float *qX,         /* (o) the quantized vector */
  int *index,                   /* (o) a vector of indexes for all vector
                                   codebooks in the split */
  float *X,                     /* (i) the vector to quantize */
  const float *CB,              /* (i) the quantizer codebook */
  int nsplit,                   /* the number of vector splits */
  const int *dim,               /* the dimension of X and qX */
  const int *cbsize             /* the number of vectors in the codebook */
  )
{
  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];
  }
}

   /*----------------------------------------------------------------*
    *  scalar quantization
    *---------------------------------------------------------------*/

void sort_sq(float *xq,         /* (o) the quantized value */
  int *index,                   /* (o) the quantization index */
  float x,                      /* (i) the value to quantize */
  const float *cb,              /* (i) the quantization codebook */
  int cb_size                   /* (i) the size of the quantization codebook */
  )
{
  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];
    }
  }
}

   /*----------------------------------------------------------------*
    *  check for stability of lsf coefficients
    *---------------------------------------------------------------*/

int LSF_check(                  /* (o) 1 for stable lsf vectors and 0 for
                                   nonstable ones */
  float *lsf,                   /* (i) a table of lsf vectors */
  int dim,                      /* (i) the dimension of each lsf vector */
  int NoAn                      /* (i) the number of lsf vectors in the
                                   table */
  )
{
  int k, n, m, Nit = 2, change = 0, pos;
  float tmp;
  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]) {
            tmp = lsf[pos + 1];
            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;
}
