--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/intercom/ilbc/LPCencode.c	Fri Jun 25 09:57:52 2010 +0200
@@ -0,0 +1,235 @@
+
+   /******************************************************************
+
+       iLBC Speech Coder ANSI-C Source Code
+
+       LPCencode.c
+
+       Copyright (C) The Internet Society (2004).
+       All Rights Reserved.
+
+   ******************************************************************/
+
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "helpfun.h"
+#include "lsf.h"
+#include "constants.h"
+
+
+
+
+
+   /*----------------------------------------------------------------*
+    *  lpc analysis (subrutine to LPCencode)
+    *---------------------------------------------------------------*/
+
+void SimpleAnalysis(float *lsf, /* (o) lsf coefficients */
+  float *data,                  /* (i) new data vector */
+  iLBC_Enc_Inst_t * iLBCenc_inst
+  /* (i/o) the encoder state structure */
+  )
+{
+  int k, is;
+  float temp[BLOCKL_MAX], lp[LPC_FILTERORDER + 1];
+  float lp2[LPC_FILTERORDER + 1];
+  float r[LPC_FILTERORDER + 1];
+
+  is = LPC_LOOKBACK + BLOCKL_MAX - iLBCenc_inst->blockl;
+  memcpy(iLBCenc_inst->lpc_buffer + is, data,
+    iLBCenc_inst->blockl * sizeof(float));
+
+  /* No lookahead, last window is asymmetric */
+
+  for (k = 0; k < iLBCenc_inst->lpc_n; k++) {
+
+    is = LPC_LOOKBACK;
+
+    if (k < (iLBCenc_inst->lpc_n - 1)) {
+      window(temp, lpc_winTbl, iLBCenc_inst->lpc_buffer, BLOCKL_MAX);
+    } else {
+      window(temp, lpc_asymwinTbl,
+        iLBCenc_inst->lpc_buffer + is, BLOCKL_MAX);
+    }
+
+    autocorr(r, temp, BLOCKL_MAX, LPC_FILTERORDER);
+    window(r, r, lpc_lagwinTbl, LPC_FILTERORDER + 1);
+
+    levdurb(lp, temp, r, LPC_FILTERORDER);
+    bwexpand(lp2, lp, LPC_CHIRP_SYNTDENUM, LPC_FILTERORDER + 1);
+
+    a2lsf(lsf + k * LPC_FILTERORDER, lp2);
+  }
+  is = LPC_LOOKBACK + BLOCKL_MAX - iLBCenc_inst->blockl;
+  memmove(iLBCenc_inst->lpc_buffer,
+    iLBCenc_inst->lpc_buffer + LPC_LOOKBACK + BLOCKL_MAX - is,
+    is * sizeof(float));
+}
+
+   /*----------------------------------------------------------------*
+
+
+
+
+
+    *  lsf interpolator and conversion from lsf to a coefficients
+    *  (subrutine to SimpleInterpolateLSF)
+    *---------------------------------------------------------------*/
+
+void LSFinterpolate2a_enc(float *a,     /* (o) lpc coefficients */
+  float *lsf1,                  /* (i) first set of lsf coefficients */
+  float *lsf2,                  /* (i) second set of lsf coefficients */
+  float coef,                   /* (i) weighting coefficient to use between
+                                   lsf1 and lsf2 */
+  long length                   /* (i) length of coefficient vectors */
+  )
+{
+  float lsftmp[LPC_FILTERORDER];
+
+  interpolate(lsftmp, lsf1, lsf2, coef, length);
+  lsf2a(a, lsftmp);
+}
+
+   /*----------------------------------------------------------------*
+    *  lsf interpolator (subrutine to LPCencode)
+    *---------------------------------------------------------------*/
+
+void SimpleInterpolateLSF(float *syntdenum,     /* (o) the synthesis filter denominator
+                                                   resulting from the quantized
+                                                   interpolated lsf */
+  float *weightdenum,           /* (o) the weighting filter denominator
+                                   resulting from the unquantized
+                                   interpolated lsf */
+  float *lsf,                   /* (i) the unquantized lsf coefficients */
+  float *lsfdeq,                /* (i) the dequantized lsf coefficients */
+  float *lsfold,                /* (i) the unquantized lsf coefficients of
+                                   the previous signal frame */
+  float *lsfdeqold,             /* (i) the dequantized lsf coefficients of
+                                   the previous signal frame */
+  int length,                   /* (i) should equate LPC_FILTERORDER */
+  iLBC_Enc_Inst_t * iLBCenc_inst
+  /* (i/o) the encoder state structure */
+  )
+{
+  int i, pos, lp_length;
+  float lp[LPC_FILTERORDER + 1], *lsf2, *lsfdeq2;
+
+  lsf2 = lsf + length;
+  lsfdeq2 = lsfdeq + length;
+  lp_length = length + 1;
+
+  if (iLBCenc_inst->mode == 30) {
+    /* sub-frame 1: Interpolation between old and first
+
+
+
+
+
+       set of lsf coefficients */
+
+    LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
+      lsf_weightTbl_30ms[0], length);
+    memcpy(syntdenum, lp, lp_length * sizeof(float));
+    LSFinterpolate2a_enc(lp, lsfold, lsf,
+      lsf_weightTbl_30ms[0], length);
+    bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
+
+    /* sub-frame 2 to 6: Interpolation between first
+       and second set of lsf coefficients */
+
+    pos = lp_length;
+    for (i = 1; i < iLBCenc_inst->nsub; i++) {
+      LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq2,
+        lsf_weightTbl_30ms[i], length);
+      memcpy(syntdenum + pos, lp, lp_length * sizeof(float));
+
+      LSFinterpolate2a_enc(lp, lsf, lsf2,
+        lsf_weightTbl_30ms[i], length);
+      bwexpand(weightdenum + pos, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
+      pos += lp_length;
+    }
+  } else {
+    pos = 0;
+    for (i = 0; i < iLBCenc_inst->nsub; i++) {
+      LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
+        lsf_weightTbl_20ms[i], length);
+      memcpy(syntdenum + pos, lp, lp_length * sizeof(float));
+      LSFinterpolate2a_enc(lp, lsfold, lsf,
+        lsf_weightTbl_20ms[i], length);
+      bwexpand(weightdenum + pos, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
+      pos += lp_length;
+    }
+  }
+
+  /* update memory */
+
+  if (iLBCenc_inst->mode == 30) {
+    memcpy(lsfold, lsf2, length * sizeof(float));
+    memcpy(lsfdeqold, lsfdeq2, length * sizeof(float));
+  } else {
+    memcpy(lsfold, lsf, length * sizeof(float));
+    memcpy(lsfdeqold, lsfdeq, length * sizeof(float));
+
+
+
+
+
+  }
+}
+
+   /*----------------------------------------------------------------*
+    *  lsf quantizer (subrutine to LPCencode)
+    *---------------------------------------------------------------*/
+
+void SimplelsfQ(float *lsfdeq,  /* (o) dequantized lsf coefficients
+                                   (dimension FILTERORDER) */
+  int *index,                   /* (o) quantization index */
+  float *lsf,                   /* (i) the lsf coefficient vector to be
+                                   quantized (dimension FILTERORDER ) */
+  int lpc_n                     /* (i) number of lsf sets to quantize */
+  )
+{
+  /* Quantize first LSF with memoryless split VQ */
+  SplitVQ(lsfdeq, index, lsf, lsfCbTbl, LSF_NSPLIT,
+    dim_lsfCbTbl, size_lsfCbTbl);
+
+  if (lpc_n == 2) {
+    /* Quantize second LSF with memoryless split VQ */
+    SplitVQ(lsfdeq + LPC_FILTERORDER, index + LSF_NSPLIT,
+      lsf + LPC_FILTERORDER, lsfCbTbl, LSF_NSPLIT,
+      dim_lsfCbTbl, size_lsfCbTbl);
+  }
+}
+
+   /*----------------------------------------------------------------*
+    *  lpc encoder
+    *---------------------------------------------------------------*/
+
+void LPCencode(float *syntdenum,        /* (i/o) synthesis filter coefficients
+                                           before/after encoding */
+  float *weightdenum,           /* (i/o) weighting denumerator
+                                   coefficients before/after
+                                   encoding */
+  int *lsf_index,               /* (o) lsf quantization index */
+  float *data,                  /* (i) lsf coefficients to quantize */
+  iLBC_Enc_Inst_t * iLBCenc_inst
+  /* (i/o) the encoder state structure */
+  )
+{
+  float lsf[LPC_FILTERORDER * LPC_N_MAX];
+  float lsfdeq[LPC_FILTERORDER * LPC_N_MAX];
+  int change = 0;
+
+  SimpleAnalysis(lsf, data, iLBCenc_inst);
+  SimplelsfQ(lsfdeq, lsf_index, lsf, iLBCenc_inst->lpc_n);
+
+
+
+
+
+  change = LSF_check(lsfdeq, LPC_FILTERORDER, iLBCenc_inst->lpc_n);
+  SimpleInterpolateLSF(syntdenum, weightdenum,
+    lsf, lsfdeq, iLBCenc_inst->lsfold,
+    iLBCenc_inst->lsfdeqold, LPC_FILTERORDER, iLBCenc_inst);
+}