diff --git a/CHANGES b/CHANGES
index d0c970c561b963a5757de591a46a50ea9b056be1..39db2dca995a6724d1881483249258741b128490 100755
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,4 @@
+ -- Add iLBC codec
Asterisk 0.4.0
-- Merge and edit Nick's FXO dial support
-- Reengineer SIP registration (outbound)
diff --git a/channel.c b/channel.c
index 49982d849704f58a7b7b4159f2a4ba358455ac00..33538e7a26ef2da8995c632ef29ee252f4a1ace7 100755
--- a/channel.c
+++ b/channel.c
@@ -234,6 +234,8 @@ int ast_best_codec(int fmts)
/* Okay, we're down to vocoders now, so pick GSM because it's small and easier to
translate and sounds pretty good */
AST_FORMAT_GSM,
+ /* iLBC is not too bad */
+ AST_FORMAT_ILBC,
/* Speex is free, but computationally more expensive than GSM */
AST_FORMAT_SPEEX,
/* Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
diff --git a/channels/chan_iax2.c b/channels/chan_iax2.c
index f13f8fa3dd7552621e9b6c3b55f3f7cfc52ed611..eec8d0e33f08aa898a1af742fc3f3b59cf736064 100755
--- a/channels/chan_iax2.c
+++ b/channels/chan_iax2.c
@@ -538,6 +538,9 @@ static int get_samples(struct ast_frame *f)
case AST_FORMAT_G723_1:
samples = 240 /* XXX Not necessarily true XXX */;
break;
+ case AST_FORMAT_ILBC:
+ samples = 240 * (f->datalen / 52);
+ break;
case AST_FORMAT_GSM:
samples = 160 * (f->datalen / 33);
break;
diff --git a/codecs/Makefile b/codecs/Makefile
index e4beeea281bded1adc6f7582537bf47f8cf5a586..00778b8210df5ff0b0b798fac18f405027403c8c 100755
--- a/codecs/Makefile
+++ b/codecs/Makefile
@@ -20,6 +20,7 @@
MODG723=$(shell [ -f g723.1/coder.c ] && echo "codec_g723_1.so")
MODG723+=$(shell [ -f g723.1b/coder2.c ] && echo "codec_g723_1b.so")
MODSPEEX=$(shell [ -f /usr/include/speex.h ] || [ -f /usr/local/include/speex.h ] && echo "codec_speex.so")
+MODILBC=$(shell [ -f ilbc/iLBC_decode.h ] && echo "codec_ilbc.so")
CFLAGS+=
LIBG723=g723.1/libg723.a
@@ -30,8 +31,9 @@ LIBGSMT=$(shell if uname -m | grep -q 86; then echo gsm/lib/libgsm.a; fi)
LIBMP3=mp3/libmp3.a
LIBLPC10=lpc10/liblpc10.a
LIBSPEEX=-lspeex -lm
+LIBILBC=ilbc/libilbc.a
-CODECS+=$(MODG723) $(MODSPEEX) codec_gsm.so codec_mp3_d.so codec_lpc10.so \
+CODECS+=$(MODG723) $(MODSPEEX) $(MODILBC) codec_gsm.so codec_mp3_d.so codec_lpc10.so \
codec_adpcm.so codec_ulaw.so codec_alaw.so codec_a_mu.so
all: $(CODECS)
@@ -43,6 +45,7 @@ clean:
make -C gsm clean
make -C mp3 clean
make -C lpc10 clean
+ make -C ilbc clean
$(LIBG723):
make -C g723.1 all
@@ -59,6 +62,12 @@ $(LIBMP3):
$(LIBLPC10):
make -C lpc10 all
+$(LIBILBC):
+ make -C ilbc all
+
+codec_ilbc.so: codec_ilbc.o $(LIBILBC)
+ $(CC) -shared -Xlinker -x -o $@ $< $(LIBILBC)
+
codec_g723_1.so : codec_g723_1.o $(LIBG723)
$(CC) -shared -Xlinker -x -o $@ $< $(LIBG723)
diff --git a/codecs/codec_ilbc.c b/codecs/codec_ilbc.c
new file mode 100755
index 0000000000000000000000000000000000000000..c5e67f8817ef24d59f21321df8d0f63de9b1f96a
--- /dev/null
+++ b/codecs/codec_ilbc.c
@@ -0,0 +1,284 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * Translate between signed linear and Internet Low Bitrate Codec
+ *
+ * The iLBC code is from The IETF code base and is copyright GlobalSound, AB
+ *
+ * Copyright (C) 1999, Mark Spencer
+ *
+ * Mark Spencer <markster@linux-support.net>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#include <asterisk/lock.h>
+#include <asterisk/translate.h>
+#include <asterisk/module.h>
+#include <asterisk/logger.h>
+#include <asterisk/channel.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "ilbc/iLBC_encode.h"
+#include "ilbc/iLBC_decode.h"
+
+/* Sample frame data */
+#include "slin_ilbc_ex.h"
+#include "ilbc_slin_ex.h"
+
+#define USE_ILBC_ENHANCER 0
+
+static pthread_mutex_t localuser_lock = AST_MUTEX_INITIALIZER;
+static int localusecnt=0;
+
+static char *tdesc = "iLBC/PCM16 (signed linear) Codec Translator";
+
+struct ast_translator_pvt {
+ iLBC_Enc_Inst_t enc;
+ iLBC_Dec_Inst_t dec;
+ struct ast_frame f;
+ /* Space to build offset */
+ char offset[AST_FRIENDLY_OFFSET];
+ /* Buffer for our outgoing frame */
+ short outbuf[8000];
+ /* Enough to store a full second */
+ short buf[8000];
+ int tail;
+};
+
+#define ilbc_coder_pvt ast_translator_pvt
+
+static struct ast_translator_pvt *lintoilbc_new(void)
+{
+ struct ilbc_coder_pvt *tmp;
+ tmp = malloc(sizeof(struct ilbc_coder_pvt));
+ if (tmp) {
+ initEncode(&tmp->enc);
+ tmp->tail = 0;
+ localusecnt++;
+ }
+ return tmp;
+}
+
+static struct ast_translator_pvt *ilbctolin_new(void)
+{
+ struct ilbc_coder_pvt *tmp;
+ tmp = malloc(sizeof(struct ilbc_coder_pvt));
+ if (tmp) {
+ initDecode(&tmp->dec, USE_ILBC_ENHANCER);
+ tmp->tail = 0;
+ localusecnt++;
+ }
+ return tmp;
+}
+
+static struct ast_frame *lintoilbc_sample(void)
+{
+ static struct ast_frame f;
+ f.frametype = AST_FRAME_VOICE;
+ f.subclass = AST_FORMAT_SLINEAR;
+ f.datalen = sizeof(slin_ilbc_ex);
+ /* Assume 8000 Hz */
+ f.samples = sizeof(slin_ilbc_ex)/2;
+ f.mallocd = 0;
+ f.offset = 0;
+ f.src = __PRETTY_FUNCTION__;
+ f.data = slin_ilbc_ex;
+ return &f;
+}
+
+static struct ast_frame *ilbctolin_sample(void)
+{
+ static struct ast_frame f;
+ f.frametype = AST_FRAME_VOICE;
+ f.subclass = AST_FORMAT_ILBC;
+ f.datalen = sizeof(ilbc_slin_ex);
+ /* All frames are 30 ms long */
+ f.samples = 240;
+ f.mallocd = 0;
+ f.offset = 0;
+ f.src = __PRETTY_FUNCTION__;
+ f.data = ilbc_slin_ex;
+ return &f;
+}
+
+static struct ast_frame *ilbctolin_frameout(struct ast_translator_pvt *tmp)
+{
+ if (!tmp->tail)
+ return NULL;
+ /* Signed linear is no particular frame size, so just send whatever
+ we have in the buffer in one lump sum */
+ tmp->f.frametype = AST_FRAME_VOICE;
+ tmp->f.subclass = AST_FORMAT_SLINEAR;
+ tmp->f.datalen = tmp->tail * 2;
+ /* Assume 8000 Hz */
+ tmp->f.samples = tmp->tail;
+ tmp->f.mallocd = 0;
+ tmp->f.offset = AST_FRIENDLY_OFFSET;
+ tmp->f.src = __PRETTY_FUNCTION__;
+ tmp->f.data = tmp->buf;
+ /* Reset tail pointer */
+ tmp->tail = 0;
+
+ return &tmp->f;
+}
+
+static int ilbctolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
+{
+ /* Assuming there's space left, decode into the current buffer at
+ the tail location. Read in as many frames as there are */
+ int x,i;
+ float tmpf[240];
+
+ if (f->datalen % 52) {
+ ast_log(LOG_WARNING, "Huh? An ilbc frame that isn't a multiple of 52 bytes long from %s (%d)?\n", f->src, f->datalen);
+ return -1;
+ }
+
+ for (x=0;x<f->datalen;x+=52) {
+ if (tmp->tail + 240 < sizeof(tmp->buf)/2) {
+ iLBC_decode(tmpf, f->data + x, &tmp->dec, 1);
+ for (i=0;i<240;i++)
+ tmp->buf[tmp->tail + i] = tmpf[i];
+ tmp->tail+=240;
+ } else {
+ ast_log(LOG_WARNING, "Out of buffer space\n");
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int lintoilbc_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
+{
+ /* Just add the frames to our stream */
+ /* XXX We should look at how old the rest of our stream is, and if it
+ is too old, then we should overwrite it entirely, otherwise we can
+ get artifacts of earlier talk that do not belong */
+ if (tmp->tail + f->datalen/2 < sizeof(tmp->buf) / 2) {
+ memcpy((tmp->buf + tmp->tail), f->data, f->datalen);
+ tmp->tail += f->datalen/2;
+ } else {
+ ast_log(LOG_WARNING, "Out of buffer space\n");
+ return -1;
+ }
+ return 0;
+}
+
+static struct ast_frame *lintoilbc_frameout(struct ast_translator_pvt *tmp)
+{
+ int x=0,i;
+ float tmpf[240];
+ /* We can't work on anything less than a frame in size */
+ if (tmp->tail < 240)
+ return NULL;
+ tmp->f.frametype = AST_FRAME_VOICE;
+ tmp->f.subclass = AST_FORMAT_ILBC;
+ tmp->f.mallocd = 0;
+ tmp->f.offset = AST_FRIENDLY_OFFSET;
+ tmp->f.src = __PRETTY_FUNCTION__;
+ tmp->f.data = tmp->outbuf;
+ while(tmp->tail >= 240) {
+ if ((x+1) * 52 >= sizeof(tmp->outbuf)) {
+ ast_log(LOG_WARNING, "Out of buffer space\n");
+ break;
+ }
+ for (i=0;i<240;i++)
+ tmpf[i] = tmp->buf[i];
+ /* Encode a frame of data */
+ iLBC_encode(((unsigned char *)(tmp->outbuf)) + (x * 52), tmpf, &tmp->enc);
+ /* Assume 8000 Hz -- 20 ms */
+ tmp->tail -= 240;
+ /* Move the data at the end of the buffer to the front */
+ if (tmp->tail)
+ memmove(tmp->buf, tmp->buf + 240, tmp->tail * 2);
+ x++;
+ }
+ tmp->f.datalen = x * 52;
+ tmp->f.samples = x * 240;
+#if 0
+ {
+ static int fd = -1;
+ if (fd == -1) {
+ fd = open("ilbc.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
+ write(fd, tmp->f.data, tmp->f.datalen);
+ close(fd);
+ }
+ }
+#endif
+ return &tmp->f;
+}
+
+static void ilbc_destroy_stuff(struct ast_translator_pvt *pvt)
+{
+ free(pvt);
+ localusecnt--;
+}
+
+static struct ast_translator ilbctolin =
+ { "ilbctolin",
+ AST_FORMAT_ILBC, AST_FORMAT_SLINEAR,
+ ilbctolin_new,
+ ilbctolin_framein,
+ ilbctolin_frameout,
+ ilbc_destroy_stuff,
+ ilbctolin_sample
+ };
+
+static struct ast_translator lintoilbc =
+ { "lintoilbc",
+ AST_FORMAT_SLINEAR, AST_FORMAT_ILBC,
+ lintoilbc_new,
+ lintoilbc_framein,
+ lintoilbc_frameout,
+ ilbc_destroy_stuff,
+ lintoilbc_sample
+ };
+
+int unload_module(void)
+{
+ int res;
+ ast_pthread_mutex_lock(&localuser_lock);
+ res = ast_unregister_translator(&lintoilbc);
+ if (!res)
+ res = ast_unregister_translator(&ilbctolin);
+ if (localusecnt)
+ res = -1;
+ ast_pthread_mutex_unlock(&localuser_lock);
+ return res;
+}
+
+int load_module(void)
+{
+ int res;
+ res=ast_register_translator(&ilbctolin);
+ if (!res)
+ res=ast_register_translator(&lintoilbc);
+ else
+ ast_unregister_translator(&ilbctolin);
+ return res;
+}
+
+char *description(void)
+{
+ return tdesc;
+}
+
+int usecount(void)
+{
+ int res;
+ STANDARD_USECOUNT(res);
+ return res;
+}
+
+char *key()
+{
+ return ASTERISK_GPL_KEY;
+}
diff --git a/codecs/ilbc/FrameClassify.c b/codecs/ilbc/FrameClassify.c
new file mode 100755
index 0000000000000000000000000000000000000000..61ede133b05b5f40999d4128c36cc4a04c02a660
--- /dev/null
+++ b/codecs/ilbc/FrameClassify.c
@@ -0,0 +1,100 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ FrameClassify.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * Classification of subframes to localize start state
+ *---------------------------------------------------------------*/
+
+int FrameClassify( /* index to the max-energy sub frame */
+ float *residual /* (i) lpc residual signal */
+){
+ float max_ssqEn, fssqEn[NSUB], bssqEn[NSUB], *pp;
+ int n, l, max_ssqEn_n;
+ const float ssqEn_win[NSUB-1]={(float)0.8,(float)0.9,
+ (float)1.0,(float)0.9,(float)0.8};
+ const float sampEn_win[5]={(float)1.0/(float)6.0,
+ (float)2.0/(float)6.0, (float)3.0/(float)6.0,
+ (float)4.0/(float)6.0, (float)5.0/(float)6.0};
+
+ /* init the front and back energies to zero */
+
+ memset(fssqEn, 0, NSUB*sizeof(float));
+ memset(bssqEn, 0, NSUB*sizeof(float));
+
+ /* Calculate front of first seqence */
+
+ n=0;
+ pp=residual;
+ for(l=0;l<5;l++){
+ fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
+ pp++;
+ }
+ for(l=5;l<SUBL;l++){
+ fssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+
+ /* Calculate front and back of all middle sequences */
+
+ for(n=1;n<NSUB-1;n++) {
+ pp=residual+n*SUBL;
+ for(l=0;l<5;l++){
+ fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
+ bssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+ for(l=5;l<SUBL-5;l++){
+ fssqEn[n] += (*pp) * (*pp);
+ bssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+ for(l=SUBL-5;l<SUBL;l++){
+ fssqEn[n] += (*pp) * (*pp);
+ bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
+ pp++;
+ }
+ }
+
+ /* Calculate back of last seqence */
+
+ n=NSUB-1;
+ pp=residual+n*SUBL;
+ for(l=0;l<SUBL-5;l++){
+ bssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+ for(l=SUBL-5;l<SUBL;l++){
+ bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
+ pp++;
+ }
+
+ /* find the index to the weighted 80 sample with
+ most energy */
+
+ max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[0];
+ max_ssqEn_n=1;
+ for (n=2;n<NSUB;n++) {
+
+ if ((fssqEn[n-1]+bssqEn[n])*ssqEn_win[n-1] > max_ssqEn) {
+ max_ssqEn=(fssqEn[n-1]+bssqEn[n]) *
+ ssqEn_win[n-1];
+ max_ssqEn_n=n;
+ }
+ }
+
+ return max_ssqEn_n;
+}
+
+
diff --git a/codecs/ilbc/FrameClassify.h b/codecs/ilbc/FrameClassify.h
new file mode 100755
index 0000000000000000000000000000000000000000..c0d4b4f2e6032598a3a464c692ea538a740ecb41
--- /dev/null
+++ b/codecs/ilbc/FrameClassify.h
@@ -0,0 +1,23 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ FrameClassify.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_FRAMECLASSIFY_H
+#define __iLBC_FRAMECLASSIFY_H
+
+int FrameClassify( /* Index to the max-energy sub frame */
+ float *residual /* (i) lpc residual signal */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/LPCdecode.c b/codecs/ilbc/LPCdecode.c
new file mode 100755
index 0000000000000000000000000000000000000000..5ca53d055bc64dce0f6133a13687e90e795c2e99
--- /dev/null
+++ b/codecs/ilbc/LPCdecode.c
@@ -0,0 +1,121 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ LPC_decode.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "helpfun.h"
+#include "lsf.h"
+#include "iLBC_define.h"
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * interpolation of lsf coefficients for the decoder
+ *---------------------------------------------------------------*/
+
+void LSFinterpolate2a_dec(
+ float *a, /* (o) lpc coefficients for a sub frame */
+ float *lsf1, /* (i) first lsf coefficient vector */
+ float *lsf2, /* (i) second lsf coefficient vector */
+ float coef, /* (i) interpolation weight */
+ int length /* (i) length of lsf vectors */
+){
+ float lsftmp[LPC_FILTERORDER];
+
+ interpolate(lsftmp, lsf1, lsf2, coef, length);
+ lsf2a(a, lsftmp);
+}
+
+/*----------------------------------------------------------------*
+ * obtain dequantized lsf coefficients from quantization index
+ *---------------------------------------------------------------*/
+
+void SimplelsfDEQ(
+ float *lsfdeq, /* (o) dequantized lsf coefficients */
+ int *index /* (i) quantization index */
+){
+ int i,j, pos, cb_pos;
+
+ /* decode first LSF */
+
+ pos = 0;
+ cb_pos = 0;
+ for (i = 0; i < LSF_NSPLIT; i++) {
+ for (j = 0; j < dim_lsfCbTbl[i]; j++) {
+ lsfdeq[pos + j] = lsfCbTbl[cb_pos +
+ (long)(index[i])*dim_lsfCbTbl[i] + j];
+ }
+ pos += dim_lsfCbTbl[i];
+ cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i];
+ }
+
+ /* decode last LSF */
+
+ pos = 0;
+ cb_pos = 0;
+ for (i = 0; i < LSF_NSPLIT; i++) {
+ for (j = 0; j < dim_lsfCbTbl[i]; j++) {
+ lsfdeq[LPC_FILTERORDER + pos + j] = lsfCbTbl[cb_pos +
+ (long)(index[LSF_NSPLIT + i])*dim_lsfCbTbl[i] + j];
+ }
+ pos += dim_lsfCbTbl[i];
+ cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i];
+ }
+}
+
+/*----------------------------------------------------------------*
+ * obtain synthesis and weighting filters form lsf coefficients
+ *---------------------------------------------------------------*/
+
+void DecoderInterpolateLSF(
+ float *syntdenum, /* (o) synthesis filter coefficients */
+ float *weightdenum, /* (o) weighting denumerator
+ coefficients */
+ float *lsfdeq, /* (i) dequantized lsf coefficients */
+ int length, /* (i) length of lsf coefficient vector */
+ iLBC_Dec_Inst_t *iLBCdec_inst
+ /* (i) the decoder state structure */
+){
+ int i, pos, lp_length;
+ float lp[LPC_FILTERORDER + 1], *lsfdeq2;
+
+ lsfdeq2 = lsfdeq + length;
+ lp_length = length + 1;
+
+ /* subframe 1: Interpolation between old and first */
+
+ LSFinterpolate2a_dec(lp, (*iLBCdec_inst).lsfdeqold, lsfdeq,
+ lsf_weightTbl[0], length);
+ memcpy(syntdenum,lp,lp_length*sizeof(float));
+ bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
+
+ /* subframes 2 to 6: interpolation between first and last
+ LSF */
+
+ pos = lp_length;
+ for (i = 1; i < 6; i++) {
+ LSFinterpolate2a_dec(lp, lsfdeq, lsfdeq2, lsf_weightTbl[i],
+ length);
+ memcpy(syntdenum + pos,lp,lp_length*sizeof(float));
+ bwexpand(weightdenum + pos, lp,
+ LPC_CHIRP_WEIGHTDENUM, lp_length);
+ pos += lp_length;
+ }
+
+ /* update memory */
+
+ memcpy((*iLBCdec_inst).lsfdeqold, lsfdeq2, length*sizeof(float));
+
+}
+
+
diff --git a/codecs/ilbc/LPCdecode.h b/codecs/ilbc/LPCdecode.h
new file mode 100755
index 0000000000000000000000000000000000000000..f572648826788110192615cbe4a8f9e3c4e7716d
--- /dev/null
+++ b/codecs/ilbc/LPCdecode.h
@@ -0,0 +1,42 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ LPC_decode.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_LPC_DECODE_H
+#define __iLBC_LPC_DECODE_H
+
+void LSFinterpolate2a_dec(
+ float *a, /* (o) lpc coefficients for a sub frame */
+ float *lsf1, /* (i) first lsf coefficient vector */
+ float *lsf2, /* (i) second lsf coefficient vector */
+ float coef, /* (i) interpolation weight */
+ int length /* (i) length of lsf vectors */
+);
+
+void SimplelsfDEQ(
+ float *lsfdeq, /* (o) dequantized lsf coefficients */
+ int *index /* (i) quantization index */
+);
+
+void DecoderInterpolateLSF(
+ float *syntdenum, /* (o) synthesis filter coefficients */
+ float *weightdenum, /* (o) weighting denumerator
+ coefficients */
+ float *lsfdeq, /* (i) dequantized lsf coefficients */
+ int length, /* (i) length of lsf coefficient vector */
+ iLBC_Dec_Inst_t *iLBCdec_inst
+ /* (i) the decoder state structure */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/LPCencode.c b/codecs/ilbc/LPCencode.c
new file mode 100755
index 0000000000000000000000000000000000000000..330796d7ba6ea8511b09ff3596cee6868cedec8e
--- /dev/null
+++ b/codecs/ilbc/LPCencode.c
@@ -0,0 +1,184 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ LPCencode.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ 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 */
+ float *lpc_buffer /* (i) buffer containing old data */
+){
+ int k, is;
+ float temp[BLOCKL], lp[LPC_FILTERORDER + 1];
+ float lp2[LPC_FILTERORDER + 1];
+ float r[LPC_FILTERORDER + 1];
+
+ memcpy(lpc_buffer+LPC_LOOKBACK,data,BLOCKL*sizeof(float));
+
+ /* No lookahead, last window is asymmetric */
+
+ for (k = 0; k < LPC_N; k++) {
+
+ is = LPC_LOOKBACK;
+
+ if (k < (LPC_N - 1)) {
+ window(temp, lpc_winTbl, lpc_buffer, BLOCKL);
+ } else {
+ window(temp, lpc_asymwinTbl, lpc_buffer + is, BLOCKL);
+ }
+
+ autocorr(r, temp, BLOCKL, 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);
+ }
+ memcpy(lpc_buffer, lpc_buffer+BLOCKL,
+ LPC_LOOKBACK*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 FILTERORDER */
+){
+ int i, pos, lp_length;
+ float lp[LPC_FILTERORDER + 1], *lsf2, *lsfdeq2;
+
+ lsf2 = lsf + length;
+ lsfdeq2 = lsfdeq + length;
+ lp_length = length + 1;
+
+ /* subframe 1: Interpolation between old and first set of
+ lsf coefficients */
+
+ LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
+ lsf_weightTbl[0], length);
+ memcpy(syntdenum,lp,lp_length*sizeof(float));
+ LSFinterpolate2a_enc(lp, lsfold, lsf, lsf_weightTbl[0], length);
+ bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
+
+ /* subframe 2 to 6: Interpolation between first and second
+ set of lsf coefficients */
+
+ pos = lp_length;
+ for (i = 1; i < NSUB; i++) {
+ LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq2,
+ lsf_weightTbl[i], length);
+ memcpy(syntdenum + pos,lp,lp_length*sizeof(float));
+
+ LSFinterpolate2a_enc(lp, lsf, lsf2,
+ lsf_weightTbl[i], length);
+ bwexpand(weightdenum + pos, lp,
+ LPC_CHIRP_WEIGHTDENUM, lp_length);
+ pos += lp_length;
+ }
+
+ /* update memory */
+
+ memcpy(lsfold, lsf2, length*sizeof(float));
+ memcpy(lsfdeqold, lsfdeq2, 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 ) */
+){
+ /* Quantize first LSF with memoryless split VQ */
+ SplitVQ(lsfdeq, index, lsf, lsfCbTbl, LSF_NSPLIT,
+ dim_lsfCbTbl, size_lsfCbTbl);
+
+ /* 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];
+ float lsfdeq[LPC_FILTERORDER * LPC_N];
+ int change=0;
+
+ SimpleAnalysis(lsf, data, (*iLBCenc_inst).lpc_buffer);
+ SimplelsfQ(lsfdeq, lsf_index, lsf);
+ change=LSF_check(lsfdeq, LPC_FILTERORDER, LPC_N);
+ SimpleInterpolateLSF(syntdenum, weightdenum,
+ lsf, lsfdeq, (*iLBCenc_inst).lsfold,
+ (*iLBCenc_inst).lsfdeqold, LPC_FILTERORDER);
+}
+
+
diff --git a/codecs/ilbc/LPCencode.h b/codecs/ilbc/LPCencode.h
new file mode 100755
index 0000000000000000000000000000000000000000..1b6b8374911eddedb989c0b5e68ab9cec5ba69ce
--- /dev/null
+++ b/codecs/ilbc/LPCencode.h
@@ -0,0 +1,30 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ LPCencode.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_LPCENCOD_H
+#define __iLBC_LPCENCOD_H
+
+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 */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/Makefile b/codecs/ilbc/Makefile
new file mode 100755
index 0000000000000000000000000000000000000000..ba7466ee076092ea4d7eaa3999181e57aaacc0d9
--- /dev/null
+++ b/codecs/ilbc/Makefile
@@ -0,0 +1,19 @@
+LIB=libilbc.a
+
+OBJS= anaFilter.o iCBSearch.o packing.o \
+ constants.o gainquant.o iLBC_decode.o StateConstructW.o \
+ createCB.o getCBvec.o iLBC_encode.o StateSearchW.o doCPLC.o \
+ helpfun.o syntFilter.o enhancer.o hpInput.o LPCdecode.o \
+ filter.o hpOutput.o LPCencode.o FrameClassify.o iCBConstruct.o lsf.o
+
+all: $(LIB)
+
+
+$(LIB): $(OBJS)
+ ar cr $(LIB) $(OBJS)
+
+clean:
+ rm -f $(LIB) *.o
+
+install:
+
diff --git a/codecs/ilbc/StateConstructW.c b/codecs/ilbc/StateConstructW.c
new file mode 100755
index 0000000000000000000000000000000000000000..c694106aee60a49b8566df5671cddb07c1d74db2
--- /dev/null
+++ b/codecs/ilbc/StateConstructW.c
@@ -0,0 +1,72 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateConstructW.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include "filter.h"
+
+/*----------------------------------------------------------------*
+ * decoding of the start state
+ *---------------------------------------------------------------*/
+
+void StateConstructW(
+ int idxForMax, /* (i) 6-bit index for the quantization of
+ max amplitude */
+ int *idxVec, /* (i) vector of quantization indexes */
+ float *syntDenum, /* (i) synthesis filter denumerator */
+ float *out, /* (o) the decoded state vector */
+ int len /* (i) length of a state vector */
+){
+ float maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_LEN], *tmp,
+ numerator[LPC_FILTERORDER+1];
+ float foutbuf[LPC_FILTERORDER+2*STATE_LEN], *fout;
+ int k,tmpi;
+
+ /* decoding of the maximum value */
+
+ maxVal = state_frgqTbl[idxForMax];
+ maxVal = (float)pow(10,maxVal)/(float)4.5;
+
+ /* initialization of buffers and coefficients */
+
+ memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
+ memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
+ for(k=0; k<LPC_FILTERORDER; k++){
+ numerator[k]=syntDenum[LPC_FILTERORDER-k];
+ }
+ numerator[LPC_FILTERORDER]=syntDenum[0];
+ tmp = &tmpbuf[LPC_FILTERORDER];
+ fout = &foutbuf[LPC_FILTERORDER];
+
+ /* decoding of the sample values */
+
+ for(k=0; k<len; k++){
+ tmpi = len-1-k;
+ /* maxVal = 1/scal */
+ tmp[k] = maxVal*state_sq3Tbl[idxVec[tmpi]];
+ }
+
+ /* circular convolution with all-pass filter */
+
+ memset(tmp+len, 0, len*sizeof(float));
+ ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
+ LPC_FILTERORDER, fout);
+ for(k=0;k<len;k++){
+ out[k] = fout[len-1-k]+fout[2*len-1-k];
+ }
+}
+
+
diff --git a/codecs/ilbc/StateConstructW.h b/codecs/ilbc/StateConstructW.h
new file mode 100755
index 0000000000000000000000000000000000000000..e2f5db4731d6ad02784c67d45d847208f8120f59
--- /dev/null
+++ b/codecs/ilbc/StateConstructW.h
@@ -0,0 +1,28 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateConstructW.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_STATECONSTRUCTW_H
+#define __iLBC_STATECONSTRUCTW_H
+
+void StateConstructW(
+ int idxForMax, /* (i) 6-bit index for the quantization of
+ max amplitude */
+ int *idxVec, /* (i) vector of quantization indexes */
+ float *syntDenum, /* (i) synthesis filter denumerator */
+ float *out, /* (o) the decoded state vector */
+ int len /* (i) length of a state vector */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/StateSearchW.c b/codecs/ilbc/StateSearchW.c
new file mode 100755
index 0000000000000000000000000000000000000000..3a761d5afa04c85a5bd3ba0500b35d0b685807f1
--- /dev/null
+++ b/codecs/ilbc/StateSearchW.c
@@ -0,0 +1,177 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateSearchW.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include "filter.h"
+#include "helpfun.h"
+
+/*----------------------------------------------------------------*
+ * predictive noise shaping encoding of scaled start state
+ * (subrutine for StateSearchW)
+ *---------------------------------------------------------------*/
+
+void AbsQuantW(
+ 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, syntOutBuf[LPC_FILTERORDER+STATE_SHORT_LEN];
+ 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, 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==(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);
+ }
+}
+
+/*----------------------------------------------------------------*
+ * encoding of start state
+ *---------------------------------------------------------------*/
+
+void StateSearchW(
+ float *residual,/* (i) target residual vector */
+ float *syntDenum, /* (i) lpc synthesis filter */
+ float *weightDenum, /* (i) weighting filter denuminator */
+ int *idxForMax, /* (o) quantizer index for maximum
+ amplitude */
+ int *idxVec, /* (o) vector of quantization indexes */
+ int len, /* (i) length of all vectors */
+ int state_first /* (i) position of start state in the
+ 80 vec */
+){
+ float dtmp, maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN];
+ float *tmp, numerator[1+LPC_FILTERORDER];
+ float foutbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN], *fout;
+ int k;
+ float qmax, scal;
+
+ /* initialization of buffers and filter coefficients */
+
+ memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
+ memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
+ for(k=0; k<LPC_FILTERORDER; k++){
+ numerator[k]=syntDenum[LPC_FILTERORDER-k];
+ }
+ numerator[LPC_FILTERORDER]=syntDenum[0];
+ tmp = &tmpbuf[LPC_FILTERORDER];
+ fout = &foutbuf[LPC_FILTERORDER];
+
+ /* circular convolution with the all-pass filter */
+
+ memcpy(tmp, residual, len*sizeof(float));
+ memset(tmp+len, 0, len*sizeof(float));
+ ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
+ LPC_FILTERORDER, fout);
+ for(k=0;k<len;k++){
+ fout[k] += fout[k+len];
+ }
+
+ /* identification of the maximum amplitude value */
+
+ maxVal = fout[0];
+ for(k=1; k<len; k++){
+
+ if(fout[k]*fout[k] > maxVal*maxVal){
+ maxVal = fout[k];
+ }
+ }
+ maxVal=(float)fabs(maxVal);
+
+ /* encoding of the maximum amplitude value */
+
+ if(maxVal < 10.0){
+ maxVal = 10.0;
+ }
+ maxVal = (float)log10(maxVal);
+ sort_sq(&dtmp, idxForMax, maxVal, state_frgqTbl, 64);
+
+ /* decoding of the maximum amplitude representation value,
+ and corresponding scaling of start state */
+
+ maxVal=state_frgqTbl[*idxForMax];
+ qmax = (float)pow(10,maxVal);
+ scal = (float)(4.5)/qmax;
+ for(k=0;k<len;k++){
+ fout[k] *= scal;
+ }
+
+ /* predictive noise shaping encoding of scaled start state */
+
+ AbsQuantW(fout,syntDenum,weightDenum,idxVec, len, state_first);
+}
+
+
diff --git a/codecs/ilbc/StateSearchW.h b/codecs/ilbc/StateSearchW.h
new file mode 100755
index 0000000000000000000000000000000000000000..2f3f4022d8942ebac452d0962dc6a79050c8b6ba
--- /dev/null
+++ b/codecs/ilbc/StateSearchW.h
@@ -0,0 +1,43 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateSearchW.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_STATESEARCHW_H
+#define __iLBC_STATESEARCHW_H
+
+void AbsQuantW(
+ 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 */
+);
+
+void StateSearchW(
+ float *residual,/* (i) target residual vector */
+ float *syntDenum, /* (i) lpc synthesis filter */
+ float *weightDenum, /* (i) weighting filter denuminator */
+ int *idxForMax, /* (o) quantizer index for maximum
+ amplitude */
+ int *idxVec, /* (o) vector of quantization indexes */
+ int len, /* (i) length of all vectors */
+ int state_first /* (i) position of start state in the
+ 80 vec */
+);
+
+
+#endif
+
+
diff --git a/codecs/ilbc/anaFilter.c b/codecs/ilbc/anaFilter.c
new file mode 100755
index 0000000000000000000000000000000000000000..19b502ef0b22f1b8182f579fc229c511a80d5cfd
--- /dev/null
+++ b/codecs/ilbc/anaFilter.c
@@ -0,0 +1,68 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ anaFilter.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <string.h>
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * LP analysis filter.
+ *---------------------------------------------------------------*/
+
+void anaFilter(
+ float *In, /* (i) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len,/* (i) Length of signal */
+ float *Out, /* (o) Filtered signal */
+ float *mem /* (i/o) Filter state */
+){
+ int i, j;
+ float *po, *pi, *pm, *pa;
+
+ po = Out;
+
+ /* Filter first part using memory from past */
+
+ for (i=0;i<LPC_FILTERORDER;i++) {
+ pi = &In[i];
+ pm = &mem[LPC_FILTERORDER-1];
+ pa = a;
+ *po=0.0;
+ for (j=0;j<=i;j++) {
+ *po+=(*pa++)*(*pi--);
+ }
+ for (j=i+1;j<LPC_FILTERORDER+1;j++) {
+ *po+=(*pa++)*(*pm--);
+ }
+ po++;
+ }
+
+ /* Filter last part where the state is entierly
+ in the input vector */
+
+ for (i=LPC_FILTERORDER;i<len;i++) {
+ pi = &In[i];
+ pa = a;
+ *po=0.0;
+ for (j=0;j<LPC_FILTERORDER+1;j++) {
+ *po+=(*pa++)*(*pi--);
+ }
+ po++;
+ }
+
+ /* Update state vector */
+
+ memcpy(mem, &In[len-LPC_FILTERORDER],
+ LPC_FILTERORDER*sizeof(float));
+}
+
+
diff --git a/codecs/ilbc/anaFilter.h b/codecs/ilbc/anaFilter.h
new file mode 100755
index 0000000000000000000000000000000000000000..9d87c4fa9e473f6ca00ccaae7bbcd18ec3831d96
--- /dev/null
+++ b/codecs/ilbc/anaFilter.h
@@ -0,0 +1,27 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ anaFilter.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ANAFILTER_H
+#define __iLBC_ANAFILTER_H
+
+void anaFilter(
+ float *In, /* (i) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len,/* (i) Length of signal */
+ float *Out, /* (o) Filtered signal */
+ float *mem /* (i/o) Filter state */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/constants.c b/codecs/ilbc/constants.c
new file mode 100755
index 0000000000000000000000000000000000000000..2a99def702bcac423660d6b6b408216a0c612898
--- /dev/null
+++ b/codecs/ilbc/constants.c
@@ -0,0 +1,685 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ constants.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+
+/* bit allocation */
+
+int lsf_bitsTbl[6]={6,7,7,6,7,7};
+int start_bitsTbl=3;
+int scale_bitsTbl=6;
+int state_bitsTbl=3;
+int cb_bitsTbl[5][CB_NSTAGES]={{7,7,7},{8,7,7},
+ {8,8,8},{8,8,8},{8,8,8}};
+int search_rangeTbl[5][CB_NSTAGES]={{58,58,58}, {108,44,44},
+ {108,108,108}, {108,108,108}, {108,108,108}};
+int gain_bitsTbl[3]={5,4,3};
+
+/* ULP bit allocation */
+
+int ulp_lsf_bitsTbl[6][ULP_CLASSES+2]={
+ {6,0,0,0,0},{7,0,0,0,0},
+ {7,0,0,0,0},{6,0,0,0,0},
+ {7,0,0,0,0},{7,0,0,0,0}};
+int ulp_start_bitsTbl[ULP_CLASSES+2]={3,0,0,0,0};
+int ulp_startfirst_bitsTbl[ULP_CLASSES+2]={1,0,0,0,0};
+int ulp_scale_bitsTbl[ULP_CLASSES+2]={6,0,0,0,0};
+int ulp_state_bitsTbl[ULP_CLASSES+2]={0,1,2,0,0};
+
+int ulp_extra_cb_indexTbl[CB_NSTAGES][ULP_CLASSES+2]={
+ {4,2,1,0,0},{0,0,7,0,0},{0,0,7,0,0}};
+int ulp_extra_cb_gainTbl[CB_NSTAGES][ULP_CLASSES+2]={
+ {1,1,3,0,0},{1,1,2,0,0},{0,0,3,0,0}};
+int ulp_cb_indexTbl[NASUB][CB_NSTAGES][ULP_CLASSES+2]={
+ {{6,1,1,0,0},{0,0,7,0,0},{0,0,7,0,0}},
+ {{0,7,1,0,0},{0,0,8,0,0},{0,0,8,0,0}},
+ {{0,7,1,0,0},{0,0,8,0,0},{0,0,8,0,0}},
+ {{0,7,1,0,0},{0,0,8,0,0},{0,0,8,0,0}}};
+int ulp_cb_gainTbl[NASUB][CB_NSTAGES][ULP_CLASSES+2]={
+ {{1,2,2,0,0},{1,2,1,0,0},{0,0,3,0,0}},
+ {{0,2,3,0,0},{0,2,2,0,0},{0,0,3,0,0}},
+ {{0,1,4,0,0},{0,1,3,0,0},{0,0,3,0,0}},
+ {{0,1,4,0,0},{0,1,3,0,0},{0,0,3,0,0}}};
+
+/* HP Filters */
+
+float hpi_zero_coefsTbl[3] = {
+ (float)0.92727436, (float)-1.8544941, (float)0.92727436
+};
+float hpi_pole_coefsTbl[3] = {
+ (float)1.0, (float)-1.9059465, (float)0.9114024
+};
+float hpo_zero_coefsTbl[3] = {
+ (float)0.93980581, (float)-1.8795834, (float)0.93980581
+};
+float hpo_pole_coefsTbl[3] = {
+ (float)1.0, (float)-1.9330735, (float)0.93589199
+};
+
+/* LP Filter */
+
+float lpFilt_coefsTbl[FILTERORDER_DS]={
+ (float)-0.066650, (float)0.125000, (float)0.316650,
+ (float)0.414063, (float)0.316650,
+ (float)0.125000, (float)-0.066650
+};
+
+/* State quantization tables */
+
+float state_sq3Tbl[8] = {
+ (float)-3.719849, (float)-2.177490, (float)-1.130005,
+ (float)-0.309692, (float)0.444214, (float)1.329712,
+ (float)2.436279, (float)3.983887
+};
+
+float state_frgqTbl[64] = {
+ (float)1.000085, (float)1.071695, (float)1.140395,
+ (float)1.206868, (float)1.277188, (float)1.351503,
+ (float)1.429380, (float)1.500727, (float)1.569049,
+ (float)1.639599, (float)1.707071, (float)1.781531,
+ (float)1.840799, (float)1.901550, (float)1.956695,
+ (float)2.006750, (float)2.055474, (float)2.102787,
+ (float)2.142819, (float)2.183592, (float)2.217962,
+ (float)2.257177, (float)2.295739, (float)2.332967,
+ (float)2.369248, (float)2.402792, (float)2.435080,
+ (float)2.468598, (float)2.503394, (float)2.539284,
+ (float)2.572944, (float)2.605036, (float)2.636331,
+ (float)2.668939, (float)2.698780, (float)2.729101,
+ (float)2.759786, (float)2.789834, (float)2.818679,
+ (float)2.848074, (float)2.877470, (float)2.906899,
+ (float)2.936655, (float)2.967804, (float)3.000115,
+ (float)3.033367, (float)3.066355, (float)3.104231,
+ (float)3.141499, (float)3.183012, (float)3.222952,
+ (float)3.265433, (float)3.308441, (float)3.350823,
+ (float)3.395275, (float)3.442793, (float)3.490801,
+ (float)3.542514, (float)3.604064, (float)3.666050,
+ (float)3.740994, (float)3.830749, (float)3.938770,
+ (float)4.101764
+};
+
+/* CB tables */
+
+int stMemLTbl=85;
+int memLfTbl[NASUB]={147,147,147,147};
+
+/* expansion filter(s) */
+
+float cbfiltersTbl[CB_FILTERLEN]={
+ (float)-0.033691, (float)0.083740, (float)-0.144043,
+ (float)0.713379, (float)0.806152, (float)-0.184326,
+ (float)0.108887, (float)-0.034180};
+
+/* Gain Quantization */
+
+float gain_sq3Tbl[8]={
+ (float)-1.000000, (float)-0.659973, (float)-0.330017,
+ (float)0.000000, (float)0.250000, (float)0.500000,
+ (float)0.750000, (float)1.00000};
+
+float gain_sq4Tbl[16]={
+ (float)-1.049988, (float)-0.900024, (float)-0.750000,
+ (float)-0.599976, (float)-0.450012, (float)-0.299988,
+ (float)-0.150024, (float)0.000000, (float)0.150024,
+ (float)0.299988, (float)0.450012, (float)0.599976,
+ (float)0.750000, (float)0.900024, (float)1.049988,
+ (float)1.200012};
+
+float gain_sq5Tbl[32]={
+ (float)0.037476, (float)0.075012, (float)0.112488,
+ (float)0.150024, (float)0.187500, (float)0.224976,
+ (float)0.262512, (float)0.299988, (float)0.337524,
+ (float)0.375000, (float)0.412476, (float)0.450012,
+ (float)0.487488, (float)0.525024, (float)0.562500,
+ (float)0.599976, (float)0.637512, (float)0.674988,
+ (float)0.712524, (float)0.750000, (float)0.787476,
+ (float)0.825012, (float)0.862488, (float)0.900024,
+ (float)0.937500, (float)0.974976, (float)1.012512,
+ (float)1.049988, (float)1.087524, (float)1.125000,
+ (float)1.162476, (float)1.200012};
+
+/* Enhancer - Upsamling a factor 4 (ENH_UPS0 = 4) */
+float polyphaserTbl[ENH_UPS0*(2*ENH_FL0+1)]={
+ (float)0.000000, (float)0.000000, (float)0.000000,
+(float)1.000000,
+ (float)0.000000, (float)0.000000, (float)0.000000,
+ (float)0.015625, (float)-0.076904, (float)0.288330,
+(float)0.862061,
+ (float)-0.106445, (float)0.018799, (float)-0.015625,
+ (float)0.023682, (float)-0.124268, (float)0.601563,
+(float)0.601563,
+ (float)-0.124268, (float)0.023682, (float)-0.023682,
+ (float)0.018799, (float)-0.106445, (float)0.862061,
+(float)0.288330,
+ (float)-0.076904, (float)0.015625, (float)-0.018799};
+
+float enh_plocsTbl[ENH_NBLOCKS_TOT] = {(float)40.0, (float)120.0,
+ (float)200.0, (float)280.0, (float)360.0,
+ (float)440.0, (float)520.0, (float)600.0};
+
+/* LPC analysis and quantization */
+
+int dim_lsfCbTbl[LSF_NSPLIT] = {3, 3, 4};
+int size_lsfCbTbl[LSF_NSPLIT] = {64,128,128};
+
+
+float lsfmeanTbl[LPC_FILTERORDER] = {
+ (float)0.281738, (float)0.445801, (float)0.663330,
+ (float)0.962524, (float)1.251831, (float)1.533081,
+ (float)1.850586, (float)2.137817, (float)2.481445,
+ (float)2.777344};
+
+float lsf_weightTbl[6] = {(float)(1.0/2.0), (float)1.0,
+(float)(2.0/3.0),
+ (float)(1.0/3.0), (float)0.0, (float)0.0};
+
+
+/* Hanning LPC window */
+float lpc_winTbl[BLOCKL]={
+ (float)0.000183, (float)0.000671, (float)0.001526,
+ (float)0.002716, (float)0.004242, (float)0.006104,
+ (float)0.008301, (float)0.010834, (float)0.013702,
+ (float)0.016907, (float)0.020416, (float)0.024261,
+ (float)0.028442, (float)0.032928, (float)0.037750,
+ (float)0.042877, (float)0.048309, (float)0.054047,
+ (float)0.060089, (float)0.066437, (float)0.073090,
+ (float)0.080017, (float)0.087219, (float)0.094727,
+ (float)0.102509, (float)0.110535, (float)0.118835,
+ (float)0.127411, (float)0.136230, (float)0.145294,
+ (float)0.154602, (float)0.164154, (float)0.173920,
+ (float)0.183899, (float)0.194122, (float)0.204529,
+ (float)0.215149, (float)0.225952, (float)0.236938,
+ (float)0.248108, (float)0.259460, (float)0.270966,
+ (float)0.282654, (float)0.294464, (float)0.306396,
+ (float)0.318481, (float)0.330688, (float)0.343018,
+ (float)0.355438, (float)0.367981, (float)0.380585,
+ (float)0.393280, (float)0.406067, (float)0.418884,
+ (float)0.431763, (float)0.444702, (float)0.457672,
+ (float)0.470673, (float)0.483704, (float)0.496735,
+ (float)0.509766, (float)0.522797, (float)0.535828,
+ (float)0.548798, (float)0.561768, (float)0.574677,
+ (float)0.587524, (float)0.600342, (float)0.613068,
+ (float)0.625732, (float)0.638306, (float)0.650787,
+ (float)0.663147, (float)0.675415, (float)0.687561,
+ (float)0.699585, (float)0.711487, (float)0.723206,
+ (float)0.734802, (float)0.746216, (float)0.757477,
+ (float)0.768585, (float)0.779480, (float)0.790192,
+ (float)0.800720, (float)0.811005, (float)0.821106,
+ (float)0.830994, (float)0.840668, (float)0.850067,
+ (float)0.859253, (float)0.868225, (float)0.876892,
+ (float)0.885345, (float)0.893524, (float)0.901428,
+ (float)0.909058, (float)0.916412, (float)0.923492,
+ (float)0.930267, (float)0.936768, (float)0.942963,
+ (float)0.948853, (float)0.954437, (float)0.959717,
+ (float)0.964691, (float)0.969360, (float)0.973694,
+ (float)0.977692, (float)0.981384, (float)0.984741,
+ (float)0.987762, (float)0.990479, (float)0.992828,
+ (float)0.994873, (float)0.996552, (float)0.997925,
+ (float)0.998932, (float)0.999603, (float)0.999969,
+ (float)0.999969, (float)0.999603, (float)0.998932,
+ (float)0.997925, (float)0.996552, (float)0.994873,
+ (float)0.992828, (float)0.990479, (float)0.987762,
+ (float)0.984741, (float)0.981384, (float)0.977692,
+ (float)0.973694, (float)0.969360, (float)0.964691,
+ (float)0.959717, (float)0.954437, (float)0.948853,
+ (float)0.942963, (float)0.936768, (float)0.930267,
+ (float)0.923492, (float)0.916412, (float)0.909058,
+ (float)0.901428, (float)0.893524, (float)0.885345,
+ (float)0.876892, (float)0.868225, (float)0.859253,
+ (float)0.850067, (float)0.840668, (float)0.830994,
+ (float)0.821106, (float)0.811005, (float)0.800720,
+ (float)0.790192, (float)0.779480, (float)0.768585,
+ (float)0.757477, (float)0.746216, (float)0.734802,
+ (float)0.723206, (float)0.711487, (float)0.699585,
+ (float)0.687561, (float)0.675415, (float)0.663147,
+ (float)0.650787, (float)0.638306, (float)0.625732,
+ (float)0.613068, (float)0.600342, (float)0.587524,
+ (float)0.574677, (float)0.561768, (float)0.548798,
+ (float)0.535828, (float)0.522797, (float)0.509766,
+ (float)0.496735, (float)0.483704, (float)0.470673,
+ (float)0.457672, (float)0.444702, (float)0.431763,
+ (float)0.418884, (float)0.406067, (float)0.393280,
+ (float)0.380585, (float)0.367981, (float)0.355438,
+ (float)0.343018, (float)0.330688, (float)0.318481,
+ (float)0.306396, (float)0.294464, (float)0.282654,
+ (float)0.270966, (float)0.259460, (float)0.248108,
+ (float)0.236938, (float)0.225952, (float)0.215149,
+ (float)0.204529, (float)0.194122, (float)0.183899,
+ (float)0.173920, (float)0.164154, (float)0.154602,
+ (float)0.145294, (float)0.136230, (float)0.127411,
+ (float)0.118835, (float)0.110535, (float)0.102509,
+ (float)0.094727, (float)0.087219, (float)0.080017,
+ (float)0.073090, (float)0.066437, (float)0.060089,
+ (float)0.054047, (float)0.048309, (float)0.042877,
+ (float)0.037750, (float)0.032928, (float)0.028442,
+ (float)0.024261, (float)0.020416, (float)0.016907,
+ (float)0.013702, (float)0.010834, (float)0.008301,
+ (float)0.006104, (float)0.004242, (float)0.002716,
+ (float)0.001526, (float)0.000671, (float)0.000183
+};
+
+/* Asymmetric LPC window */
+float lpc_asymwinTbl[BLOCKL]={
+ (float)0.000061, (float)0.000214, (float)0.000458,
+ (float)0.000824, (float)0.001282, (float)0.001831,
+ (float)0.002472, (float)0.003235, (float)0.004120,
+ (float)0.005066, (float)0.006134, (float)0.007294,
+ (float)0.008545, (float)0.009918, (float)0.011383,
+ (float)0.012939, (float)0.014587, (float)0.016357,
+ (float)0.018219, (float)0.020172, (float)0.022217,
+ (float)0.024353, (float)0.026611, (float)0.028961,
+ (float)0.031372, (float)0.033905, (float)0.036530,
+ (float)0.039276, (float)0.042084, (float)0.044983,
+ (float)0.047974, (float)0.051086, (float)0.054260,
+ (float)0.057526, (float)0.060883, (float)0.064331,
+ (float)0.067871, (float)0.071503, (float)0.075226,
+ (float)0.079010, (float)0.082916, (float)0.086884,
+ (float)0.090942, (float)0.095062, (float)0.099304,
+ (float)0.103607, (float)0.107971, (float)0.112427,
+ (float)0.116974, (float)0.121582, (float)0.126282,
+ (float)0.131073, (float)0.135895, (float)0.140839,
+ (float)0.145813, (float)0.150879, (float)0.156006,
+ (float)0.161224, (float)0.166504, (float)0.171844,
+ (float)0.177246, (float)0.182709, (float)0.188263,
+ (float)0.193848, (float)0.199524, (float)0.205231,
+ (float)0.211029, (float)0.216858, (float)0.222778,
+ (float)0.228729, (float)0.234741, (float)0.240814,
+ (float)0.246918, (float)0.253082, (float)0.259308,
+ (float)0.265564, (float)0.271881, (float)0.278259,
+ (float)0.284668, (float)0.291107, (float)0.297607,
+ (float)0.304138, (float)0.310730, (float)0.317322,
+ (float)0.323975, (float)0.330658, (float)0.337372,
+ (float)0.344147, (float)0.350922, (float)0.357727,
+ (float)0.364594, (float)0.371460, (float)0.378357,
+ (float)0.385284, (float)0.392212, (float)0.399170,
+ (float)0.406158, (float)0.413177, (float)0.420197,
+ (float)0.427246, (float)0.434296, (float)0.441376,
+ (float)0.448456, (float)0.455536, (float)0.462646,
+ (float)0.469757, (float)0.476868, (float)0.483978,
+ (float)0.491089, (float)0.498230, (float)0.505341,
+ (float)0.512451, (float)0.519592, (float)0.526703,
+ (float)0.533813, (float)0.540924, (float)0.548004,
+ (float)0.555084, (float)0.562164, (float)0.569244,
+ (float)0.576294, (float)0.583313, (float)0.590332,
+ (float)0.597321, (float)0.604309, (float)0.611267,
+ (float)0.618195, (float)0.625092, (float)0.631989,
+ (float)0.638855, (float)0.645660, (float)0.652466,
+ (float)0.659241, (float)0.665985, (float)0.672668,
+ (float)0.679352, (float)0.685974, (float)0.692566,
+ (float)0.699127, (float)0.705658, (float)0.712128,
+ (float)0.718536, (float)0.724945, (float)0.731262,
+ (float)0.737549, (float)0.743805, (float)0.750000,
+ (float)0.756134, (float)0.762238, (float)0.768280,
+ (float)0.774261, (float)0.780182, (float)0.786072,
+ (float)0.791870, (float)0.797638, (float)0.803314,
+ (float)0.808960, (float)0.814514, (float)0.820038,
+ (float)0.825470, (float)0.830841, (float)0.836151,
+ (float)0.841400, (float)0.846558, (float)0.851654,
+ (float)0.856689, (float)0.861633, (float)0.866516,
+ (float)0.871338, (float)0.876068, (float)0.880737,
+ (float)0.885315, (float)0.889801, (float)0.894226,
+ (float)0.898560, (float)0.902832, (float)0.907013,
+ (float)0.911102, (float)0.915100, (float)0.919037,
+ (float)0.922882, (float)0.926636, (float)0.930328,
+ (float)0.933899, (float)0.937408, (float)0.940796,
+ (float)0.944122, (float)0.947357, (float)0.950470,
+ (float)0.953522, (float)0.956482, (float)0.959351,
+ (float)0.962097, (float)0.964783, (float)0.967377,
+ (float)0.969849, (float)0.972229, (float)0.974518,
+ (float)0.976715, (float)0.978821, (float)0.980835,
+ (float)0.982727, (float)0.984528, (float)0.986237,
+ (float)0.987854, (float)0.989380, (float)0.990784,
+ (float)0.992096, (float)0.993317, (float)0.994415,
+ (float)0.995422, (float)0.996338, (float)0.997162,
+ (float)0.997864, (float)0.998474, (float)0.998962,
+ (float)0.999390, (float)0.999695, (float)0.999878,
+ (float)0.999969, (float)0.999969, (float)0.996918,
+ (float)0.987701, (float)0.972382, (float)0.951050,
+ (float)0.923889, (float)0.891022, (float)0.852631,
+ (float)0.809021, (float)0.760406, (float)0.707092,
+ (float)0.649445, (float)0.587799, (float)0.522491,
+ (float)0.453979, (float)0.382690, (float)0.309021,
+ (float)0.233459, (float)0.156433, (float)0.078461
+};
+
+/* Lag window for LPC */
+float lpc_lagwinTbl[LPC_FILTERORDER + 1]={
+ (float)1.000100, (float)0.998890, (float)0.995569,
+ (float)0.990057, (float)0.982392,
+ (float)0.972623, (float)0.960816, (float)0.947047,
+ (float)0.931405, (float)0.913989, (float)0.894909};
+
+/* LSF quantization*/
+float lsfCbTbl[64 * 3 + 128 * 3 + 128 * 4] = {
+(float)0.155396, (float)0.273193, (float)0.451172,
+(float)0.390503, (float)0.648071, (float)1.002075,
+(float)0.440186, (float)0.692261, (float)0.955688,
+(float)0.343628, (float)0.642334, (float)1.071533,
+(float)0.318359, (float)0.491577, (float)0.670532,
+(float)0.193115, (float)0.375488, (float)0.725708,
+(float)0.364136, (float)0.510376, (float)0.658691,
+(float)0.297485, (float)0.527588, (float)0.842529,
+(float)0.227173, (float)0.365967, (float)0.563110,
+(float)0.244995, (float)0.396729, (float)0.636475,
+(float)0.169434, (float)0.300171, (float)0.520264,
+(float)0.312866, (float)0.464478, (float)0.643188,
+(float)0.248535, (float)0.429932, (float)0.626099,
+(float)0.236206, (float)0.491333, (float)0.817139,
+(float)0.334961, (float)0.625122, (float)0.895752,
+(float)0.343018, (float)0.518555, (float)0.698608,
+(float)0.372803, (float)0.659790, (float)0.945435,
+(float)0.176880, (float)0.316528, (float)0.581421,
+(float)0.416382, (float)0.625977, (float)0.805176,
+(float)0.303223, (float)0.568726, (float)0.915039,
+(float)0.203613, (float)0.351440, (float)0.588135,
+(float)0.221191, (float)0.375000, (float)0.614746,
+(float)0.199951, (float)0.323364, (float)0.476074,
+(float)0.300781, (float)0.433350, (float)0.566895,
+(float)0.226196, (float)0.354004, (float)0.507568,
+(float)0.300049, (float)0.508179, (float)0.711670,
+(float)0.312012, (float)0.492676, (float)0.763428,
+(float)0.329956, (float)0.541016, (float)0.795776,
+(float)0.373779, (float)0.604614, (float)0.928833,
+(float)0.210571, (float)0.452026, (float)0.755249,
+(float)0.271118, (float)0.473267, (float)0.662476,
+(float)0.285522, (float)0.436890, (float)0.634399,
+(float)0.246704, (float)0.565552, (float)0.859009,
+(float)0.270508, (float)0.406250, (float)0.553589,
+(float)0.361450, (float)0.578491, (float)0.813843,
+(float)0.342651, (float)0.482788, (float)0.622437,
+(float)0.340332, (float)0.549438, (float)0.743164,
+(float)0.200439, (float)0.336304, (float)0.540894,
+(float)0.407837, (float)0.644775, (float)0.895142,
+(float)0.294678, (float)0.454834, (float)0.699097,
+(float)0.193115, (float)0.344482, (float)0.643188,
+(float)0.275757, (float)0.420776, (float)0.598755,
+(float)0.380493, (float)0.608643, (float)0.861084,
+(float)0.222778, (float)0.426147, (float)0.676514,
+(float)0.407471, (float)0.700195, (float)1.053101,
+(float)0.218384, (float)0.377197, (float)0.669922,
+(float)0.313232, (float)0.454102, (float)0.600952,
+(float)0.347412, (float)0.571533, (float)0.874146,
+(float)0.238037, (float)0.405396, (float)0.729492,
+(float)0.223877, (float)0.412964, (float)0.822021,
+(float)0.395264, (float)0.582153, (float)0.743896,
+(float)0.247925, (float)0.485596, (float)0.720581,
+(float)0.229126, (float)0.496582, (float)0.907715,
+(float)0.260132, (float)0.566895, (float)1.012695,
+(float)0.337402, (float)0.611572, (float)0.978149,
+(float)0.267822, (float)0.447632, (float)0.769287,
+(float)0.250610, (float)0.381714, (float)0.530029,
+(float)0.430054, (float)0.805054, (float)1.221924,
+(float)0.382568, (float)0.544067, (float)0.701660,
+(float)0.383545, (float)0.710327, (float)1.149170,
+(float)0.271362, (float)0.529053, (float)0.775513,
+(float)0.246826, (float)0.393555, (float)0.588623,
+(float)0.266846, (float)0.422119, (float)0.676758,
+(float)0.311523, (float)0.580688, (float)0.838623,
+(float)1.331177, (float)1.576782, (float)1.779541,
+(float)1.160034, (float)1.401978, (float)1.768188,
+(float)1.161865, (float)1.525146, (float)1.715332,
+(float)0.759521, (float)0.913940, (float)1.119873,
+(float)0.947144, (float)1.121338, (float)1.282471,
+(float)1.015015, (float)1.557007, (float)1.804932,
+(float)1.172974, (float)1.402100, (float)1.692627,
+(float)1.087524, (float)1.474243, (float)1.665405,
+(float)0.899536, (float)1.105225, (float)1.406250,
+(float)1.148438, (float)1.484741, (float)1.796265,
+(float)0.785645, (float)1.209839, (float)1.567749,
+(float)0.867798, (float)1.166504, (float)1.450684,
+(float)0.922485, (float)1.229858, (float)1.420898,
+(float)0.791260, (float)1.123291, (float)1.409546,
+(float)0.788940, (float)0.966064, (float)1.340332,
+(float)1.051147, (float)1.272827, (float)1.556641,
+(float)0.866821, (float)1.181152, (float)1.538818,
+(float)0.906738, (float)1.373535, (float)1.607910,
+(float)1.244751, (float)1.581421, (float)1.933838,
+(float)0.913940, (float)1.337280, (float)1.539673,
+(float)0.680542, (float)0.959229, (float)1.662720,
+(float)0.887207, (float)1.430542, (float)1.800781,
+(float)0.912598, (float)1.433594, (float)1.683960,
+(float)0.860474, (float)1.060303, (float)1.455322,
+(float)1.005127, (float)1.381104, (float)1.706909,
+(float)0.800781, (float)1.363892, (float)1.829102,
+(float)0.781860, (float)1.124390, (float)1.505981,
+(float)1.003662, (float)1.471436, (float)1.684692,
+(float)0.981323, (float)1.309570, (float)1.618042,
+(float)1.228760, (float)1.554321, (float)1.756470,
+(float)0.734375, (float)0.895752, (float)1.225586,
+(float)0.841797, (float)1.055664, (float)1.249268,
+(float)0.920166, (float)1.119385, (float)1.486206,
+(float)0.894409, (float)1.539063, (float)1.828979,
+(float)1.283691, (float)1.543335, (float)1.858276,
+(float)0.676025, (float)0.933105, (float)1.490845,
+(float)0.821289, (float)1.491821, (float)1.739868,
+(float)0.923218, (float)1.144653, (float)1.580566,
+(float)1.057251, (float)1.345581, (float)1.635864,
+(float)0.888672, (float)1.074951, (float)1.353149,
+(float)0.942749, (float)1.195435, (float)1.505493,
+(float)1.492310, (float)1.788086, (float)2.039673,
+(float)1.070313, (float)1.634399, (float)1.860962,
+(float)1.253296, (float)1.488892, (float)1.686035,
+(float)0.647095, (float)0.864014, (float)1.401855,
+(float)0.866699, (float)1.254883, (float)1.453369,
+(float)1.063965, (float)1.532593, (float)1.731323,
+(float)1.167847, (float)1.521484, (float)1.884033,
+(float)0.956055, (float)1.502075, (float)1.745605,
+(float)0.928711, (float)1.288574, (float)1.479614,
+(float)1.088013, (float)1.380737, (float)1.570801,
+(float)0.905029, (float)1.186768, (float)1.371948,
+(float)1.057861, (float)1.421021, (float)1.617432,
+(float)1.108276, (float)1.312500, (float)1.501465,
+(float)0.979492, (float)1.416992, (float)1.624268,
+(float)1.276001, (float)1.661011, (float)2.007935,
+(float)0.993042, (float)1.168579, (float)1.331665,
+(float)0.778198, (float)0.944946, (float)1.235962,
+(float)1.223755, (float)1.491333, (float)1.815674,
+(float)0.852661, (float)1.350464, (float)1.722290,
+(float)1.134766, (float)1.593140, (float)1.787354,
+(float)1.051392, (float)1.339722, (float)1.531006,
+(float)0.803589, (float)1.271240, (float)1.652100,
+(float)0.755737, (float)1.143555, (float)1.639404,
+(float)0.700928, (float)0.837280, (float)1.130371,
+(float)0.942749, (float)1.197876, (float)1.669800,
+(float)0.993286, (float)1.378296, (float)1.566528,
+(float)0.801025, (float)1.095337, (float)1.298950,
+(float)0.739990, (float)1.032959, (float)1.383667,
+(float)0.845703, (float)1.072266, (float)1.543823,
+(float)0.915649, (float)1.072266, (float)1.224487,
+(float)1.021973, (float)1.226196, (float)1.481323,
+(float)0.999878, (float)1.204102, (float)1.555908,
+(float)0.722290, (float)0.913940, (float)1.340210,
+(float)0.673340, (float)0.835938, (float)1.259521,
+(float)0.832397, (float)1.208374, (float)1.394165,
+(float)0.962158, (float)1.576172, (float)1.912842,
+(float)1.166748, (float)1.370850, (float)1.556763,
+(float)0.946289, (float)1.138550, (float)1.400391,
+(float)1.035034, (float)1.218262, (float)1.386475,
+(float)1.393799, (float)1.717773, (float)2.000244,
+(float)0.972656, (float)1.260986, (float)1.760620,
+(float)1.028198, (float)1.288452, (float)1.484619,
+(float)0.773560, (float)1.258057, (float)1.756714,
+(float)1.080322, (float)1.328003, (float)1.742676,
+(float)0.823975, (float)1.450806, (float)1.917725,
+(float)0.859009, (float)1.016602, (float)1.191895,
+(float)0.843994, (float)1.131104, (float)1.645020,
+(float)1.189697, (float)1.702759, (float)1.894409,
+(float)1.346680, (float)1.763184, (float)2.066040,
+(float)0.980469, (float)1.253784, (float)1.441650,
+(float)1.338135, (float)1.641968, (float)1.932739,
+(float)1.223267, (float)1.424194, (float)1.626465,
+(float)0.765747, (float)1.004150, (float)1.579102,
+(float)1.042847, (float)1.269165, (float)1.647461,
+(float)0.968750, (float)1.257568, (float)1.555786,
+(float)0.826294, (float)0.993408, (float)1.275146,
+(float)0.742310, (float)0.950439, (float)1.430542,
+(float)1.054321, (float)1.439819, (float)1.828003,
+(float)1.072998, (float)1.261719, (float)1.441895,
+(float)0.859375, (float)1.036377, (float)1.314819,
+(float)0.895752, (float)1.267212, (float)1.605591,
+(float)0.805420, (float)0.962891, (float)1.142334,
+(float)0.795654, (float)1.005493, (float)1.468506,
+(float)1.105347, (float)1.313843, (float)1.584839,
+(float)0.792236, (float)1.221802, (float)1.465698,
+(float)1.170532, (float)1.467651, (float)1.664063,
+(float)0.838257, (float)1.153198, (float)1.342163,
+(float)0.968018, (float)1.198242, (float)1.391235,
+(float)1.250122, (float)1.623535, (float)1.823608,
+(float)0.711670, (float)1.058350, (float)1.512085,
+(float)1.204834, (float)1.454468, (float)1.739136,
+(float)1.137451, (float)1.421753, (float)1.620117,
+(float)0.820435, (float)1.322754, (float)1.578247,
+(float)0.798706, (float)1.005005, (float)1.213867,
+(float)0.980713, (float)1.324951, (float)1.512939,
+(float)1.112305, (float)1.438843, (float)1.735596,
+(float)1.135498, (float)1.356689, (float)1.635742,
+(float)1.101318, (float)1.387451, (float)1.686523,
+(float)0.849854, (float)1.276978, (float)1.523438,
+(float)1.377930, (float)1.627563, (float)1.858154,
+(float)0.884888, (float)1.095459, (float)1.287476,
+(float)1.289795, (float)1.505859, (float)1.756592,
+(float)0.817505, (float)1.384155, (float)1.650513,
+(float)1.446655, (float)1.702148, (float)1.931885,
+(float)0.835815, (float)1.023071, (float)1.385376,
+(float)0.916626, (float)1.139038, (float)1.335327,
+(float)0.980103, (float)1.174072, (float)1.453735,
+(float)1.705688, (float)2.153809, (float)2.398315, (float)2.743408,
+(float)1.797119, (float)2.016846, (float)2.445679, (float)2.701904,
+(float)1.990356, (float)2.219116, (float)2.576416, (float)2.813477,
+(float)1.849365, (float)2.190918, (float)2.611572, (float)2.835083,
+(float)1.657959, (float)1.854370, (float)2.159058, (float)2.726196,
+(float)1.437744, (float)1.897705, (float)2.253174, (float)2.655396,
+(float)2.028687, (float)2.247314, (float)2.542358, (float)2.875854,
+(float)1.736938, (float)1.922119, (float)2.185913, (float)2.743408,
+(float)1.521606, (float)1.870972, (float)2.526855, (float)2.786987,
+(float)1.841431, (float)2.050659, (float)2.463623, (float)2.857666,
+(float)1.590088, (float)2.067261, (float)2.427979, (float)2.794434,
+(float)1.746826, (float)2.057373, (float)2.320190, (float)2.800781,
+(float)1.734619, (float)1.940552, (float)2.306030, (float)2.826416,
+(float)1.786255, (float)2.204468, (float)2.457520, (float)2.795288,
+(float)1.861084, (float)2.170532, (float)2.414551, (float)2.763672,
+(float)2.001465, (float)2.307617, (float)2.552734, (float)2.811890,
+(float)1.784424, (float)2.124146, (float)2.381592, (float)2.645508,
+(float)1.888794, (float)2.135864, (float)2.418579, (float)2.861206,
+(float)2.301147, (float)2.531250, (float)2.724976, (float)2.913086,
+(float)1.837769, (float)2.051270, (float)2.261963, (float)2.553223,
+(float)2.012939, (float)2.221191, (float)2.440186, (float)2.678101,
+(float)1.429565, (float)1.858276, (float)2.582275, (float)2.845703,
+(float)1.622803, (float)1.897705, (float)2.367310, (float)2.621094,
+(float)1.581543, (float)1.960449, (float)2.515869, (float)2.736450,
+(float)1.419434, (float)1.933960, (float)2.394653, (float)2.746704,
+(float)1.721924, (float)2.059570, (float)2.421753, (float)2.769653,
+(float)1.911011, (float)2.220703, (float)2.461060, (float)2.740723,
+(float)1.581177, (float)1.860840, (float)2.516968, (float)2.874634,
+(float)1.870361, (float)2.098755, (float)2.432373, (float)2.656494,
+(float)2.059692, (float)2.279785, (float)2.495605, (float)2.729370,
+(float)1.815674, (float)2.181519, (float)2.451538, (float)2.680542,
+(float)1.407959, (float)1.768311, (float)2.343018, (float)2.668091,
+(float)2.168701, (float)2.394653, (float)2.604736, (float)2.829346,
+(float)1.636230, (float)1.865723, (float)2.329102, (float)2.824219,
+(float)1.878906, (float)2.139526, (float)2.376709, (float)2.679810,
+(float)1.765381, (float)1.971802, (float)2.195435, (float)2.586914,
+(float)2.164795, (float)2.410889, (float)2.673706, (float)2.903198,
+(float)2.071899, (float)2.331055, (float)2.645874, (float)2.907104,
+(float)2.026001, (float)2.311523, (float)2.594849, (float)2.863892,
+(float)1.948975, (float)2.180786, (float)2.514893, (float)2.797852,
+(float)1.881836, (float)2.130859, (float)2.478149, (float)2.804199,
+(float)2.238159, (float)2.452759, (float)2.652832, (float)2.868286,
+(float)1.897949, (float)2.101685, (float)2.524292, (float)2.880127,
+(float)1.856445, (float)2.074585, (float)2.541016, (float)2.791748,
+(float)1.695557, (float)2.199097, (float)2.506226, (float)2.742676,
+(float)1.612671, (float)1.877075, (float)2.435425, (float)2.732910,
+(float)1.568848, (float)1.786499, (float)2.194580, (float)2.768555,
+(float)1.953369, (float)2.164551, (float)2.486938, (float)2.874023,
+(float)1.388306, (float)1.725342, (float)2.384521, (float)2.771851,
+(float)2.115356, (float)2.337769, (float)2.592896, (float)2.864014,
+(float)1.905762, (float)2.111328, (float)2.363525, (float)2.789307,
+(float)1.882568, (float)2.332031, (float)2.598267, (float)2.827637,
+(float)1.683594, (float)2.088745, (float)2.361938, (float)2.608643,
+(float)1.874023, (float)2.182129, (float)2.536133, (float)2.766968,
+(float)1.861938, (float)2.070435, (float)2.309692, (float)2.700562,
+(float)1.722168, (float)2.107422, (float)2.477295, (float)2.837646,
+(float)1.926880, (float)2.184692, (float)2.442627, (float)2.663818,
+(float)2.123901, (float)2.337280, (float)2.553101, (float)2.777466,
+(float)1.588135, (float)1.911499, (float)2.212769, (float)2.543945,
+(float)2.053955, (float)2.370850, (float)2.712158, (float)2.939941,
+(float)2.210449, (float)2.519653, (float)2.770386, (float)2.958618,
+(float)2.199463, (float)2.474731, (float)2.718262, (float)2.919922,
+(float)1.960083, (float)2.175415, (float)2.608032, (float)2.888794,
+(float)1.953735, (float)2.185181, (float)2.428223, (float)2.809570,
+(float)1.615234, (float)2.036499, (float)2.576538, (float)2.834595,
+(float)1.621094, (float)2.028198, (float)2.431030, (float)2.664673,
+(float)1.824951, (float)2.267456, (float)2.514526, (float)2.747925,
+(float)1.994263, (float)2.229126, (float)2.475220, (float)2.833984,
+(float)1.746338, (float)2.011353, (float)2.588257, (float)2.826904,
+(float)1.562866, (float)2.135986, (float)2.471680, (float)2.687256,
+(float)1.748901, (float)2.083496, (float)2.460938, (float)2.686279,
+(float)1.758057, (float)2.131470, (float)2.636597, (float)2.891602,
+(float)2.071289, (float)2.299072, (float)2.550781, (float)2.814331,
+(float)1.839600, (float)2.094360, (float)2.496460, (float)2.723999,
+(float)1.882202, (float)2.088257, (float)2.636841, (float)2.923096,
+(float)1.957886, (float)2.153198, (float)2.384399, (float)2.615234,
+(float)1.992920, (float)2.351196, (float)2.654419, (float)2.889771,
+(float)2.012817, (float)2.262451, (float)2.643799, (float)2.903076,
+(float)2.025635, (float)2.254761, (float)2.508423, (float)2.784058,
+(float)2.316040, (float)2.589355, (float)2.794189, (float)2.963623,
+(float)1.741211, (float)2.279541, (float)2.578491, (float)2.816284,
+(float)1.845337, (float)2.055786, (float)2.348511, (float)2.822021,
+(float)1.679932, (float)1.926514, (float)2.499756, (float)2.835693,
+(float)1.722534, (float)1.946899, (float)2.448486, (float)2.728760,
+(float)1.829834, (float)2.043213, (float)2.580444, (float)2.867676,
+(float)1.676636, (float)2.071655, (float)2.322510, (float)2.704834,
+(float)1.791504, (float)2.113525, (float)2.469727, (float)2.784058,
+(float)1.977051, (float)2.215088, (float)2.497437, (float)2.726929,
+(float)1.800171, (float)2.106689, (float)2.357788, (float)2.738892,
+(float)1.827759, (float)2.170166, (float)2.525879, (float)2.852417,
+(float)1.918335, (float)2.132813, (float)2.488403, (float)2.728149,
+(float)1.916748, (float)2.225098, (float)2.542603, (float)2.857666,
+(float)1.761230, (float)1.976074, (float)2.507446, (float)2.884521,
+(float)2.053711, (float)2.367432, (float)2.608032, (float)2.837646,
+(float)1.595337, (float)2.000977, (float)2.307129, (float)2.578247,
+(float)1.470581, (float)2.031250, (float)2.375854, (float)2.647583,
+(float)1.801392, (float)2.128052, (float)2.399780, (float)2.822876,
+(float)1.853638, (float)2.066650, (float)2.429199, (float)2.751465,
+(float)1.956299, (float)2.163696, (float)2.394775, (float)2.734253,
+(float)1.963623, (float)2.275757, (float)2.585327, (float)2.865234,
+(float)1.887451, (float)2.105469, (float)2.331787, (float)2.587402,
+(float)2.120117, (float)2.443359, (float)2.733887, (float)2.941406,
+(float)1.506348, (float)1.766968, (float)2.400513, (float)2.851807,
+(float)1.664551, (float)1.981079, (float)2.375732, (float)2.774414,
+(float)1.720703, (float)1.978882, (float)2.391479, (float)2.640991,
+(float)1.483398, (float)1.814819, (float)2.434448, (float)2.722290,
+(float)1.769043, (float)2.136597, (float)2.563721, (float)2.774414,
+(float)1.810791, (float)2.049316, (float)2.373901, (float)2.613647,
+(float)1.788330, (float)2.005981, (float)2.359131, (float)2.723145,
+(float)1.785156, (float)1.993164, (float)2.399780, (float)2.832520,
+(float)1.695313, (float)2.022949, (float)2.522583, (float)2.745117,
+(float)1.584106, (float)1.965576, (float)2.299927, (float)2.715576,
+(float)1.894897, (float)2.249878, (float)2.655884, (float)2.897705,
+(float)1.720581, (float)1.995728, (float)2.299438, (float)2.557007,
+(float)1.619385, (float)2.173950, (float)2.574219, (float)2.787964,
+(float)1.883179, (float)2.220459, (float)2.474365, (float)2.825073,
+(float)1.447632, (float)2.045044, (float)2.555542, (float)2.744873,
+(float)1.502686, (float)2.156616, (float)2.653320, (float)2.846558,
+(float)1.711548, (float)1.944092, (float)2.282959, (float)2.685791,
+(float)1.499756, (float)1.867554, (float)2.341064, (float)2.578857,
+(float)1.916870, (float)2.135132, (float)2.568237, (float)2.826050,
+(float)1.498047, (float)1.711182, (float)2.223267, (float)2.755127,
+(float)1.808716, (float)1.997559, (float)2.256470, (float)2.758545,
+(float)2.088501, (float)2.402710, (float)2.667358, (float)2.890259,
+(float)1.545044, (float)1.819214, (float)2.324097, (float)2.692993,
+(float)1.796021, (float)2.012573, (float)2.505737, (float)2.784912,
+(float)1.786499, (float)2.041748, (float)2.290405, (float)2.650757,
+(float)1.938232, (float)2.264404, (float)2.529053, (float)2.796143
+};
+
+
diff --git a/codecs/ilbc/constants.h b/codecs/ilbc/constants.h
new file mode 100755
index 0000000000000000000000000000000000000000..954d511fd28f68b03bc27bb87d57788337510a55
--- /dev/null
+++ b/codecs/ilbc/constants.h
@@ -0,0 +1,85 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ constants.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_CONSTANTS_H
+#define __iLBC_CONSTANTS_H
+
+#include "iLBC_define.h"
+
+/* bit allocation */
+
+extern int lsf_bitsTbl[];
+extern int start_bitsTbl;
+extern int scale_bitsTbl;
+extern int state_bitsTbl;
+extern int cb_bitsTbl[5][CB_NSTAGES];
+extern int search_rangeTbl[5][CB_NSTAGES];
+extern int gain_bitsTbl[];
+
+/* ULP bit allocation */
+
+extern int ulp_lsf_bitsTbl[6][ULP_CLASSES+2];
+extern int ulp_start_bitsTbl[];
+extern int ulp_startfirst_bitsTbl[];
+extern int ulp_scale_bitsTbl[];
+extern int ulp_state_bitsTbl[];
+extern int ulp_extra_cb_indexTbl[CB_NSTAGES][ULP_CLASSES+2];
+extern int ulp_extra_cb_gainTbl[CB_NSTAGES][ULP_CLASSES+2];
+extern int ulp_cb_indexTbl[NASUB][CB_NSTAGES][ULP_CLASSES+2];
+extern int ulp_cb_gainTbl[NASUB][CB_NSTAGES][ULP_CLASSES+2];
+
+/* high pass filters */
+
+extern float hpi_zero_coefsTbl[];
+extern float hpi_pole_coefsTbl[];
+extern float hpo_zero_coefsTbl[];
+extern float hpo_pole_coefsTbl[];
+
+/* low pass filters */
+extern float lpFilt_coefsTbl[];
+
+/* LPC analysis and quantization */
+
+extern float lpc_winTbl[];
+extern float lpc_asymwinTbl[];
+extern float lpc_lagwinTbl[];
+extern float lsfCbTbl[];
+extern float lsfmeanTbl[];
+extern int dim_lsfCbTbl[];
+extern int size_lsfCbTbl[];
+extern float lsf_weightTbl[];
+
+/* state quantization tables */
+
+extern float state_sq3Tbl[];
+extern float state_frgqTbl[];
+
+/* gain quantization tables */
+
+extern float gain_sq3Tbl[];
+extern float gain_sq4Tbl[];
+extern float gain_sq5Tbl[];
+
+/* adaptive codebook definitions */
+
+extern int memLfTbl[];
+extern int stMemLTbl;
+extern float cbfiltersTbl[CB_FILTERLEN];
+
+/* enhancer definitions */
+
+extern float polyphaserTbl[];
+extern float enh_plocsTbl[];
+
+#endif
+
diff --git a/codecs/ilbc/createCB.c b/codecs/ilbc/createCB.c
new file mode 100755
index 0000000000000000000000000000000000000000..b16ef4610ce595b0f7c31b966e8066722b03db9d
--- /dev/null
+++ b/codecs/ilbc/createCB.c
@@ -0,0 +1,207 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ createCB.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include <string.h>
+#include <math.h>
+
+/*----------------------------------------------------------------*
+ * Construct an additional codebook vector by filtering the
+ * initial codebook buffer. This vector is then used to expand
+ * the codebook with an additional section.
+ *---------------------------------------------------------------*/
+
+void filteredCBvecs(
+ float *cbvectors, /* (o) Codebook vectors for the higher
+section */
+ float *mem, /* (i) Buffer to create codebook vector from
+*/
+ int lMem /* (i) Length of buffer */
+){
+ int j, k;
+ float *pp, *pp1;
+ float tempbuff2[CB_MEML+CB_FILTERLEN];
+ float *pos;
+
+ memset(tempbuff2, 0, (CB_HALFFILTERLEN-1)*sizeof(float));
+ memcpy(&tempbuff2[CB_HALFFILTERLEN-1], mem, lMem*sizeof(float));
+ memset(&tempbuff2[lMem+CB_HALFFILTERLEN-1], 0,
+ (CB_HALFFILTERLEN+1)*sizeof(float));
+
+ /* Create codebook vector for higher section by filtering */
+
+ /* do filtering */
+ pos=cbvectors;
+ memset(pos, 0, lMem*sizeof(float));
+ for (k=0; k<lMem; k++) {
+ pp=&tempbuff2[k];
+ pp1=&cbfiltersTbl[0];
+ for (j=0;j<CB_FILTERLEN;j++) {
+ (*pos)+=(*pp++)*(*pp1++);
+ }
+ pos++;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * Search the augmented part of the codebook to find the best
+ * measure.
+ *----------------------------------------------------------------*/
+
+void searchAugmentedCB(
+ int low, /* (i) Start index for the search */
+ int high, /* (i) End index for the search */
+ int stage, /* (i) Current stage */
+ int startIndex, /* (i) Codebook index for the first
+ aug vector */
+ float *target, /* (i) Target vector for encoding */
+ float *buffer, /* (i) Pointer to the end of the buffer for
+ augmented codebook construction */
+ float *max_measure, /* (i/o) Currently maximum measure */
+ int *best_index,/* (o) Currently the best index */
+ float *gain, /* (o) Currently the best gain */
+ float *energy, /* (o) Energy of augmented codebook
+ vectors */
+ float *invenergy/* (o) Inv energy of augmented codebook
+ vectors */
+) {
+ int lagcount, ilow, j, tmpIndex;
+ float *pp, *ppo, *ppi, *ppe, crossDot, alfa;
+ float weighted, measure, nrjRecursive;
+ float ftmp;
+
+ /* Compute the energy for the first (low-5)
+ noninterpolated samples */
+ nrjRecursive = (float) 0.0;
+ pp = buffer - low + 1;
+ for (j=0; j<(low-5); j++) {
+ nrjRecursive += ( (*pp)*(*pp) );
+ pp++;
+ }
+ ppe = buffer - low;
+
+
+ for (lagcount=low; lagcount<=high; lagcount++) {
+
+ /* Index of the codebook vector used for retrieving
+ energy values */
+ tmpIndex = startIndex+lagcount-20;
+
+ ilow = lagcount-4;
+
+ /* Update the energy recursively to save complexity */
+ nrjRecursive = nrjRecursive + (*ppe)*(*ppe);
+ ppe--;
+ energy[tmpIndex] = nrjRecursive;
+
+ /* Compute cross dot product for the first (low-5) samples */
+ crossDot = (float) 0.0;
+ pp = buffer-lagcount;
+ for (j=0; j<ilow; j++) {
+ crossDot += target[j]*(*pp++);
+ }
+
+ /* interpolation */
+ alfa = (float) 0.2;
+ ppo = buffer-4;
+ ppi = buffer-lagcount-4;
+ for (j=ilow; j<lagcount; j++) {
+ weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
+ ppo++;
+ ppi++;
+ energy[tmpIndex] += weighted*weighted;
+ crossDot += target[j]*weighted;
+ alfa += (float)0.2;
+ }
+
+ /* Compute energy and cross dot product for the
+ remaining samples */
+ pp = buffer - lagcount;
+ for (j=lagcount; j<SUBL; j++) {
+ energy[tmpIndex] += (*pp)*(*pp);
+ crossDot += target[j]*(*pp++);
+ }
+
+ if(energy[tmpIndex]>0.0) {
+ invenergy[tmpIndex]=(float)1.0/(energy[tmpIndex]+EPS);
+ } else {
+ invenergy[tmpIndex] = (float) 0.0;
+ }
+
+ if (stage==0) {
+ measure = (float)-10000000.0;
+
+ if (crossDot > 0.0) {
+ measure = crossDot*crossDot*invenergy[tmpIndex];
+ }
+ }
+ else {
+ measure = crossDot*crossDot*invenergy[tmpIndex];
+ }
+
+ /* check if measure is better */
+ ftmp = crossDot*invenergy[tmpIndex];
+
+ if ((measure>*max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
+ *best_index = tmpIndex;
+ *max_measure = measure;
+ *gain = ftmp;
+ }
+ }
+}
+
+
+/*----------------------------------------------------------------*
+ * Recreate a specific codebook vector from the augmented part.
+ *
+ *----------------------------------------------------------------*/
+
+void createAugmentedVec(
+ int index, /* (i) Index for the augmented vector
+ to be created */
+ float *buffer, /* (i) Pointer to the end of the buffer for
+ augmented codebook construction */
+ float *cbVec/* (o) The construced codebook vector */
+) {
+ int ilow, j;
+ float *pp, *ppo, *ppi, alfa, alfa1, weighted;
+
+ ilow = index-5;
+
+ /* copy the first noninterpolated part */
+
+ pp = buffer-index;
+ memcpy(cbVec,pp,sizeof(float)*index);
+
+ /* interpolation */
+
+ alfa1 = (float)0.2;
+ alfa = 0.0;
+ ppo = buffer-5;
+ ppi = buffer-index-5;
+ for (j=ilow; j<index; j++) {
+ weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
+ ppo++;
+ ppi++;
+ cbVec[j] = weighted;
+ alfa += alfa1;
+ }
+
+ /* copy the second noninterpolated part */
+
+ pp = buffer - index;
+ memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index));
+}
+
+
diff --git a/codecs/ilbc/createCB.h b/codecs/ilbc/createCB.h
new file mode 100755
index 0000000000000000000000000000000000000000..41bbead146ef6a5deda2d29f8cac3bcbec67224e
--- /dev/null
+++ b/codecs/ilbc/createCB.h
@@ -0,0 +1,55 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ createCB.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_CREATECB_H
+#define __iLBC_CREATECB_H
+
+void filteredCBvecs(
+ float *cbvectors, /* (o) Codebook vector for the
+ higher section */
+ float *mem, /* (i) Buffer to create codebook
+ vectors from */
+ int lMem /* (i) Length of buffer */
+);
+
+void searchAugmentedCB(
+ int low, /* (i) Start index for the search */
+ int high, /* (i) End index for the search */
+ int stage, /* (i) Current stage */
+ int startIndex, /* (i) CB index for the first
+ augmented vector */
+ float *target, /* (i) Target vector for encoding */
+ float *buffer, /* (i) Pointer to the end of the
+ buffer for augmented codebook
+ construction */
+ float *max_measure, /* (i/o) Currently maximum measure */
+ int *best_index,/* (o) Currently the best index */
+ float *gain, /* (o) Currently the best gain */
+ float *energy, /* (o) Energy of augmented
+ codebook vectors */
+ float *invenergy/* (o) Inv energy of aug codebook
+ vectors */
+);
+
+void createAugmentedVec(
+ int index, /* (i) Index for the aug vector
+ to be created */
+ float *buffer, /* (i) Pointer to the end of the
+ buffer for augmented codebook
+ construction */
+ float *cbVec /* (o) The construced codebook vector */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/doCPLC.c b/codecs/ilbc/doCPLC.c
new file mode 100755
index 0000000000000000000000000000000000000000..0b0083b097faf4a0a3d87aea77d8b33c17bfedf9
--- /dev/null
+++ b/codecs/ilbc/doCPLC.c
@@ -0,0 +1,303 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ doCPLC.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * Compute cross correlation and pitch gain for pitch prediction
+ * of last subframe at given lag.
+ *---------------------------------------------------------------*/
+
+void compCorr(
+ float *cc, /* (o) cross correlation coefficient */
+ float *gc, /* (o) gain */
+ float *buffer, /* (i) signal buffer */
+ int lag, /* (i) pitch lag */
+ int bLen, /* (i) length of buffer */
+ int sRange /* (i) correlation search length */
+){
+ int i;
+ float ftmp1, ftmp2;
+
+ ftmp1 = 0.0;
+ ftmp2 = 0.0;
+ for (i=0; i<sRange; i++) {
+ ftmp1 += buffer[bLen-sRange+i] *
+ buffer[bLen-sRange+i-lag];
+ ftmp2 += buffer[bLen-sRange+i-lag] *
+ buffer[bLen-sRange+i-lag];
+ }
+
+ if (ftmp2 > 0.0) {
+ *cc = ftmp1*ftmp1/ftmp2;
+ *gc = (float)fabs(ftmp1/ftmp2);
+ }
+ else {
+ *cc = 0.0;
+ *gc = 0.0;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * Packet loss concealment routine. Conceals a residual signal
+ * and LP parameters. If no packet loss, update state.
+ *---------------------------------------------------------------*/
+
+void doThePLC(
+ float *PLCresidual, /* (o) concealed residual */
+ float *PLClpc, /* (o) concealed LP parameters */
+ int PLI, /* (i) packet loss indicator
+ 0 - no PL, 1 = PL */
+ float *decresidual, /* (i) decoded residual */
+ float *lpc, /* (i) decoded LPC (only used for no PL) */
+ int inlag, /* (i) pitch lag */
+ iLBC_Dec_Inst_t *iLBCdec_inst
+ /* (i/o) decoder instance */
+){
+ int lag=20, randlag;
+ float gain, maxcc;
+ float gain_comp, maxcc_comp;
+ int i, pick, offset;
+ float ftmp, ftmp1, randvec[BLOCKL], pitchfact;
+
+ /* Packet Loss */
+
+ if (PLI == 1) {
+
+ (*iLBCdec_inst).consPLICount += 1;
+
+ /* if previous frame not lost,
+ determine pitch pred. gain */
+
+ if ((*iLBCdec_inst).prevPLI != 1) {
+
+ /* Search around the previous lag to find the
+ best pitch period */
+
+ lag=inlag-3;
+ compCorr(&maxcc, &gain, (*iLBCdec_inst).prevResidual,
+ lag, BLOCKL, 60);
+ for (i=inlag-2;i<=inlag+3;i++) {
+ compCorr(&maxcc_comp, &gain_comp,
+ (*iLBCdec_inst).prevResidual,
+ i, BLOCKL, 60);
+
+ if (maxcc_comp>maxcc) {
+ maxcc=maxcc_comp;
+ gain=gain_comp;
+ lag=i;
+ }
+ }
+
+ if (gain > 1.0) {
+ gain = 1.0;
+ }
+ }
+
+ /* previous frame lost, use recorded lag and gain */
+
+ else {
+ lag=(*iLBCdec_inst).prevLag;
+ gain=(*iLBCdec_inst).prevGain;
+ }
+
+ /* Attenuate signal and scale down pitch pred gain if
+ several frames lost consecutively */
+
+
+ if ((*iLBCdec_inst).consPLICount > 1) {
+ gain *= (float)0.9;
+ }
+
+ /* Compute mixing factor of picth repeatition and noise */
+
+
+ if (gain > PLC_XT_MIX) {
+ pitchfact = PLC_YT_MIX;
+ } else if (gain < PLC_XB_MIX) {
+ pitchfact = PLC_YB_MIX;
+ } else {
+ pitchfact = PLC_YB_MIX + (gain - PLC_XB_MIX) *
+ (PLC_YT_MIX-PLC_YB_MIX)/(PLC_XT_MIX-PLC_XB_MIX);
+ }
+
+ /* compute concealed residual */
+
+ (*iLBCdec_inst).energy = 0.0;
+ for (i=0; i<BLOCKL; i++) {
+
+ /* noise component */
+
+ (*iLBCdec_inst).seed=((*iLBCdec_inst).seed*69069L+1) &
+ (0x80000000L-1);
+ randlag = 50 + ((signed long) (*iLBCdec_inst).seed)%70;
+ pick = i - randlag;
+
+ if (pick < 0) {
+ randvec[i] = gain *
+ (*iLBCdec_inst).prevResidual[BLOCKL+pick];
+ } else {
+ randvec[i] = gain * randvec[pick];
+ }
+
+ /* pitch repeatition component */
+
+ pick = i - lag;
+
+ if (pick < 0) {
+ PLCresidual[i] = gain *
+ (*iLBCdec_inst).prevResidual[BLOCKL+pick];
+ } else {
+ PLCresidual[i] = gain * PLCresidual[pick];
+ }
+
+ /* mix noise and pitch repeatition */
+
+ PLCresidual[i] = (pitchfact * PLCresidual[i] +
+ ((float)1.0 - pitchfact) * randvec[i]);
+
+ (*iLBCdec_inst).energy += PLCresidual[i] *
+ PLCresidual[i];
+ }
+
+ /* less than 30 dB, use only noise */
+
+ if (sqrt((*iLBCdec_inst).energy/(float)BLOCKL) < 30.0) {
+ (*iLBCdec_inst).energy = 0.0;
+ gain=0.0;
+ for (i=0; i<BLOCKL; i++) {
+ PLCresidual[i] = randvec[i];
+ (*iLBCdec_inst).energy += PLCresidual[i] *
+ PLCresidual[i];
+ }
+ }
+
+ /* conceal LPC by bandwidth expansion of old LPC */
+
+ ftmp=PLC_BWEXPAND;
+ PLClpc[0]=(float)1.0;
+ for (i=1; i<LPC_FILTERORDER+1; i++) {
+ PLClpc[i] = ftmp * (*iLBCdec_inst).prevLpc[i];
+ ftmp *= PLC_BWEXPAND;
+ }
+
+ }
+
+ /* previous frame lost and this frame OK, mixing in
+ with new frame */
+
+ else if ((*iLBCdec_inst).prevPLI == 1) {
+
+ lag = (*iLBCdec_inst).prevLag;
+ gain = (*iLBCdec_inst).prevGain;
+
+ /* if pitch pred gain high, do overlap-add */
+
+ if (gain >= PLC_GAINTHRESHOLD) {
+
+ /* Compute mixing factor of pitch repeatition
+ and noise */
+
+ if (gain > PLC_XT_MIX) {
+ pitchfact = PLC_YT_MIX;
+ } else if (gain < PLC_XB_MIX) {
+ pitchfact = PLC_YB_MIX;
+ } else {
+ pitchfact = PLC_YB_MIX + (gain - PLC_XB_MIX) *
+ (PLC_YT_MIX-PLC_YB_MIX)/(PLC_XT_MIX-PLC_XB_MIX);
+ }
+
+ /* compute concealed residual for 3 subframes */
+
+ for (i=0; i<3*SUBL; i++) {
+
+ (*iLBCdec_inst).seed=((*iLBCdec_inst).seed*
+ 69069L+1) & (0x80000000L-1);
+ randlag = 50 + ((signed long)
+ (*iLBCdec_inst).seed)%70;
+
+ /* noise component */
+
+ pick = i - randlag;
+
+ if (pick < 0) {
+ randvec[i] = gain *
+ (*iLBCdec_inst).prevResidual[BLOCKL+pick];
+ } else {
+ randvec[i] = gain * randvec[pick];
+ }
+
+ /* pitch repeatition component */
+
+ pick = i - lag;
+
+ if (pick < 0) {
+ PLCresidual[i] = gain *
+ (*iLBCdec_inst).prevResidual[BLOCKL+pick];
+ } else {
+ PLCresidual[i] = gain * PLCresidual[pick];
+ }
+
+ /* mix noise and pitch repeatition */
+
+ PLCresidual[i] = (pitchfact * PLCresidual[i] +
+ ((float)1.0 - pitchfact) * randvec[i]);
+ }
+
+ /* interpolate concealed residual with actual
+ residual */
+
+ offset = 3*SUBL;
+ for (i=0; i<offset; i++) {
+ ftmp1 = (float) (i+1) / (float) (offset+1);
+ ftmp = (float)1.0 - ftmp1;
+ PLCresidual[i]=PLCresidual[i]*ftmp+
+ decresidual[i]*ftmp1;
+ }
+
+ memcpy(PLCresidual+offset, decresidual+offset,
+ (BLOCKL-offset)*sizeof(float));
+
+ } else {
+ memcpy(PLCresidual, decresidual, BLOCKL*sizeof(float));
+ }
+
+ /* copy LPC */
+
+ memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float));
+
+ (*iLBCdec_inst).consPLICount = 0;
+ }
+
+ /* no packet loss, copy input */
+
+ else {
+ memcpy(PLCresidual, decresidual, BLOCKL*sizeof(float));
+ memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float));
+ }
+
+ /* update state */
+
+ (*iLBCdec_inst).prevLag = lag;
+ (*iLBCdec_inst).prevGain = gain;
+ (*iLBCdec_inst).prevPLI = PLI;
+ memcpy((*iLBCdec_inst).prevLpc, PLClpc,
+ (LPC_FILTERORDER+1)*sizeof(float));
+ memcpy((*iLBCdec_inst).prevResidual, PLCresidual,
+ BLOCKL*sizeof(float));
+}
+
+
diff --git a/codecs/ilbc/doCPLC.h b/codecs/ilbc/doCPLC.h
new file mode 100755
index 0000000000000000000000000000000000000000..6f3612bd1fccfbfed50511085bbf7bf12443be13
--- /dev/null
+++ b/codecs/ilbc/doCPLC.h
@@ -0,0 +1,31 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ doCPLC.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_DOLPC_H
+#define __iLBC_DOLPC_H
+
+void doThePLC(
+ float *PLCresidual, /* (o) concealed residual */
+ float *PLClpc, /* (o) concealed LP parameters */
+ int PLI, /* (i) packet loss indicator
+ 0 - no PL, 1 = PL */
+ float *decresidual, /* (i) decoded residual */
+ float *lpc, /* (i) decoded LPC (only used for no PL) */
+ int inlag, /* (i) pitch lag */
+ iLBC_Dec_Inst_t *iLBCdec_inst
+ /* (i/o) decoder instance */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/enhancer.c b/codecs/ilbc/enhancer.c
new file mode 100755
index 0000000000000000000000000000000000000000..a2878cce0fdf7f0b8ad1585e609fa3d4d4cab1a0
--- /dev/null
+++ b/codecs/ilbc/enhancer.c
@@ -0,0 +1,600 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ enhancer.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+#include "iLBC_define.h"
+#include "constants.h"
+#include "filter.h"
+
+/*----------------------------------------------------------------*
+ * Find index in array such that the array element with said
+ * index is the element of said array closest to "value"
+ * according to the squared-error criterion
+ *---------------------------------------------------------------*/
+
+void NearestNeighbor(
+ int *index, /* (o) index of array element closest to value */
+ float *array, /* (i) data array */
+ float value,/* (i) value */
+ int arlength/* (i) dimension of data array */
+){
+ int i;
+ float bestcrit,crit;
+
+ crit=array[0]-value;
+ bestcrit=crit*crit;
+ *index=0;
+ for(i=1;i<arlength;i++){
+ crit=array[i]-value;
+ crit=crit*crit;
+
+ if(crit<bestcrit){
+ bestcrit=crit;
+ *index=i;
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * compute cross correlation between sequences
+ *---------------------------------------------------------------*/
+
+void mycorr1(
+ float* corr, /* (o) correlation of seq1 and seq2 */
+ float* seq1, /* (i) first sequence */
+ int dim1, /* (i) dimension first seq1 */
+ const float *seq2, /* (i) second sequence */
+ int dim2 /* (i) dimension seq2 */
+){
+ int i,j;
+
+ for(i=0;i<=dim1-dim2; i++){
+ corr[i]=0.0;
+ for(j=0;j<dim2; j++){
+ corr[i] += seq1[i+j] * seq2[j];
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * upsample finite array assuming zeros outside bounds
+ *---------------------------------------------------------------*/
+
+void enh_upsample(
+ float* useq1, /* (o) upsampled output sequence */
+ float* seq1,/* (i) unupsampled sequence */
+ int dim1, /* (i) dimension seq1 */
+ int hfl /* (i) polyphase filter length=2*hfl+1 */
+){
+ float *pu,*ps;
+ int i,j,k,q,filterlength,hfl2;
+ const float *polyp[ENH_UPS0]; /* pointers to polyphase columns */
+ const float *pp;
+
+ /* define pointers for filter */
+
+ filterlength=2*hfl+1;
+
+ if( filterlength > dim1){
+ hfl2=(int) (dim1/2);
+ for(j=0;j<ENH_UPS0; j++) {
+ polyp[j]=polyphaserTbl+j*filterlength+hfl-hfl2;
+ }
+ hfl=hfl2;
+ filterlength=2*hfl+1;
+ }
+ else {
+ for(j=0;j<ENH_UPS0; j++) {
+ polyp[j]=polyphaserTbl+j*filterlength;
+ }
+ }
+
+ /* filtering: filter overhangs left side of sequence */
+
+ pu=useq1;
+ for(i=hfl;i<filterlength; i++){
+ for(j=0;j<ENH_UPS0; j++){
+ *pu=0.0;
+ pp = polyp[j];
+ ps = seq1+i;
+ for(k=0;k<=i;k++) {
+ *pu += *ps-- * *pp++;
+ }
+ pu++;
+ }
+ }
+
+ /* filtering: simple convolution=inner products */
+
+ for(i=filterlength; i<dim1; i++){
+ for(j=0;j<ENH_UPS0; j++){
+ *pu=0.0;
+ pp = polyp[j];
+ ps = seq1+i;
+ for(k=0;k<filterlength;k++) {
+ *pu += *ps-- * *pp++;
+ }
+ pu++;
+ }
+ }
+
+ /* filtering: filter overhangs right side of sequence */
+
+ for(q=1; q<=hfl;q++){
+ for(j=0;j<ENH_UPS0; j++){
+ *pu=0.0;
+ pp = polyp[j]+q;
+ ps = seq1+dim1-1;
+ for(k=0;k<filterlength-q;k++) {
+ *pu += *ps-- * *pp++;
+ }
+ pu++;
+ }
+ }
+}
+
+
+/*----------------------------------------------------------------*
+ * find segment starting near idata+estSegPos that has highest
+ * correlation with idata+centerStartPos through
+ * idata+centerStartPos+ENH_BLOCKL-1 segment is found at a
+ * resolution of ENH_UPSO times the original of the original
+ * sampling rate
+ *---------------------------------------------------------------*/
+
+void refiner(
+ float *seg, /* (o) segment array */
+ float *updStartPos, /* (o) updated start point */
+ float* idata, /* (i) original data buffer */
+ int idatal, /* (i) dimension of idata */
+ int centerStartPos, /* (i) beginning center segment */
+ float estSegPos,/* (i) estimated beginning other segment */
+ float period /* (i) estimated pitch period */
+){
+ int estSegPosRounded,searchSegStartPos,searchSegEndPos,corrdim;
+ int tloc,tloc2,i,st,en,fraction;
+ float vect[ENH_VECTL],corrVec[ENH_CORRDIM],maxv;
+ float corrVecUps[ENH_CORRDIM*ENH_UPS0];
+ (void)period;
+
+ /* defining array bounds */
+
+ estSegPosRounded=(int)(estSegPos - 0.5);
+
+ searchSegStartPos=estSegPosRounded-ENH_SLOP;
+
+ if (searchSegStartPos<0) {
+ searchSegStartPos=0;
+ }
+ searchSegEndPos=estSegPosRounded+ENH_SLOP;
+
+ if(searchSegEndPos+ENH_BLOCKL >= idatal) {
+ searchSegEndPos=idatal-ENH_BLOCKL-1;
+ }
+ corrdim=searchSegEndPos-searchSegStartPos+1;
+
+ /* compute upsampled correlation (corr33) and find
+ location of max */
+
+ mycorr1(corrVec,idata+searchSegStartPos,
+ corrdim+ENH_BLOCKL-1,idata+centerStartPos,ENH_BLOCKL);
+ enh_upsample(corrVecUps,corrVec,corrdim,ENH_FL0);
+ tloc=0; maxv=corrVecUps[0];
+ for(i=1;i<ENH_UPS0*corrdim; i++){
+
+ if(corrVecUps[i]>maxv){
+ tloc=i;
+ maxv=corrVecUps[i];
+ }
+ }
+
+ /* make vector can be upsampled without ever running outside
+ bounds */
+
+ *updStartPos= (float)searchSegStartPos +
+ (float)tloc/(float)ENH_UPS0+(float)1.0;
+ tloc2=(int)(tloc/ENH_UPS0);
+
+ if (tloc>tloc2*ENH_UPS0) {
+ tloc2++;
+ }
+ st=searchSegStartPos+tloc2-ENH_FL0;
+
+ if(st<0){
+ memset(vect,0,-st*sizeof(float));
+ memcpy(&vect[-st],idata, (ENH_VECTL+st)*sizeof(float));
+ }
+ else{
+ en=st+ENH_VECTL;
+
+ if(en>idatal){
+ memcpy(vect, &idata[st],
+ (ENH_VECTL-(en-idatal))*sizeof(float));
+ memset(&vect[ENH_VECTL-(en-idatal)], 0,
+ (en-idatal)*sizeof(float));
+ }
+ else {
+ memcpy(vect, &idata[st], ENH_VECTL*sizeof(float));
+ }
+ }
+ fraction=tloc2*ENH_UPS0-tloc;
+
+ /* compute the segment (this is actually a convolution) */
+
+ mycorr1(seg,vect,ENH_VECTL,polyphaserTbl+(2*ENH_FL0+1)*fraction,
+ 2*ENH_FL0+1);
+}
+
+/*----------------------------------------------------------------*
+ * find the smoothed output data
+ *---------------------------------------------------------------*/
+
+void smath(
+ float *odata, /* (o) smoothed output */
+ float *sseq,/* (i) said second sequence of waveforms */
+ int hl, /* (i) 2*hl+1 is sseq dimension */
+ float alpha0/* (i) max smoothing energy fraction */
+){
+ int i,k;
+ float w00,w10,w11,A,B,C,*psseq,err,errs;
+ float surround[BLOCKL]; /* shape contributed by other than
+ current */
+ float wt[2*ENH_HL+1]; /* waveform weighting to get surround
+ shape */
+ float denom;
+
+ /* create shape of contribution from all waveforms except the
+ current one */
+
+ for(i=1;i<=2*hl+1; i++) {
+ wt[i-1] = (float)0.5*(1 - (float)cos(2*PI*i/(2*hl+2)));
+ }
+ wt[hl]=0.0; /* for clarity, not used */
+ for(i=0;i<ENH_BLOCKL; i++) {
+ surround[i]=sseq[i]*wt[0];
+ }
+ for(k=1;k<hl; k++){
+ psseq=sseq+k*ENH_BLOCKL;
+ for(i=0;i<ENH_BLOCKL; i++) {
+ surround[i]+=psseq[i]*wt[k];
+ }
+ }
+ for(k=hl+1;k<=2*hl; k++){
+ psseq=sseq+k*ENH_BLOCKL;
+ for(i=0;i<ENH_BLOCKL; i++) {
+ surround[i]+=psseq[i]*wt[k];
+ }
+ }
+
+ /* compute some inner products */
+
+ w00 = w10 = w11 = 0.0;
+ psseq=sseq+hl*ENH_BLOCKL; /* current block */
+ for(i=0;i<ENH_BLOCKL;i++) {
+ w00+=psseq[i]*psseq[i];
+ w11+=surround[i]*surround[i];
+ w10+=surround[i]*psseq[i];
+ }
+
+ if( fabs(w11) < 1.0) {
+ w11=1.0;
+ }
+ C = (float)sqrt( w00/w11);
+
+ /* first try enhancement without power-constraint */
+
+ errs=0.0;
+ psseq=sseq+hl*ENH_BLOCKL;
+ for(i=0;i<ENH_BLOCKL;i++) {
+ odata[i]=C*surround[i];
+ err=psseq[i]-odata[i];
+ errs+=err*err;
+ }
+
+ /* if constraint violated by first try, add constraint */
+
+ if( errs > alpha0 * w00){
+ if( w00 < 1) {
+ w00=1;
+ }
+ denom = (w11*w00-w10*w10)/(w00*w00);
+
+ if( denom > 0.0001){ /* eliminates numerical problems
+ for if smooth */
+ A = (float)sqrt( (alpha0- alpha0*alpha0/4)/denom);
+ B = -alpha0/2 - A * w10/w00;
+ B = B+1;
+ }
+ else{ /* essentially no difference between cycles;
+ smoothing not needed */
+ A= 0.0;
+ B= 1.0;
+ }
+
+ /* create smoothed sequence */
+
+ psseq=sseq+hl*ENH_BLOCKL;
+ for(i=0;i<ENH_BLOCKL;i++) {
+ odata[i]=A*surround[i]+B*psseq[i];
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * get the pitch-synchronous sample sequence
+ *---------------------------------------------------------------*/
+
+void getsseq(
+ float *sseq, /* (o) the pitch-synchronous sequence */
+ float *idata, /* (i) original data */
+ int idatal, /* (i) dimension of data */
+ int centerStartPos, /* (i) where current block starts */
+ float *period, /* (i) rough-pitch-period array */
+ float *plocs, /* (i) where periods of period array
+ are taken */
+ int periodl, /* (i) dimension period array */
+ int hl /* (i)( 2*hl+1 is the number of sequences */
+){
+ int i,centerEndPos,q;
+ float blockStartPos[2*ENH_HL+1];
+ int lagBlock[2*ENH_HL+1];
+ float plocs2[ENH_PLOCSL];
+ float *psseq;
+
+ centerEndPos=centerStartPos+ENH_BLOCKL-1;
+
+ /* present */
+
+ NearestNeighbor(lagBlock+hl,plocs,
+ (float)0.5*(centerStartPos+centerEndPos),periodl);
+
+ blockStartPos[hl]=(float)centerStartPos;
+ psseq=sseq+ENH_BLOCKL*hl;
+ memcpy(psseq, idata+centerStartPos, ENH_BLOCKL*sizeof(float));
+
+ /* past */
+
+ for(q=hl-1;q>=0;q--) {
+ blockStartPos[q]=blockStartPos[q+1]-period[lagBlock[q+1]];
+ NearestNeighbor(lagBlock+q,plocs,
+ blockStartPos[q]+ENH_BLOCKL_HALF-period[lagBlock[q+1]],
+ periodl);
+
+
+ if(blockStartPos[q]-ENH_OVERHANG>=0) {
+ refiner(sseq+q*ENH_BLOCKL,blockStartPos+q,idata,idatal,
+ centerStartPos,blockStartPos[q],
+ period[lagBlock[q+1]]);
+ } else {
+
+ psseq=sseq+q*ENH_BLOCKL;
+ memset(psseq, 0, ENH_BLOCKL*sizeof(float));
+ }
+ }
+
+ /* future */
+
+ for(i=0;i<periodl;i++) {
+ plocs2[i]=plocs[i]-period[i];
+ }
+ for(q=hl+1;q<=2*hl;q++) {
+ NearestNeighbor(lagBlock+q,plocs2,
+ blockStartPos[q-1]+ENH_BLOCKL_HALF,periodl);
+
+ blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]];
+ if( blockStartPos[q]+ENH_BLOCKL+ENH_OVERHANG<idatal) {
+
+ refiner(sseq+ENH_BLOCKL*q,blockStartPos+q,idata,idatal,
+ centerStartPos,blockStartPos[q],period[lagBlock[q]]);
+
+ }
+ else {
+ psseq=sseq+q*ENH_BLOCKL;
+ memset(psseq, 0, ENH_BLOCKL*sizeof(float));
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * perform enhancement on idata+centerStartPos through
+ * idata+centerStartPos+ENH_BLOCKL-1
+ *---------------------------------------------------------------*/
+
+void enhancer(
+ float *odata, /* (o) smoothed block, dimension blockl */
+ float *idata, /* (i) data buffer used for enhancing */
+ int idatal, /* (i) dimension idata */
+ int centerStartPos, /* (i) first sample current block
+ within idata */
+ float alpha0, /* (i) max correction-energy-fraction
+ (in [0,1]) */
+ float *period, /* (i) pitch period array */
+ float *plocs, /* (i) locations where period array
+ values valid */
+ int periodl /* (i) dimension of period and plocs */
+){
+ float sseq[(2*ENH_HL+1)*ENH_BLOCKL];
+
+ /* get said second sequence of segments */
+
+ getsseq(sseq,idata,idatal,centerStartPos,period,
+ plocs,periodl,ENH_HL);
+
+ /* compute the smoothed output from said second sequence */
+
+ smath(odata,sseq,ENH_HL,alpha0);
+
+}
+
+/*----------------------------------------------------------------*
+ * cross correlation
+ *---------------------------------------------------------------*/
+
+float xCorrCoef(
+ float *target, /* (i) first array */
+ float *regressor, /* (i) second array */
+ int subl /* (i) dimension arrays */
+){
+ int i;
+ float ftmp1, ftmp2;
+
+ ftmp1 = 0.0;
+ ftmp2 = 0.0;
+ for (i=0; i<subl; i++) {
+ ftmp1 += target[i]*regressor[i];
+ ftmp2 += regressor[i]*regressor[i];
+ }
+
+ if (ftmp1 > 0.0) {
+ return (float)(ftmp1*ftmp1/ftmp2);
+ }
+ else {
+ return (float)0.0;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * interface for enhancer
+ *---------------------------------------------------------------*/
+
+int enhancerInterface(
+ float *out, /* (o) enhanced signal */
+ float *in, /* (i) unenhanced signal */
+ iLBC_Dec_Inst_t *iLBCdec_inst /* (i) buffers etc */
+){
+ float *enh_buf, *enh_period;
+ int iblock, isample;
+ int lag, ilag, i;
+ float cc, maxcc;
+ float ftmp1, ftmp2, gain;
+ float *inPtr, *enh_bufPtr1, *enh_bufPtr2;
+
+ float lpState[6], downsampled[(ENH_NBLOCKS*ENH_BLOCKL+120)/2];
+ int inLen=ENH_NBLOCKS*ENH_BLOCKL+120;
+ int start;
+
+ enh_buf=iLBCdec_inst->enh_buf;
+ enh_period=iLBCdec_inst->enh_period;
+
+
+ memmove(enh_buf, &enh_buf[ENH_NBLOCKS*ENH_BLOCKL],
+ (ENH_NBLOCKS_EXTRA*ENH_BLOCKL)*sizeof(float));
+
+ memcpy(&enh_buf[ENH_NBLOCKS_EXTRA*ENH_BLOCKL], in,
+ (ENH_NBLOCKS*ENH_BLOCKL)*sizeof(float));
+
+ if (iLBCdec_inst->prev_enh_pl==1) {
+ /* PLC was performed on the previous packet */
+
+ lag = 20;
+ maxcc = xCorrCoef(in, in+lag, ENH_BLOCKL);
+ for (ilag=21; ilag<120; ilag++) {
+ cc = xCorrCoef(in, in+ilag, ENH_BLOCKL);
+
+ if (cc > maxcc) {
+ maxcc = cc;
+ lag = ilag;
+ }
+ }
+
+ ftmp1 = 0.0;
+ ftmp2 = 0.0;
+ for (i=0; i<ENH_BLOCKL; i++) {
+ ftmp1 += in[i]*in[i+lag];
+ ftmp2 += in[i+lag]*in[i+lag];
+ }
+
+ if (ftmp1 > 0.0) {
+ gain=(float)(ftmp1/ftmp2);
+ }
+ else {
+ gain=(float)0.0;
+ }
+ if (gain>1.0) {
+ gain=1.0;
+ } else if (gain<-1.0) {
+ gain=-1.0;
+ }
+
+ inPtr=&in[lag-1];
+
+ enh_bufPtr1=&enh_buf[ENH_NBLOCKS_EXTRA*ENH_BLOCKL-1];
+
+ if (lag>ENH_BLOCKL) {
+ start=ENH_BLOCKL;
+ } else {
+ start=lag;
+ }
+
+ for (isample = start; isample>0; isample--) {
+ *enh_bufPtr1-- = gain*(*inPtr--);
+ }
+
+ enh_bufPtr2=&enh_buf[ENH_NBLOCKS_EXTRA*ENH_BLOCKL-1];
+ for (isample = (ENH_BLOCKL-1-lag); isample>=0; isample--) {
+ *enh_bufPtr1-- = gain*(*enh_bufPtr2--);
+ }
+
+ }
+
+ memmove(enh_period, &enh_period[ENH_NBLOCKS],
+ ENH_NBLOCKS_EXTRA*sizeof(float));
+
+
+ /* Set state information to the 6 samples right before
+ the samples to be downsampled. */
+
+ memcpy(lpState, enh_buf+ENH_NBLOCKS_EXTRA*ENH_BLOCKL-126,
+ 6*sizeof(float));
+
+ /* Down sample a factor 2 to save computations */
+
+ DownSample(enh_buf+ENH_NBLOCKS_EXTRA*ENH_BLOCKL-120,
+ lpFilt_coefsTbl, inLen,
+ lpState, downsampled);
+
+ /* Estimate the pitch in the down sampled domain. */
+ for(iblock = 0; iblock<ENH_NBLOCKS; iblock++){
+
+ lag = 10;
+ maxcc = xCorrCoef(downsampled+60+iblock*
+ ENH_BLOCKL_HALF, downsampled+60+iblock*
+ ENH_BLOCKL_HALF-lag, ENH_BLOCKL_HALF);
+ for (ilag=11; ilag<60; ilag++) {
+ cc = xCorrCoef(downsampled+60+iblock*
+ ENH_BLOCKL_HALF, downsampled+60+iblock*
+ ENH_BLOCKL_HALF-ilag, ENH_BLOCKL_HALF);
+
+ if (cc > maxcc) {
+ maxcc = cc;
+ lag = ilag;
+ }
+ }
+
+ /* Store the estimated lag in the non-downsampled domain */
+ enh_period[iblock+ENH_NBLOCKS_EXTRA] = (float)lag*2;
+ }
+
+ for(iblock = 0; iblock<ENH_NBLOCKS; iblock++){
+
+ enhancer(out+iblock*ENH_BLOCKL, enh_buf,
+ ENH_BUFL, (4+iblock)*ENH_BLOCKL,
+ ENH_ALPHA0, enh_period, enh_plocsTbl,
+ ENH_NBLOCKS_TOT);
+
+ }
+ return (lag*2);
+}
+
+
diff --git a/codecs/ilbc/enhancer.h b/codecs/ilbc/enhancer.h
new file mode 100755
index 0000000000000000000000000000000000000000..7d1730c54dc471d45fa23484103a080758f5e654
--- /dev/null
+++ b/codecs/ilbc/enhancer.h
@@ -0,0 +1,34 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ enhancer.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __ENHANCER_H
+#define __ENHANCER_H
+
+#include "iLBC_define.h"
+
+float xCorrCoef(
+ float *target, /* (i) first array */
+ float *regressor, /* (i) second array */
+ int subl /* (i) dimension arrays */
+);
+
+int enhancerInterface(
+ float *out, /* (o) the enhanced recidual signal */
+ float *in, /* (i) the recidual signal to enhance */
+ iLBC_Dec_Inst_t *iLBCdec_inst
+ /* (i/o) the decoder state structure */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/filter.c b/codecs/ilbc/filter.c
new file mode 100755
index 0000000000000000000000000000000000000000..c74e9cfc5f679ed6802b5e8afae5e80e59568c23
--- /dev/null
+++ b/codecs/ilbc/filter.c
@@ -0,0 +1,161 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ filter.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ 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;
+ }
+}
+
+
diff --git a/codecs/ilbc/filter.h b/codecs/ilbc/filter.h
new file mode 100755
index 0000000000000000000000000000000000000000..1883560babb920561caef78baef93ce632017466
--- /dev/null
+++ b/codecs/ilbc/filter.h
@@ -0,0 +1,72 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ filter.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_FILTER_H
+#define __iLBC_FILTER_H
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/gainquant.c b/codecs/ilbc/gainquant.c
new file mode 100755
index 0000000000000000000000000000000000000000..be64f8a6733bc2bb88a563c0b3f5adc45e9c7164
--- /dev/null
+++ b/codecs/ilbc/gainquant.c
@@ -0,0 +1,103 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ gainquant.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <string.h>
+#include <math.h>
+#include "constants.h"
+#include "filter.h"
+
+/*----------------------------------------------------------------*
+ * quantizer for the gain in the gain-shape coding of residual
+ *---------------------------------------------------------------*/
+
+float gainquant(/* (o) quantized gain value */
+ float in, /* (i) gain value */
+ float maxIn,/* (i) maximum of gain value */
+ int cblen, /* (i) number of quantization indices */
+ int *index /* (o) quantization index */
+){
+ int i, tindex;
+ float minmeasure,measure, *cb, scale;
+
+ /* ensure a lower bound on the scaling factor */
+
+ scale=maxIn;
+
+ if (scale<0.1) {
+ scale=(float)0.1;
+ }
+
+ /* select the quantization table */
+
+ if (cblen == 8) {
+ cb = gain_sq3Tbl;
+ } else if (cblen == 16) {
+ cb = gain_sq4Tbl;
+ } else {
+ cb = gain_sq5Tbl;
+ }
+
+ /* select the best index in the quantization table */
+
+ minmeasure=10000000.0;
+ tindex=0;
+ for (i=0;i<cblen;i++) {
+ measure=(in-scale*cb[i])*(in-scale*cb[i]);
+
+ if (measure<minmeasure) {
+ tindex=i;
+ minmeasure=measure;
+ }
+ }
+ *index=tindex;
+
+ /* return the quantized value */
+
+ return scale*cb[tindex];
+}
+
+/*----------------------------------------------------------------*
+ * decoder for quantized gains in the gain-shape coding of
+ * residual
+ *---------------------------------------------------------------*/
+
+float gaindequant( /* (o) quantized gain value */
+ int index, /* (i) quantization index */
+ float maxIn,/* (i) maximum of unquantized gain */
+ int cblen /* (i) number of quantization indices */
+){
+ float scale;
+
+ /* obtain correct scale factor */
+
+ scale=(float)fabs(maxIn);
+
+ if (scale<0.1) {
+ scale=(float)0.1;
+ }
+
+ /* select the quantization table and return the decoded value */
+
+ if (cblen==8) {
+ return scale*gain_sq3Tbl[index];
+ } else if (cblen==16) {
+ return scale*gain_sq4Tbl[index];
+ }
+ else if (cblen==32) {
+ return scale*gain_sq5Tbl[index];
+ }
+
+ return 0.0;
+}
+
+
diff --git a/codecs/ilbc/gainquant.h b/codecs/ilbc/gainquant.h
new file mode 100755
index 0000000000000000000000000000000000000000..3768b93e1e7e979d395a2745eb564d7b53262e98
--- /dev/null
+++ b/codecs/ilbc/gainquant.h
@@ -0,0 +1,32 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ gainquant.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_GAINQUANT_H
+#define __iLBC_GAINQUANT_H
+
+float gainquant(/* (o) quantized gain value */
+ float in, /* (i) gain value */
+ float maxIn,/* (i) maximum of gain value */
+ int cblen, /* (i) number of quantization indices */
+ int *index /* (o) quantization index */
+);
+
+float gaindequant( /* (o) quantized gain value */
+ int index, /* (i) quantization index */
+ float maxIn,/* (i) maximum of unquantized gain */
+ int cblen /* (i) number of quantization indices */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/getCBvec.c b/codecs/ilbc/getCBvec.c
new file mode 100755
index 0000000000000000000000000000000000000000..07e9f2d3c8d55792305758e53e389cf65473e3fb
--- /dev/null
+++ b/codecs/ilbc/getCBvec.c
@@ -0,0 +1,171 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ getCBvec.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include <string.h>
+
+/*----------------------------------------------------------------*
+ * Construct codebook vector for given index.
+ *---------------------------------------------------------------*/
+
+void getCBvec(
+ float *cbvec, /* (o) Constructed codebook vector */
+ float *mem, /* (i) Codebook buffer */
+ int index, /* (i) Codebook index */
+ int lMem, /* (i) Length of codebook buffer */
+ int cbveclen/* (i) Codebook vector length */
+){
+ int j, k, n, memInd, sFilt;
+ float tmpbuf[CB_MEML];
+ int base_size;
+ int ilow, ihigh;
+ float alfa, alfa1;
+
+ /* Determine size of codebook sections */
+
+ base_size=lMem-cbveclen+1;
+
+ if (cbveclen==SUBL) {
+ base_size+=cbveclen/2;
+ }
+
+ /* No filter -> First codebook section */
+
+ if (index<lMem-cbveclen+1) {
+
+ /* first non-interpolated vectors */
+
+ k=index+cbveclen;
+ /* get vector */
+ memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
+
+ } else if (index < base_size) {
+
+ k=2*(index-(lMem-cbveclen+1))+cbveclen;
+
+ ihigh=k/2;
+ ilow=ihigh-5;
+
+ /* Copy first noninterpolated part */
+
+ memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
+
+ /* interpolation */
+
+ alfa1=(float)0.2;
+ alfa=0.0;
+ for (j=ilow; j<ihigh; j++) {
+ cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+
+ alfa*mem[lMem-k+j];
+ alfa+=alfa1;
+ }
+
+ /* Copy second noninterpolated part */
+
+ memcpy(cbvec+ihigh, mem+lMem-k+ihigh,
+ (cbveclen-ihigh)*sizeof(float));
+
+ }
+
+ /* Higher codebbok section based on filtering */
+
+ else {
+
+ /* first non-interpolated vectors */
+
+ if (index-base_size<lMem-cbveclen+1) {
+ float tempbuff2[CB_MEML+CB_FILTERLEN+1];
+ float *pos;
+ float *pp, *pp1;
+
+ memset(tempbuff2, 0, CB_HALFFILTERLEN*sizeof(float));
+ memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
+ lMem*sizeof(float));
+ memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
+ (CB_HALFFILTERLEN+1)*sizeof(float));
+
+ k=index-base_size+cbveclen;
+ sFilt=lMem-k;
+ memInd=sFilt+1-CB_HALFFILTERLEN;
+
+ /* do filtering */
+ pos=cbvec;
+ memset(pos, 0, cbveclen*sizeof(float));
+ for (n=0; n<cbveclen; n++) {
+ pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];
+ pp1=&cbfiltersTbl[0];
+ for (j=0;j<CB_FILTERLEN;j++) {
+ (*pos)+=(*pp++)*(*pp1++);
+ }
+ pos++;
+ }
+ }
+
+ /* interpolated vectors */
+
+ else {
+ float tempbuff2[CB_MEML+CB_FILTERLEN+1];
+
+ float *pos;
+ float *pp, *pp1;
+ int i;
+
+ memset(tempbuff2, 0, CB_HALFFILTERLEN*sizeof(float));
+ memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
+ lMem*sizeof(float));
+ memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
+ (CB_HALFFILTERLEN+1)*sizeof(float));
+
+ k=2*(index-base_size-(lMem-cbveclen+1))+cbveclen;
+ sFilt=lMem-k;
+ memInd=sFilt+1-CB_HALFFILTERLEN;
+
+ /* do filtering */
+ pos=&tmpbuf[sFilt];
+ memset(pos, 0, k*sizeof(float));
+ for (i=0; i<k; i++) {
+ pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];
+ pp1=&cbfiltersTbl[0];
+ for (j=0;j<CB_FILTERLEN;j++) {
+ (*pos)+=(*pp++)*(*pp1++);
+ }
+ pos++;
+ }
+
+ ihigh=k/2;
+ ilow=ihigh-5;
+
+ /* Copy first noninterpolated part */
+
+ memcpy(cbvec, tmpbuf+lMem-k/2, ilow*sizeof(float));
+
+ /* interpolation */
+
+ alfa1=(float)0.2;
+ alfa=0.0;
+ for (j=ilow; j<ihigh; j++) {
+ cbvec[j]=((float)1.0-alfa)*
+ tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];
+ alfa+=alfa1;
+ }
+
+ /* Copy second noninterpolated part */
+
+ memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,
+ (cbveclen-ihigh)*sizeof(float));
+ }
+ }
+}
+
+
diff --git a/codecs/ilbc/getCBvec.h b/codecs/ilbc/getCBvec.h
new file mode 100755
index 0000000000000000000000000000000000000000..ad4e8aa708e51aa2a0e1d49eb87008e2f014dac9
--- /dev/null
+++ b/codecs/ilbc/getCBvec.h
@@ -0,0 +1,27 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ getCBvec.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_GETCBVEC_H
+#define __iLBC_GETCBVEC_H
+
+void getCBvec(
+ float *cbvec, /* (o) Constructed codebook vector */
+ float *mem, /* (i) Codebook buffer */
+ int index, /* (i) Codebook index */
+ int lMem, /* (i) Length of codebook buffer */
+ int cbveclen/* (i) Codebook vector length */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/helpfun.c b/codecs/ilbc/helpfun.c
new file mode 100755
index 0000000000000000000000000000000000000000..8788e78948296a0053e72781a24058baa11684f6
--- /dev/null
+++ b/codecs/ilbc/helpfun.c
@@ -0,0 +1,293 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ helpfun.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ 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;
+}
+
+
diff --git a/codecs/ilbc/helpfun.h b/codecs/ilbc/helpfun.h
new file mode 100755
index 0000000000000000000000000000000000000000..be6e727b7b7449a55cdb1a787629b6b827a9e692
--- /dev/null
+++ b/codecs/ilbc/helpfun.h
@@ -0,0 +1,93 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ helpfun.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_HELPFUN_H
+#define __iLBC_HELPFUN_H
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+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 */
+);
+
+
+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 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 */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/hpInput.c b/codecs/ilbc/hpInput.c
new file mode 100755
index 0000000000000000000000000000000000000000..1599c292359f7b9152339ee9619f020f6b4cdcb9
--- /dev/null
+++ b/codecs/ilbc/hpInput.c
@@ -0,0 +1,58 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpInput.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * Input high-pass filter
+ *---------------------------------------------------------------*/
+
+void hpInput(
+ float *In, /* (i) vector to filter */
+ int len, /* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+){
+ int i;
+ float *pi, *po;
+
+ /* all-zero section*/
+
+ pi = &In[0];
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po = hpi_zero_coefsTbl[0] * (*pi);
+ *po += hpi_zero_coefsTbl[1] * mem[0];
+ *po += hpi_zero_coefsTbl[2] * mem[1];
+
+ mem[1] = mem[0];
+ mem[0] = *pi;
+ po++;
+ pi++;
+
+ }
+
+ /* all-pole section*/
+
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po -= hpi_pole_coefsTbl[1] * mem[2];
+ *po -= hpi_pole_coefsTbl[2] * mem[3];
+
+ mem[3] = mem[2];
+ mem[2] = *po;
+ po++;
+ }
+}
+
+
diff --git a/codecs/ilbc/hpInput.h b/codecs/ilbc/hpInput.h
new file mode 100755
index 0000000000000000000000000000000000000000..9be4fc2877a1dd078dfec1dad7cfdfe0983ede76
--- /dev/null
+++ b/codecs/ilbc/hpInput.h
@@ -0,0 +1,26 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpInput.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_HPINPUT_H
+#define __iLBC_HPINPUT_H
+
+void hpInput(
+ float *In, /* (i) vector to filter */
+ int len, /* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/hpOutput.c b/codecs/ilbc/hpOutput.c
new file mode 100755
index 0000000000000000000000000000000000000000..fa75f2578233ccdbce1754c6388ad939337fcdf7
--- /dev/null
+++ b/codecs/ilbc/hpOutput.c
@@ -0,0 +1,58 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpOutput.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * Output high-pass filter
+ *---------------------------------------------------------------*/
+
+void hpOutput(
+ float *In, /* (i) vector to filter */
+ int len,/* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+){
+ int i;
+ float *pi, *po;
+
+ /* all-zero section*/
+
+ pi = &In[0];
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po = hpo_zero_coefsTbl[0] * (*pi);
+ *po += hpo_zero_coefsTbl[1] * mem[0];
+ *po += hpo_zero_coefsTbl[2] * mem[1];
+
+ mem[1] = mem[0];
+ mem[0] = *pi;
+ po++;
+ pi++;
+
+ }
+
+ /* all-pole section*/
+
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po -= hpo_pole_coefsTbl[1] * mem[2];
+ *po -= hpo_pole_coefsTbl[2] * mem[3];
+
+ mem[3] = mem[2];
+ mem[2] = *po;
+ po++;
+ }
+}
+
+
diff --git a/codecs/ilbc/hpOutput.h b/codecs/ilbc/hpOutput.h
new file mode 100755
index 0000000000000000000000000000000000000000..b19f5d1ec774968f8a19f28bb4512b02e4ba4394
--- /dev/null
+++ b/codecs/ilbc/hpOutput.h
@@ -0,0 +1,26 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpOutput.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_HPOUTPUT_H
+#define __iLBC_HPOUTPUT_H
+
+void hpOutput(
+ float *In, /* (i) vector to filter */
+ int len,/* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/iCBConstruct.c b/codecs/ilbc/iCBConstruct.c
new file mode 100755
index 0000000000000000000000000000000000000000..ccb3f663b5853e1370eb911782b9fa840011e153
--- /dev/null
+++ b/codecs/ilbc/iCBConstruct.c
@@ -0,0 +1,104 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBConstruct.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+
+#include "iLBC_define.h"
+#include "gainquant.h"
+#include "getCBvec.h"
+
+/*----------------------------------------------------------------*
+ * Convert the codebook indexes to make the search easier
+ *---------------------------------------------------------------*/
+
+void index_conv_enc(
+ int *index /* (i/o) Codebook indexes */
+){
+ int k;
+
+ for (k=1;k<CB_NSTAGES;k++) {
+
+ if ((index[k]>=108)&&(index[k]<172)) {
+ index[k]-=64;
+ } else if (index[k]>=236) {
+ index[k]-=128;
+ } else {
+ /* ERROR */
+ }
+ }
+}
+
+void index_conv_dec(
+ int *index /* (i/o) Codebook indexes */
+){
+ int k;
+
+ for (k=1;k<CB_NSTAGES;k++) {
+
+ if ((index[k]>=44)&&(index[k]<108)) {
+ index[k]+=64;
+ } else if ((index[k]>=108)&&(index[k]<128)) {
+ index[k]+=128;
+ } else {
+ /* ERROR */
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * Construct decoded vector from codebook and gains.
+ *---------------------------------------------------------------*/
+
+void iCBConstruct(
+ float *decvector, /* (o) Decoded vector */
+ int *index, /* (i) Codebook indices */
+ int *gain_index,/* (i) Gain quantization indices */
+ float *mem, /* (i) Buffer for codevector construction */
+ int lMem, /* (i) Length of buffer */
+ int veclen, /* (i) Length of vector */
+ int nStages /* (i) Number of codebook stages */
+){
+ int j,k;
+ float gain[CB_NSTAGES];
+ float cbvec[SUBL];
+
+ /* gain de-quantization */
+
+ gain[0] = gaindequant(gain_index[0], 1.0, 32);
+ if (nStages > 1) {
+ gain[1] = gaindequant(gain_index[1],
+ (float)fabs(gain[0]), 16);
+ }
+ if (nStages > 2) {
+ gain[2] = gaindequant(gain_index[2],
+ (float)fabs(gain[1]), 8);
+ }
+
+ /* codebook vector construction and construction of
+ total vector */
+
+ getCBvec(cbvec, mem, index[0], lMem, veclen);
+ for (j=0;j<veclen;j++){
+ decvector[j] = gain[0]*cbvec[j];
+ }
+ if (nStages > 1) {
+ for (k=1; k<nStages; k++) {
+ getCBvec(cbvec, mem, index[k], lMem, veclen);
+ for (j=0;j<veclen;j++) {
+ decvector[j] += gain[k]*cbvec[j];
+ }
+ }
+ }
+}
+
+
diff --git a/codecs/ilbc/iCBConstruct.h b/codecs/ilbc/iCBConstruct.h
new file mode 100755
index 0000000000000000000000000000000000000000..3c9128ebf080d8ab9f76dbbd532ae46d1b237ffc
--- /dev/null
+++ b/codecs/ilbc/iCBConstruct.h
@@ -0,0 +1,37 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBConstruct.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ICBCONSTRUCT_H
+#define __iLBC_ICBCONSTRUCT_H
+
+void index_conv_enc(
+ int *index /* (i/o) Codebook indexes */
+);
+
+void index_conv_dec(
+ int *index /* (i/o) Codebook indexes */
+);
+
+void iCBConstruct(
+ float *decvector, /* (o) Decoded vector */
+ int *index, /* (i) Codebook indices */
+ int *gain_index,/* (i) Gain quantization indices */
+ float *mem, /* (i) Buffer for codevector construction */
+ int lMem, /* (i) Length of buffer */
+ int veclen, /* (i) Length of vector */
+ int nStages /* (i) Number of codebook stages */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/iCBSearch.c b/codecs/ilbc/iCBSearch.c
new file mode 100755
index 0000000000000000000000000000000000000000..a6f3030fa45f7d149b0eef4f5abfb8fb179b24b1
--- /dev/null
+++ b/codecs/ilbc/iCBSearch.c
@@ -0,0 +1,461 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBSearch.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "gainquant.h"
+#include "createCB.h"
+#include "filter.h"
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * Search routine for codebook encoding and gain quantization.
+ *---------------------------------------------------------------*/
+
+void iCBSearch(
+ 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 subblock 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++);
+ }
+
+ 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 lags 40+ in the 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 lags 20-39 in the first codebook section,
+ * full search.
+ * The vectors are interpolated.
+ */
+
+ if(lTarget==SUBL) {
+
+ /* Search for best possible lag 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 */
+
+ 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++);
+ }
+
+ 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-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, lag_val;
+
+ filterno=index[stage]/base_size;
+ lag_val=index[stage]-filterno*base_size;
+
+
+ if (lag_val<(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;
+}
+
+
diff --git a/codecs/ilbc/iCBSearch.h b/codecs/ilbc/iCBSearch.h
new file mode 100755
index 0000000000000000000000000000000000000000..fcdd997da5805cadd46b408813d5de971be3c2a8
--- /dev/null
+++ b/codecs/ilbc/iCBSearch.h
@@ -0,0 +1,32 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBSearch.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ICBSEARCH_H
+#define __iLBC_ICBSEARCH_H
+
+void iCBSearch(
+ 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 subblock number */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/iLBC_decode.c b/codecs/ilbc/iLBC_decode.c
new file mode 100755
index 0000000000000000000000000000000000000000..2347ab83ae552a0f3ca47f65ad84144f0f0b36b1
--- /dev/null
+++ b/codecs/ilbc/iLBC_decode.c
@@ -0,0 +1,519 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_decode.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "iLBC_define.h"
+#include "StateConstructW.h"
+#include "LPCdecode.h"
+#include "iCBConstruct.h"
+#include "doCPLC.h"
+#include "helpfun.h"
+#include "constants.h"
+#include "packing.h"
+#include "string.h"
+#include "enhancer.h"
+#include "hpOutput.h"
+#include "syntFilter.h"
+
+/*----------------------------------------------------------------*
+ * Initiation of decoder instance.
+ *---------------------------------------------------------------*/
+
+short initDecode( /* (o) Number of decoded
+ samples */
+ iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) Decoder instance */
+ int use_enhancer /* (i) 1 to use enhancer
+ 0 to run without
+ enhancer */
+){
+ int i;
+
+ memset((*iLBCdec_inst).syntMem, 0,
+ LPC_FILTERORDER*sizeof(float));
+ memcpy((*iLBCdec_inst).lsfdeqold, lsfmeanTbl,
+ LPC_FILTERORDER*sizeof(float));
+
+ memset((*iLBCdec_inst).old_syntdenum, 0,
+ ((LPC_FILTERORDER + 1)*NSUB)*sizeof(float));
+ for (i=0; i<NSUB; i++)
+ (*iLBCdec_inst).old_syntdenum[i*(LPC_FILTERORDER+1)]=1.0;
+
+ (*iLBCdec_inst).last_lag = 20;
+
+ (*iLBCdec_inst).prevLag = 120;
+ (*iLBCdec_inst).prevGain = 0.0;
+ (*iLBCdec_inst).consPLICount = 0;
+ (*iLBCdec_inst).prevPLI = 0;
+ (*iLBCdec_inst).prevLpc[0] = 1.0;
+ memset((*iLBCdec_inst).prevLpc+1,0,
+ LPC_FILTERORDER*sizeof(float));
+ memset((*iLBCdec_inst).prevResidual, 0, BLOCKL*sizeof(float));
+ (*iLBCdec_inst).seed=777;
+
+ memset((*iLBCdec_inst).hpomem, 0, 4*sizeof(float));
+
+ (*iLBCdec_inst).use_enhancer = use_enhancer;
+ memset((*iLBCdec_inst).enh_buf, 0, ENH_BUFL*sizeof(float));
+ for (i=0;i<ENH_NBLOCKS_TOT;i++)
+ (*iLBCdec_inst).enh_period[i]=(float)40.0;
+
+ iLBCdec_inst->prev_enh_pl = 0;
+
+ return (BLOCKL);
+}
+
+/*----------------------------------------------------------------*
+ * frame residual decoder function (subrutine to iLBC_decode)
+ *---------------------------------------------------------------*/
+
+void Decode(
+ float *decresidual, /* (o) decoded residual frame */
+ int start, /* (i) location of start state */
+ int idxForMax, /* (i) codebook index for the maximum
+ value */
+ int *idxVec, /* (i) codebook indexes for the samples
+ in the start state */
+ float *syntdenum, /* (i) the decoded synthesis filter
+ coefficients */
+ int *cb_index, /* (i) the indexes for the adaptive
+ codebook */
+ int *gain_index, /* (i) the indexes for the corresponding
+ gains */
+ int *extra_cb_index,/* (i) the indexes for the adaptive
+ codebook part of start state */
+ int *extra_gain_index, /* (i) the indexes for the corresponding
+ gains */
+ int state_first /* (i) 1 if non adaptive part of start
+ state comes first 0 if that part
+ comes last */
+){
+ float reverseDecresidual[BLOCKL], mem[CB_MEML];
+ int k, meml_gotten, Nfor, Nback, i;
+ int diff, start_pos;
+ int subcount, subframe;
+
+ diff = STATE_LEN - STATE_SHORT_LEN;
+
+ if (state_first == 1) {
+ start_pos = (start-1)*SUBL;
+ } else {
+ start_pos = (start-1)*SUBL + diff;
+ }
+
+ /* decode scalar part of start state */
+
+ StateConstructW(idxForMax, idxVec,
+ &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
+ &decresidual[start_pos], STATE_SHORT_LEN);
+
+
+ if (state_first) { /* put adaptive part in the end */
+
+ /* setup memory */
+
+ memset(mem, 0, (CB_MEML-STATE_SHORT_LEN)*sizeof(float));
+ memcpy(mem+CB_MEML-STATE_SHORT_LEN, decresidual+start_pos,
+ STATE_SHORT_LEN*sizeof(float));
+
+ /* construct decoded vector */
+
+ iCBConstruct(&decresidual[start_pos+STATE_SHORT_LEN],
+ extra_cb_index, extra_gain_index, mem+CB_MEML-stMemLTbl,
+ stMemLTbl, diff, CB_NSTAGES);
+
+ }
+ else {/* put adaptive part in the beginning */
+
+ /* create reversed vectors for prediction */
+
+ for(k=0; k<diff; k++ ){
+ reverseDecresidual[k] =
+ decresidual[(start+1)*SUBL -1-(k+STATE_SHORT_LEN)];
+ }
+
+ /* setup memory */
+
+ meml_gotten = STATE_SHORT_LEN;
+ for( k=0; k<meml_gotten; k++){
+ mem[CB_MEML-1-k] = decresidual[start_pos + k];
+ }
+ memset(mem, 0, (CB_MEML-k)*sizeof(float));
+
+ /* construct decoded vector */
+
+ iCBConstruct(reverseDecresidual, extra_cb_index,
+ extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl,
+ diff, CB_NSTAGES);
+
+ /* get decoded residual from reversed vector */
+
+ for( k=0; k<diff; k++ ){
+ decresidual[start_pos-1-k] = reverseDecresidual[k];
+ }
+ }
+
+ /* counter for predicted subframes */
+
+ subcount=0;
+
+ /* forward prediction of subframes */
+
+ Nfor = NSUB-start-1;
+
+ if( Nfor > 0 ){
+
+ /* setup memory */
+
+ memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
+ memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
+ STATE_LEN*sizeof(float));
+
+ /* loop over subframes to encode */
+
+ for (subframe=0; subframe<Nfor; subframe++) {
+
+ /* construct decoded vector */
+
+ iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
+ cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ mem+CB_MEML-memLfTbl[subcount],
+ memLfTbl[subcount], SUBL, CB_NSTAGES);
+
+ /* update memory */
+
+ memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
+ memcpy(mem+CB_MEML-SUBL,
+ &decresidual[(start+1+subframe)*SUBL],
+ SUBL*sizeof(float));
+
+ subcount++;
+
+ }
+
+ }
+
+ /* backward prediction of subframes */
+
+ Nback = start-1;
+
+ if( Nback > 0 ){
+
+ /* setup memory */
+
+ meml_gotten = SUBL*(NSUB+1-start);
+
+
+ if( meml_gotten > CB_MEML ) {
+ meml_gotten=CB_MEML;
+ }
+ for( k=0; k<meml_gotten; k++) {
+ mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
+ }
+ memset(mem, 0, (CB_MEML-k)*sizeof(float));
+
+ /* loop over subframes to decode */
+
+ for (subframe=0; subframe<Nback; subframe++) {
+
+ /* construct decoded vector */
+
+ iCBConstruct(&reverseDecresidual[subframe*SUBL],
+ cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
+ SUBL, CB_NSTAGES);
+
+ /* update memory */
+
+ memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
+ memcpy(mem+CB_MEML-SUBL,
+ &reverseDecresidual[subframe*SUBL],
+ SUBL*sizeof(float));
+
+ subcount++;
+ }
+
+ /* get decoded residual from reversed vector */
+
+ for (i = 0; i < SUBL*Nback; i++)
+ decresidual[SUBL*Nback - i - 1] =
+ reverseDecresidual[i];
+ }
+}
+
+/*----------------------------------------------------------------*
+ * main decoder function
+ *---------------------------------------------------------------*/
+
+void iLBC_decode(
+ float *decblock, /* (o) decoded signal block */
+ unsigned char *bytes, /* (i) encoded signal bits */
+ iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state
+ structure */
+ int mode /* (i) 0: bad packet, PLC,
+ 1: normal */
+){
+ float data[BLOCKL];
+ float lsfdeq[LPC_FILTERORDER*LPC_N];
+ float PLCresidual[BLOCKL], PLClpc[LPC_FILTERORDER + 1];
+ float zeros[BLOCKL], one[LPC_FILTERORDER + 1];
+ int k, i, start, idxForMax, pos, lastpart, ulp;
+ int lag, ilag;
+ float cc, maxcc;
+ int idxVec[STATE_LEN];
+ int check;
+ int gain_index[NASUB*CB_NSTAGES], extra_gain_index[CB_NSTAGES];
+ int cb_index[CB_NSTAGES*NASUB], extra_cb_index[CB_NSTAGES];
+ int lsf_i[LSF_NSPLIT*LPC_N];
+ int state_first;
+ unsigned char *pbytes;
+ float weightdenum[(LPC_FILTERORDER + 1)*NSUB];
+ int order_plus_one;
+ float syntdenum[NSUB*(LPC_FILTERORDER+1)];
+ float decresidual[BLOCKL];
+
+ if (mode>0) { /* the data are good */
+
+ /* decode data */
+
+ pbytes=bytes;
+ pos=0;
+
+ /* Set everything to zero before decoding */
+
+ for (k=0;k<6;k++) {
+ lsf_i[k]=0;
+ }
+ start=0;
+ state_first=0;
+ idxForMax=0;
+ for (k=0; k<STATE_SHORT_LEN; k++) {
+ idxVec[k]=0;
+ }
+ for (k=0;k<CB_NSTAGES;k++) {
+ extra_cb_index[k]=0;
+ }
+ for (k=0;k<CB_NSTAGES;k++) {
+ extra_gain_index[k]=0;
+ }
+ for (i=0; i<NASUB; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ cb_index[i*CB_NSTAGES+k]=0;
+ }
+ }
+ for (i=0; i<NASUB; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ gain_index[i*CB_NSTAGES+k]=0;
+ }
+ }
+
+ /* loop over ULP classes */
+
+ for (ulp=0; ulp<3; ulp++) {
+
+ /* LSF */
+ for (k=0;k<6;k++) {
+ unpack( &pbytes, &lastpart,
+ ulp_lsf_bitsTbl[k][ulp], &pos);
+ packcombine(&lsf_i[k], lastpart,
+ ulp_lsf_bitsTbl[k][ulp]);
+ }
+
+ /* Start block info */
+
+ unpack( &pbytes, &lastpart,
+ ulp_start_bitsTbl[ulp], &pos);
+ packcombine(&start, lastpart,
+ ulp_start_bitsTbl[ulp]);
+
+ unpack( &pbytes, &lastpart,
+ ulp_startfirst_bitsTbl[ulp], &pos);
+ packcombine(&state_first, lastpart,
+ ulp_startfirst_bitsTbl[ulp]);
+
+ unpack( &pbytes, &lastpart,
+ ulp_scale_bitsTbl[ulp], &pos);
+ packcombine(&idxForMax, lastpart,
+ ulp_scale_bitsTbl[ulp]);
+
+ for (k=0; k<STATE_SHORT_LEN; k++) {
+ unpack( &pbytes, &lastpart,
+ ulp_state_bitsTbl[ulp], &pos);
+ packcombine(idxVec+k, lastpart,
+ ulp_state_bitsTbl[ulp]);
+ }
+
+ /* 22 sample block */
+
+ for (k=0;k<CB_NSTAGES;k++) {
+ unpack( &pbytes, &lastpart,
+ ulp_extra_cb_indexTbl[k][ulp], &pos);
+ packcombine(extra_cb_index+k, lastpart,
+ ulp_extra_cb_indexTbl[k][ulp]);
+ }
+ for (k=0;k<CB_NSTAGES;k++) {
+ unpack( &pbytes, &lastpart,
+ ulp_extra_cb_gainTbl[k][ulp], &pos);
+ packcombine(extra_gain_index+k, lastpart,
+ ulp_extra_cb_gainTbl[k][ulp]);
+ }
+
+ /* The four 40 sample sub blocks */
+
+ for (i=0; i<NASUB; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ unpack( &pbytes, &lastpart,
+ ulp_cb_indexTbl[i][k][ulp], &pos);
+ packcombine(cb_index+i*CB_NSTAGES+k, lastpart,
+ ulp_cb_indexTbl[i][k][ulp]);
+ }
+ }
+
+ for (i=0; i<NASUB; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ unpack( &pbytes, &lastpart,
+ ulp_cb_gainTbl[i][k][ulp], &pos);
+ packcombine(gain_index+i*CB_NSTAGES+k, lastpart,
+ ulp_cb_gainTbl[i][k][ulp]);
+ }
+ }
+ }
+
+ /* Check for bit errors */
+ if( (start<1) || (start>5) )
+ mode = 0;
+
+ if (mode==1) { /* No bit errors was detected,
+ continue decoding */
+
+ /* adjust index */
+ index_conv_dec(cb_index);
+
+ /* decode the lsf */
+
+ SimplelsfDEQ(lsfdeq, lsf_i);
+ check=LSF_check(lsfdeq, LPC_FILTERORDER, LPC_N);
+ DecoderInterpolateLSF(syntdenum, weightdenum,
+ lsfdeq, LPC_FILTERORDER, iLBCdec_inst);
+
+ Decode(decresidual, start, idxForMax, idxVec,
+ syntdenum, cb_index, gain_index,
+ extra_cb_index, extra_gain_index,
+ state_first);
+
+ /* preparing the plc for a future loss! */
+
+ doThePLC(PLCresidual, PLClpc, 0, decresidual,
+ syntdenum + (LPC_FILTERORDER + 1)*(NSUB - 1),
+ (*iLBCdec_inst).last_lag, iLBCdec_inst);
+
+
+ memcpy(decresidual, PLCresidual, BLOCKL*sizeof(float));
+ }
+
+ }
+
+ if (mode == 0) {
+ /* the data is bad (either a PLC call
+ * was made or a bit error was detected)
+ */
+
+ /* packet loss conceal */
+
+ memset(zeros, 0, BLOCKL*sizeof(float));
+
+ one[0] = 1;
+ memset(one+1, 0, LPC_FILTERORDER*sizeof(float));
+
+ start=0;
+
+ doThePLC(PLCresidual, PLClpc, 1, zeros, one,
+ (*iLBCdec_inst).last_lag, iLBCdec_inst);
+ memcpy(decresidual, PLCresidual, BLOCKL*sizeof(float));
+
+ order_plus_one = LPC_FILTERORDER + 1;
+ for (i = 0; i < NSUB; i++) {
+ memcpy(syntdenum+(i*order_plus_one), PLClpc,
+ order_plus_one*sizeof(float));
+ }
+ }
+
+ if ((*iLBCdec_inst).use_enhancer == 1) {
+
+ /* post filtering */
+
+ (*iLBCdec_inst).last_lag =
+ enhancerInterface(data, decresidual, iLBCdec_inst);
+
+ /* synthesis filtering */
+
+ for (i=0; i < 2; i++) {
+ syntFilter(data + i*SUBL,
+ (*iLBCdec_inst).old_syntdenum +
+ (i+4)*(LPC_FILTERORDER+1), SUBL,
+ (*iLBCdec_inst).syntMem);
+ }
+ for (i=2; i < NSUB; i++) {
+ syntFilter(data + i*SUBL,
+ syntdenum + (i-2)*(LPC_FILTERORDER+1), SUBL,
+ (*iLBCdec_inst).syntMem);
+ }
+
+ } else {
+
+ /* Find last lag */
+ lag = 20;
+ maxcc = xCorrCoef(&decresidual[BLOCKL-ENH_BLOCKL],
+ &decresidual[BLOCKL-ENH_BLOCKL-lag], ENH_BLOCKL);
+
+ for (ilag=21; ilag<120; ilag++) {
+ cc = xCorrCoef(&decresidual[BLOCKL-ENH_BLOCKL],
+ &decresidual[BLOCKL-ENH_BLOCKL-ilag], ENH_BLOCKL);
+
+ if (cc > maxcc) {
+ maxcc = cc;
+ lag = ilag;
+ }
+ }
+ (*iLBCdec_inst).last_lag = lag;
+
+ /* copy data and run synthesis filter */
+
+ memcpy(data, decresidual, BLOCKL*sizeof(float));
+ for (i=0; i < NSUB; i++) {
+ syntFilter(data + i*SUBL,
+ syntdenum + i*(LPC_FILTERORDER+1), SUBL,
+ (*iLBCdec_inst).syntMem);
+ }
+ }
+
+ /* high pass filtering on output if desired, otherwise
+ copy to out */
+
+ /*hpOutput(data, BLOCKL, decblock, (*iLBCdec_inst).hpomem);*/
+ memcpy(decblock,data,BLOCKL*sizeof(float));
+
+ memcpy((*iLBCdec_inst).old_syntdenum, syntdenum,
+ NSUB*(LPC_FILTERORDER+1)*sizeof(float));
+
+ iLBCdec_inst->prev_enh_pl=0;
+
+ if (mode==0) { /* PLC was used */
+ iLBCdec_inst->prev_enh_pl=1;
+ }
+}
+
+
diff --git a/codecs/ilbc/iLBC_decode.h b/codecs/ilbc/iLBC_decode.h
new file mode 100755
index 0000000000000000000000000000000000000000..70e992619235e46b6bccc9e9ba68872c9e7d218f
--- /dev/null
+++ b/codecs/ilbc/iLBC_decode.h
@@ -0,0 +1,38 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_decode.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ILBCDECODE_H
+#define __iLBC_ILBCDECODE_H
+
+#include "iLBC_define.h"
+
+short initDecode( /* (o) Number of decoded
+ samples */
+ iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) Decoder instance */
+ int use_enhancer /* (i) 1 to use enhancer
+ 0 to run without
+ enhancer */
+);
+
+void iLBC_decode(
+ float *decblock, /* (o) decoded signal block */
+ unsigned char *bytes, /* (i) encoded signal bits */
+ iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state
+ structure */
+ int mode /* (i) 0: bad packet, PLC,
+ 1: normal */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/iLBC_define.h b/codecs/ilbc/iLBC_define.h
new file mode 100755
index 0000000000000000000000000000000000000000..e1c821b3d9bc646a297cc4f871529617b012ccd8
--- /dev/null
+++ b/codecs/ilbc/iLBC_define.h
@@ -0,0 +1,157 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_define.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+#include <string.h>
+
+#ifndef __iLBC_ILBCDEFINE_H
+#define __iLBC_ILBCDEFINE_H
+
+/* general codec settings */
+
+#define FS (float)8000.0
+#define BLOCKL 240
+#define NSUB 6
+#define NASUB 4
+#define SUBL 40
+#define STATE_LEN 80
+#define STATE_SHORT_LEN 58
+
+/* LPC settings */
+
+#define LPC_FILTERORDER 10
+#define LPC_CHIRP_SYNTDENUM (float)0.9025
+#define LPC_CHIRP_WEIGHTDENUM (float)0.4222
+#define LPC_LOOKBACK 60
+#define LPC_N 2
+#define LPC_ASYMDIFF 20
+#define LPC_BW (float)60.0
+#define LPC_WN (float)1.0001
+#define LSF_NSPLIT 3
+#define LSF_NUMBER_OF_STEPS 4
+#define LPC_HALFORDER LPC_FILTERORDER/2
+
+/* cb settings */
+
+#define CB_NSTAGES 3
+#define CB_EXPAND 2
+#define CB_MEML 147
+#define CB_FILTERLEN 2*4
+#define CB_HALFFILTERLEN 4
+#define CB_RESRANGE 34
+#define CB_MAXGAIN (float) 1.3
+
+/* enhancer */
+
+#define ENH_BLOCKL 80 /* block length */
+#define ENH_BLOCKL_HALF (ENH_BLOCKL/2)
+#define ENH_HL 3 /* 2*ENH_HL+1 is number blocks
+ in said second sequence */
+#define ENH_SLOP 2 /* max difference estimated and
+ correct pitch period */
+#define ENH_PLOCSL 20 /* pitch-estimates and
+ pitch-locations buffer length */
+#define ENH_OVERHANG 2
+#define ENH_UPS0 4 /* upsampling rate */
+#define ENH_FL0 3 /* 2*FLO+1 is the length of each filter */
+#define ENH_VECTL (ENH_BLOCKL+2*ENH_FL0)
+#define ENH_CORRDIM (2*ENH_SLOP+1)
+#define ENH_NBLOCKS (BLOCKL/ENH_BLOCKL)
+#define ENH_NBLOCKS_EXTRA 5
+#define ENH_NBLOCKS_TOT 8 /* ENH_NBLOCKS+ENH_NBLOCKS_EXTRA */
+#define ENH_BUFL (ENH_NBLOCKS_TOT)*ENH_BLOCKL
+#define ENH_ALPHA0 (float)0.05
+
+/* PLC */
+
+#define PLC_BFIATTENUATE (float)0.9
+#define PLC_GAINTHRESHOLD (float)0.5
+#define PLC_BWEXPAND (float)0.99
+#define PLC_XT_MIX (float)1.0
+#define PLC_XB_MIX (float)0.0
+#define PLC_YT_MIX (float)0.95
+#define PLC_YB_MIX (float)0.0
+
+/* Down sampling */
+
+#define FILTERORDER_DS 7
+#define DELAY_DS 3
+#define FACTOR_DS 2
+
+/* bit stream defs */
+
+#define NO_OF_BYTES 50
+#define STATE_BITS 3
+#define BYTE_LEN 8
+#define ULP_CLASSES 3
+
+/* help parameters */
+
+#define FLOAT_MAX (float)1.0e37
+#define EPS (float)2.220446049250313e-016
+#define PI (float)3.14159265358979323846
+#define MIN_SAMPLE -32768
+#define MAX_SAMPLE 32767
+#define TWO_PI (float)6.283185307
+#define PI2 (float)0.159154943
+
+/* type definition encoder instance */
+typedef struct iLBC_Enc_Inst_t_ {
+
+ /* analysis filter state */
+ float anaMem[LPC_FILTERORDER];
+
+ /* old lsf parameters for interpolation */
+ float lsfold[LPC_FILTERORDER];
+ float lsfdeqold[LPC_FILTERORDER];
+
+ /* signal buffer for LP analysis */
+ float lpc_buffer[LPC_LOOKBACK + BLOCKL];
+
+ /* state of input HP filter */
+ float hpimem[4];
+
+} iLBC_Enc_Inst_t;
+
+/* type definition decoder instance */
+typedef struct iLBC_Dec_Inst_t_ {
+ /* synthesis filter state */
+ float syntMem[LPC_FILTERORDER];
+
+ /* old LSF for interpolation */
+ float lsfdeqold[LPC_FILTERORDER];
+
+ /* pitch lag estimated in enhancer and used in PLC */
+ int last_lag;
+
+ /* PLC state information */
+ int prevLag, consPLICount, prevPLI, prev_enh_pl;
+ float prevGain, prevLpc[LPC_FILTERORDER+1];
+ float prevResidual[NSUB*SUBL];
+ float energy;
+ unsigned long seed;
+
+ /* previous synthesis filter parameters */
+ float old_syntdenum[(LPC_FILTERORDER + 1)*NSUB];
+
+ /* state of output HP filter */
+ float hpomem[4];
+
+ /* enhancer state information */
+ int use_enhancer;
+ float enh_buf[ENH_BUFL];
+ float enh_period[ENH_NBLOCKS_TOT];
+
+} iLBC_Dec_Inst_t;
+
+#endif
+
+
diff --git a/codecs/ilbc/iLBC_encode.c b/codecs/ilbc/iLBC_encode.c
new file mode 100755
index 0000000000000000000000000000000000000000..6d8e043457f483fecabaafb126923ef44673b9d3
--- /dev/null
+++ b/codecs/ilbc/iLBC_encode.c
@@ -0,0 +1,446 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_encode.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "LPCencode.h"
+#include "FrameClassify.h"
+#include "StateSearchW.h"
+#include "StateConstructW.h"
+#include "helpfun.h"
+#include "constants.h"
+#include "packing.h"
+#include "iCBSearch.h"
+#include "iCBConstruct.h"
+#include "hpInput.h"
+#include "anaFilter.h"
+#include "syntFilter.h"
+
+/*----------------------------------------------------------------*
+ * Initiation of encoder instance.
+ *---------------------------------------------------------------*/
+
+short initEncode( /* (o) Number of bytes encoded */
+ iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) Encoder instance */
+){
+ memset((*iLBCenc_inst).anaMem, 0,
+ LPC_FILTERORDER*sizeof(float));
+ memcpy((*iLBCenc_inst).lsfold, lsfmeanTbl,
+ LPC_FILTERORDER*sizeof(float));
+ memcpy((*iLBCenc_inst).lsfdeqold, lsfmeanTbl,
+ LPC_FILTERORDER*sizeof(float));
+ memset((*iLBCenc_inst).lpc_buffer, 0,
+ LPC_LOOKBACK*sizeof(float));
+ memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float));
+
+ return (NO_OF_BYTES);
+}
+
+/*----------------------------------------------------------------*
+ * main encoder function
+ *---------------------------------------------------------------*/
+
+void iLBC_encode(
+ unsigned char *bytes, /* (o) encoded data bits iLBC */
+ float *block, /* (o) speech vector to encode */
+ iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder
+ state */
+){
+
+ float data[BLOCKL];
+ float residual[BLOCKL], reverseResidual[BLOCKL];
+
+ int start, idxForMax, idxVec[STATE_LEN];
+ float reverseDecresidual[BLOCKL], mem[CB_MEML];
+ int n, k, meml_gotten, Nfor, Nback, i, pos;
+ int gain_index[CB_NSTAGES*NASUB], extra_gain_index[CB_NSTAGES];
+ int cb_index[CB_NSTAGES*NASUB],extra_cb_index[CB_NSTAGES];
+ int lsf_i[LSF_NSPLIT*LPC_N];
+ unsigned char *pbytes;
+ int diff, start_pos, state_first;
+ float en1, en2;
+ int index, ulp, firstpart;
+ int subcount, subframe;
+ float weightState[LPC_FILTERORDER];
+ float syntdenum[NSUB*(LPC_FILTERORDER+1)];
+ float weightdenum[NSUB*(LPC_FILTERORDER+1)];
+ float decresidual[BLOCKL];
+
+ /* high pass filtering of input signal if such is not done
+ prior to calling this function */
+
+ /*hpInput(block, BLOCKL, data, (*iLBCenc_inst).hpimem);*/
+
+ /* otherwise simply copy */
+
+ memcpy(data,block,BLOCKL*sizeof(float));
+
+ /* LPC of hp filtered input data */
+
+ LPCencode(syntdenum, weightdenum, lsf_i, data,
+ iLBCenc_inst);
+
+ /* inverse filter to get residual */
+
+ for (n=0; n<NSUB; n++ ) {
+ anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)],
+ SUBL, &residual[n*SUBL], (*iLBCenc_inst).anaMem);
+ }
+
+ /* find state location */
+
+ start = FrameClassify(residual);
+
+ /* check if state should be in first or last part of the
+ two subframes */
+
+ diff = STATE_LEN - STATE_SHORT_LEN;
+ en1 = 0;
+ index = (start-1)*SUBL;
+ for (i = 0; i < STATE_SHORT_LEN; i++) {
+ en1 += residual[index+i]*residual[index+i];
+ }
+ en2 = 0;
+ index = (start-1)*SUBL+diff;
+ for (i = 0; i < STATE_SHORT_LEN; i++) {
+ en2 += residual[index+i]*residual[index+i];
+ }
+
+
+ if (en1 > en2) {
+ state_first = 1;
+ start_pos = (start-1)*SUBL;
+ } else {
+ state_first = 0;
+ start_pos = (start-1)*SUBL + diff;
+ }
+
+ /* scalar quantization of state */
+
+ StateSearchW(&residual[start_pos],
+ &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
+ &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax,
+ idxVec, STATE_SHORT_LEN, state_first);
+
+ StateConstructW(idxForMax, idxVec,
+ &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
+ &decresidual[start_pos], STATE_SHORT_LEN);
+
+ /* predictive quantization in state */
+
+ if (state_first) { /* put adaptive part in the end */
+
+ /* setup memory */
+
+ memset(mem, 0, (CB_MEML-STATE_SHORT_LEN)*sizeof(float));
+ memcpy(mem+CB_MEML-STATE_SHORT_LEN, decresidual+start_pos,
+ STATE_SHORT_LEN*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ /* encode subframes */
+
+ iCBSearch(extra_cb_index, extra_gain_index,
+ &residual[start_pos+STATE_SHORT_LEN],
+ mem+CB_MEML-stMemLTbl,
+ stMemLTbl, diff, CB_NSTAGES,
+ &weightdenum[start*(LPC_FILTERORDER+1)], weightState, 0);
+
+ /* construct decoded vector */
+
+ iCBConstruct(&decresidual[start_pos+STATE_SHORT_LEN],
+ extra_cb_index, extra_gain_index, mem+CB_MEML-stMemLTbl,
+ stMemLTbl, diff, CB_NSTAGES);
+
+ }
+ else { /* put adaptive part in the beginning */
+
+ /* create reversed vectors for prediction */
+
+ for(k=0; k<diff; k++ ){
+ reverseResidual[k] = residual[(start+1)*SUBL -1
+ -(k+STATE_SHORT_LEN)];
+ }
+
+ /* setup memory */
+
+ meml_gotten = STATE_SHORT_LEN;
+ for( k=0; k<meml_gotten; k++){
+ mem[CB_MEML-1-k] = decresidual[start_pos + k];
+ }
+ memset(mem, 0, (CB_MEML-k)*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ /* encode subframes */
+
+ iCBSearch(extra_cb_index, extra_gain_index,
+ reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl, diff,
+ CB_NSTAGES, &weightdenum[(start-1)*(LPC_FILTERORDER+1)],
+ weightState, 0);
+
+ /* construct decoded vector */
+
+ iCBConstruct(reverseDecresidual, extra_cb_index,
+ extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl, diff,
+ CB_NSTAGES);
+
+ /* get decoded residual from reversed vector */
+
+ for( k=0; k<diff; k++ ){
+ decresidual[start_pos-1-k] = reverseDecresidual[k];
+ }
+ }
+
+ /* counter for predicted subframes */
+
+ subcount=0;
+
+ /* forward prediction of subframes */
+
+ Nfor = NSUB-start-1;
+
+
+ if( Nfor > 0 ){
+
+ /* setup memory */
+
+ memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
+ memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
+ STATE_LEN*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ /* loop over subframes to encode */
+
+ for (subframe=0; subframe<Nfor; subframe++) {
+
+ /* encode subframe */
+
+ iCBSearch(cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ &residual[(start+1+subframe)*SUBL],
+ mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
+ SUBL, CB_NSTAGES,
+ &weightdenum[(start+1+subframe)*(LPC_FILTERORDER+1)],
+ weightState, subcount+1);
+
+ /* construct decoded vector */
+
+ iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
+ cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
+ SUBL, CB_NSTAGES);
+
+ /* update memory */
+
+ memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
+ memcpy(mem+CB_MEML-SUBL,
+ &decresidual[(start+1+subframe)*SUBL],
+ SUBL*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ subcount++;
+ }
+ }
+
+
+ /* backward prediction of subframes */
+
+ Nback = start-1;
+
+
+ if( Nback > 0 ){
+
+ /* create reverse order vectors */
+
+ for( n=0; n<Nback; n++ ){
+ for( k=0; k<SUBL; k++ ){
+ reverseResidual[n*SUBL+k] =
+ residual[(start-1)*SUBL-1-n*SUBL-k];
+ reverseDecresidual[n*SUBL+k] =
+ decresidual[(start-1)*SUBL-1-n*SUBL-k];
+ }
+ }
+
+ /* setup memory */
+
+ meml_gotten = SUBL*(NSUB+1-start);
+
+
+ if( meml_gotten > CB_MEML ) {
+ meml_gotten=CB_MEML;
+ }
+ for( k=0; k<meml_gotten; k++) {
+ mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
+ }
+ memset(mem, 0, (CB_MEML-k)*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ /* loop over subframes to encode */
+
+ for (subframe=0; subframe<Nback; subframe++) {
+
+ /* encode subframe */
+
+ iCBSearch(cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ &reverseResidual[subframe*SUBL],
+ mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
+ SUBL, CB_NSTAGES,
+ &weightdenum[(start-2-subframe)*(LPC_FILTERORDER+1)],
+ weightState, subcount+1);
+
+ /* construct decoded vector */
+
+ iCBConstruct(&reverseDecresidual[subframe*SUBL],
+ cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ mem+CB_MEML-memLfTbl[subcount],
+ memLfTbl[subcount], SUBL, CB_NSTAGES);
+
+ /* update memory */
+
+ memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
+ memcpy(mem+CB_MEML-SUBL,
+ &reverseDecresidual[subframe*SUBL],
+ SUBL*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ subcount++;
+
+ }
+
+ /* get decoded residual from reversed vector */
+
+ for (i = 0; i < SUBL*Nback; i++) {
+ decresidual[SUBL*Nback - i - 1] =
+ reverseDecresidual[i];
+ }
+ }
+ /* end encoding part */
+
+ /* adjust index */
+ index_conv_enc(cb_index);
+
+ /* pack bytes */
+
+ pbytes=bytes;
+ pos=0;
+
+ /* loop over the 3 ULP classes */
+
+ for (ulp=0; ulp<3; ulp++) {
+
+ /* LSF */
+ for (k=0;k<6;k++) {
+ packsplit(&lsf_i[k], &firstpart, &lsf_i[k],
+ ulp_lsf_bitsTbl[k][ulp],
+ ulp_lsf_bitsTbl[k][ulp]+
+ ulp_lsf_bitsTbl[k][ulp+1]+
+ ulp_lsf_bitsTbl[k][ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_lsf_bitsTbl[k][ulp], &pos);
+ }
+
+ /* Start block info */
+
+ packsplit(&start, &firstpart, &start,
+ ulp_start_bitsTbl[ulp],
+ ulp_start_bitsTbl[ulp]+
+ ulp_start_bitsTbl[ulp+1]+
+ ulp_start_bitsTbl[ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_start_bitsTbl[ulp], &pos);
+
+ packsplit(&state_first, &firstpart, &state_first,
+ ulp_startfirst_bitsTbl[ulp],
+ ulp_startfirst_bitsTbl[ulp]+
+ ulp_startfirst_bitsTbl[ulp+1]+
+ ulp_startfirst_bitsTbl[ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_startfirst_bitsTbl[ulp], &pos);
+
+ packsplit(&idxForMax, &firstpart, &idxForMax,
+ ulp_scale_bitsTbl[ulp], ulp_scale_bitsTbl[ulp]+
+ ulp_scale_bitsTbl[ulp+1]+ulp_scale_bitsTbl[ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_scale_bitsTbl[ulp], &pos);
+
+ for (k=0; k<STATE_SHORT_LEN; k++) {
+ packsplit(idxVec+k, &firstpart, idxVec+k,
+ ulp_state_bitsTbl[ulp],
+ ulp_state_bitsTbl[ulp]+
+ ulp_state_bitsTbl[ulp+1]+
+ ulp_state_bitsTbl[ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_state_bitsTbl[ulp], &pos);
+ }
+
+ /* 22 sample block */
+
+ for (k=0;k<CB_NSTAGES;k++) {
+ packsplit(extra_cb_index+k, &firstpart,
+ extra_cb_index+k,
+ ulp_extra_cb_indexTbl[k][ulp],
+ ulp_extra_cb_indexTbl[k][ulp]+
+ ulp_extra_cb_indexTbl[k][ulp+1]+
+ ulp_extra_cb_indexTbl[k][ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_extra_cb_indexTbl[k][ulp], &pos);
+ }
+ for (k=0;k<CB_NSTAGES;k++) {
+ packsplit(extra_gain_index+k, &firstpart,
+ extra_gain_index+k,
+ ulp_extra_cb_gainTbl[k][ulp],
+ ulp_extra_cb_gainTbl[k][ulp]+
+ ulp_extra_cb_gainTbl[k][ulp+1]+
+ ulp_extra_cb_gainTbl[k][ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_extra_cb_gainTbl[k][ulp], &pos);
+ }
+
+ /* The four 40 sample sub blocks */
+
+ for (i=0; i<NASUB; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ packsplit(cb_index+i*CB_NSTAGES+k, &firstpart,
+ cb_index+i*CB_NSTAGES+k,
+ ulp_cb_indexTbl[i][k][ulp],
+ ulp_cb_indexTbl[i][k][ulp]+
+ ulp_cb_indexTbl[i][k][ulp+1]+
+ ulp_cb_indexTbl[i][k][ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_cb_indexTbl[i][k][ulp], &pos);
+ }
+ }
+
+ for (i=0; i<NASUB; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ packsplit(gain_index+i*CB_NSTAGES+k, &firstpart,
+ gain_index+i*CB_NSTAGES+k,
+ ulp_cb_gainTbl[i][k][ulp],
+ ulp_cb_gainTbl[i][k][ulp]+
+ ulp_cb_gainTbl[i][k][ulp+1]+
+ ulp_cb_gainTbl[i][k][ulp+2]);
+ dopack( &pbytes, firstpart,
+ ulp_cb_gainTbl[i][k][ulp], &pos);
+ }
+ }
+ }
+
+ /* set the last unused bit to zero */
+ dopack( &pbytes, 0, 1, &pos);
+}
+
+
diff --git a/codecs/ilbc/iLBC_encode.h b/codecs/ilbc/iLBC_encode.h
new file mode 100755
index 0000000000000000000000000000000000000000..5e4de46c58814d9cd83806c826eb6f0bb0e7cf9e
--- /dev/null
+++ b/codecs/ilbc/iLBC_encode.h
@@ -0,0 +1,32 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_encode.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ILBCENCODE_H
+#define __iLBC_ILBCENCODE_H
+
+#include "iLBC_define.h"
+
+short initEncode( /* (o) Number of bytes encoded */
+ iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) Encoder instance */
+);
+
+void iLBC_encode(
+ unsigned char *bytes, /* (o) encoded data bits iLBC */
+ float *block, /* (o) speech vector to encode */
+ iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder
+ state */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/lsf.c b/codecs/ilbc/lsf.c
new file mode 100755
index 0000000000000000000000000000000000000000..f768b7782773a3d03ac4983b8f6254acf3519780
--- /dev/null
+++ b/codecs/ilbc/lsf.c
@@ -0,0 +1,252 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ lsf.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <string.h>
+#include <math.h>
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * conversion from lpc coefficients to lsf coefficients
+ *---------------------------------------------------------------*/
+
+void a2lsf(
+ float *freq,/* (o) lsf coefficients */
+ float *a /* (i) lpc coefficients */
+){
+ float steps[LSF_NUMBER_OF_STEPS] =
+ {(float)0.00635, (float)0.003175, (float)0.0015875,
+ (float)0.00079375};
+ float step;
+ int step_idx;
+ int lsp_index;
+ float p[LPC_HALFORDER];
+ float q[LPC_HALFORDER];
+ float p_pre[LPC_HALFORDER];
+ float q_pre[LPC_HALFORDER];
+ float old_p, old_q, *old;
+ float *pq_coef;
+ float omega, old_omega;
+ int i;
+ float hlp, hlp1, hlp2, hlp3, hlp4, hlp5;
+
+ for (i = 0; i < LPC_HALFORDER; i++){
+ p[i] = (float)-1.0 * (a[i + 1] + a[LPC_FILTERORDER - i]);
+ q[i] = a[LPC_FILTERORDER - i] - a[i + 1];
+ }
+
+ p_pre[0] = (float)-1.0 - p[0];
+ p_pre[1] = - p_pre[0] - p[1];
+ p_pre[2] = - p_pre[1] - p[2];
+ p_pre[3] = - p_pre[2] - p[3];
+ p_pre[4] = - p_pre[3] - p[4];
+ p_pre[4] = p_pre[4] / 2;
+
+ q_pre[0] = (float)1.0 - q[0];
+ q_pre[1] = q_pre[0] - q[1];
+ q_pre[2] = q_pre[1] - q[2];
+ q_pre[3] = q_pre[2] - q[3];
+ q_pre[4] = q_pre[3] - q[4];
+ q_pre[4] = q_pre[4] / 2;
+
+ omega = 0.0;
+ old_omega = 0.0;
+
+ old_p = FLOAT_MAX;
+ old_q = FLOAT_MAX;
+
+ /* Here we loop through lsp_index to find all the
+ LPC_FILTERORDER roots for omega. */
+
+ for (lsp_index = 0; lsp_index < LPC_FILTERORDER; lsp_index++){
+
+ /* Depending on lsp_index being even or odd, we
+ alternatively solve the roots for the two LSP equations. */
+
+
+ if ((lsp_index & 0x1) == 0) {
+ pq_coef = p_pre;
+ old = &old_p;
+ } else {
+ pq_coef = q_pre;
+ old = &old_q;
+ }
+
+ /* Start with low resolution grid */
+
+ for (step_idx = 0, step = steps[step_idx];
+ step_idx < LSF_NUMBER_OF_STEPS;){
+
+ /* cos(10piw) + pq(0)cos(8piw) + pq(1)cos(6piw) +
+ pq(2)cos(4piw) + pq(3)cod(2piw) + pq(4) */
+
+ hlp = (float)cos(omega * TWO_PI);
+ hlp1 = (float)2.0 * hlp + pq_coef[0];
+ hlp2 = (float)2.0 * hlp * hlp1 - (float)1.0 +
+ pq_coef[1];
+ hlp3 = (float)2.0 * hlp * hlp2 - hlp1 + pq_coef[2];
+ hlp4 = (float)2.0 * hlp * hlp3 - hlp2 + pq_coef[3];
+ hlp5 = hlp * hlp4 - hlp3 + pq_coef[4];
+
+
+ if (((hlp5 * (*old)) <= 0.0) || (omega >= 0.5)){
+
+ if (step_idx == (LSF_NUMBER_OF_STEPS - 1)){
+
+ if (fabs(hlp5) >= fabs(*old)) {
+ freq[lsp_index] = omega - step;
+ } else {
+ freq[lsp_index] = omega;
+ }
+
+
+ if ((*old) >= 0.0){
+ *old = (float)-1.0 * FLOAT_MAX;
+ } else {
+ *old = FLOAT_MAX;
+ }
+
+ omega = old_omega;
+ step_idx = 0;
+
+ step_idx = LSF_NUMBER_OF_STEPS;
+ } else {
+
+ if (step_idx == 0) {
+ old_omega = omega;
+ }
+
+ step_idx++;
+ omega -= steps[step_idx];
+
+ /* Go back one grid step */
+
+ step = steps[step_idx];
+ }
+ } else {
+
+ /* increment omega until they are of different sign,
+ and we know there is at least one root between omega
+ and old_omega */
+ *old = hlp5;
+ omega += step;
+ }
+ }
+ }
+
+ for (i = 0; i < LPC_FILTERORDER; i++) {
+ freq[i] = freq[i] * TWO_PI;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * conversion from lsf coefficients to lpc coefficients
+ *---------------------------------------------------------------*/
+
+void lsf2a(
+ float *a_coef, /* (o) lpc coefficients */
+ float *freq /* (i) lsf coefficients */
+){
+ int i, j;
+ float hlp;
+ float p[LPC_HALFORDER], q[LPC_HALFORDER];
+ float a[LPC_HALFORDER + 1], a1[LPC_HALFORDER], a2[LPC_HALFORDER];
+ float b[LPC_HALFORDER + 1], b1[LPC_HALFORDER], b2[LPC_HALFORDER];
+
+ for (i = 0; i < LPC_FILTERORDER; i++) {
+ freq[i] = freq[i] * PI2;
+ }
+
+ /* Check input for ill-conditioned cases. This part is not
+ found in the TIA standard. It involves the following 2 IF
+ blocks. If "freq" is judged ill-conditioned, then we first
+ modify freq[0] and freq[LPC_HALFORDER-1] (normally
+ LPC_HALFORDER = 10 for LPC applications), then we adjust
+ the other "freq" values slightly */
+
+
+ if ((freq[0] <= 0.0) || (freq[LPC_FILTERORDER - 1] >= 0.5)){
+
+
+ if (freq[0] <= 0.0) {
+ freq[0] = (float)0.022;
+ }
+
+
+ if (freq[LPC_FILTERORDER - 1] >= 0.5) {
+ freq[LPC_FILTERORDER - 1] = (float)0.499;
+ }
+
+ hlp = (freq[LPC_FILTERORDER - 1] - freq[0]) /
+ (float) (LPC_FILTERORDER - 1);
+
+ for (i = 1; i < LPC_FILTERORDER; i++) {
+ freq[i] = freq[i - 1] + hlp;
+ }
+ }
+
+ memset(a1, 0, LPC_HALFORDER*sizeof(float));
+ memset(a2, 0, LPC_HALFORDER*sizeof(float));
+ memset(b1, 0, LPC_HALFORDER*sizeof(float));
+ memset(b2, 0, LPC_HALFORDER*sizeof(float));
+ memset(a, 0, (LPC_HALFORDER+1)*sizeof(float));
+ memset(b, 0, (LPC_HALFORDER+1)*sizeof(float));
+
+ /* p[i] and q[i] compute cos(2*pi*omega_{2j}) and
+ cos(2*pi*omega_{2j-1} in eqs. 4.2.2.2-1 and 4.2.2.2-2.
+ Note that for this code p[i] specifies the coefficients
+ used in .Q_A(z) while q[i] specifies the coefficients used
+ in .P_A(z) */
+
+ for (i = 0; i < LPC_HALFORDER; i++){
+ p[i] = (float)cos(TWO_PI * freq[2 * i]);
+ q[i] = (float)cos(TWO_PI * freq[2 * i + 1]);
+ }
+
+ a[0] = 0.25;
+ b[0] = 0.25;
+
+ for (i = 0; i < LPC_HALFORDER; i++){
+ a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
+ b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
+ a2[i] = a1[i];
+ a1[i] = a[i];
+ b2[i] = b1[i];
+ b1[i] = b[i];
+ }
+
+ for (j = 0; j < LPC_FILTERORDER; j++){
+
+ if (j == 0) {
+ a[0] = 0.25;
+ b[0] = -0.25;
+ } else {
+ a[0] = b[0] = 0.0;
+ }
+
+ for (i = 0; i < LPC_HALFORDER; i++){
+ a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
+ b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
+ a2[i] = a1[i];
+ a1[i] = a[i];
+ b2[i] = b1[i];
+ b1[i] = b[i];
+ }
+
+ a_coef[j + 1] = 2 * (a[LPC_HALFORDER] + b[LPC_HALFORDER]);
+ }
+
+ a_coef[0] = 1.0;
+}
+
+
diff --git a/codecs/ilbc/lsf.h b/codecs/ilbc/lsf.h
new file mode 100755
index 0000000000000000000000000000000000000000..825685d4199b178e91e4d764de155a68ce4b5c07
--- /dev/null
+++ b/codecs/ilbc/lsf.h
@@ -0,0 +1,29 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ lsf.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_LSF_H
+#define __iLBC_LSF_H
+
+void a2lsf(
+ float *freq,/* (o) lsf coefficients */
+ float *a /* (i) lpc coefficients */
+);
+
+void lsf2a(
+ float *a_coef, /* (o) lpc coefficients */
+ float *freq /* (i) lsf coefficients */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/packing.c b/codecs/ilbc/packing.c
new file mode 100755
index 0000000000000000000000000000000000000000..6449e55ffdb3224d9dfc5f17cafb44dbbbd35620
--- /dev/null
+++ b/codecs/ilbc/packing.c
@@ -0,0 +1,169 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ packing.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include "helpfun.h"
+#include "string.h"
+
+/*----------------------------------------------------------------*
+ * splitting an integer into first most significant bits and
+ * remaining least significant bits
+ *---------------------------------------------------------------*/
+
+void packsplit(
+ int *index, /* (i) the value to split */
+ int *firstpart, /* (o) the value specified by most
+ significant bits */
+ int *rest, /* (o) the value specified by least
+ significant bits */
+ int bitno_firstpart, /* (i) number of bits in most
+ significant part */
+ int bitno_total /* (i) number of bits in full range
+ of value */
+){
+ int bitno_rest = bitno_total-bitno_firstpart;
+
+ *firstpart = *index>>(bitno_rest);
+ *rest = *index-(*firstpart<<(bitno_rest));
+}
+
+/*----------------------------------------------------------------*
+ * combining a value corresponding to msb's with a value
+ * corresponding to lsb's
+ *---------------------------------------------------------------*/
+
+void packcombine(
+ int *index, /* (i/o) the msb value in the
+ combined value out */
+ int rest, /* (i) the lsb value */
+ int bitno_rest /* (i) the number of bits in the
+ lsb part */
+){
+ *index = *index<<bitno_rest;
+ *index += rest;
+}
+
+/*----------------------------------------------------------------*
+ * packing of bits into bitstream, i.e., vector of bytes
+ *---------------------------------------------------------------*/
+
+void dopack(
+ unsigned char **bitstream, /* (i/o) on entrance pointer to place
+ in bitstream to pack new data,
+ on exit pointer to place in
+ bitstream to pack future
+ data */
+ int index, /* (i) the value to pack */
+ int bitno, /* (i) the number of bits that the
+ value will fit within */
+ int *pos /* (i/o) write position in the
+ current byte */
+){
+ int posLeft;
+
+ /* Clear the bits before starting in a new byte */
+
+ if ((*pos)==0) {
+ **bitstream=0;
+ }
+
+ while (bitno>0) {
+
+ /* Jump to the next byte if end of this byte is reached*/
+
+ if (*pos==8) {
+ *pos=0;
+ (*bitstream)++;
+ **bitstream=0;
+ }
+
+ posLeft=8-(*pos);
+
+ /* Insert index into the bitstream */
+
+ if (bitno <= posLeft) {
+ **bitstream |= (unsigned char)(index<<(posLeft-bitno));
+ *pos+=bitno;
+ bitno=0;
+ } else {
+ **bitstream |= (unsigned char)(index>>(bitno-posLeft));
+
+ *pos=8;
+ index-=((index>>(bitno-posLeft))<<(bitno-posLeft));
+
+ bitno-=posLeft;
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * unpacking of bits from bitstream, i.e., vector of bytes
+ *---------------------------------------------------------------*/
+
+void unpack(
+ unsigned char **bitstream, /* (i/o) on entrance pointer to
+ place in bitstream to
+ unpack new data from, on
+ exit pointer to place in
+ bitstream to unpack future
+ data from */
+ int *index, /* (o) resulting value */
+ int bitno, /* (i) number of bits used to
+ represent the value */
+ int *pos /* (i/o) read position in the
+ current byte */
+){
+ int BitsLeft;
+
+ *index=0;
+
+ while (bitno>0) {
+
+ /* move forward in bitstream when the end of the
+ byte is reached */
+
+ if (*pos==8) {
+ *pos=0;
+ (*bitstream)++;
+ }
+
+ BitsLeft=8-(*pos);
+
+ /* Extract bits to index */
+
+ if (BitsLeft>=bitno) {
+ *index+=((((**bitstream)<<(*pos)) & 0xFF)>>(8-bitno));
+
+ *pos+=bitno;
+ bitno=0;
+ } else {
+
+ if ((8-bitno)>0) {
+ *index+=((((**bitstream)<<(*pos)) & 0xFF)>>
+ (8-bitno));
+ *pos=8;
+ } else {
+ *index+=(((int)(((**bitstream)<<(*pos)) & 0xFF))<<
+ (bitno-8));
+ *pos=8;
+ }
+ bitno-=BitsLeft;
+ }
+ }
+}
+
+
diff --git a/codecs/ilbc/packing.h b/codecs/ilbc/packing.h
new file mode 100755
index 0000000000000000000000000000000000000000..21261e82d39c5f328fc5b35df3084b9639352b98
--- /dev/null
+++ b/codecs/ilbc/packing.h
@@ -0,0 +1,65 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ packing.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __PACKING_H
+#define __PACKING_H
+
+void packsplit(
+ int *index, /* (i) the value to split */
+ int *firstpart, /* (o) the value specified by most
+ significant bits */
+ int *rest, /* (o) the value specified by least
+ significant bits */
+ int bitno_firstpart, /* (i) number of bits in most
+ significant part */
+ int bitno_total /* (i) number of bits in full range
+ of value */
+);
+
+void packcombine(
+ int *index, /* (i/o) the msb value in the
+ combined value out */
+ int rest, /* (i) the lsb value */
+ int bitno_rest /* (i) the number of bits in the
+ lsb part */
+);
+
+void dopack(
+ unsigned char **bitstream, /* (i/o) on entrance pointer to place
+ in bitstream to pack new data,
+ on exit pointer to place in
+ bitstream to pack future
+ data */
+ int index, /* (i) the value to pack */
+ int bitno, /* (i) the number of bits that the
+ value will fit within */
+ int *pos /* (i/o) write position in the
+ current byte */
+);
+
+void unpack(
+ unsigned char **bitstream, /* (i/o) on entrance pointer to place
+ in bitstream to unpack
+ new data from, on exit pointer
+ to place in bitstream to
+ unpack future data from */
+ int *index, /* (o) resulting value */
+ int bitno, /* (i) number of bits used to
+ represent the value */
+ int *pos /* (i/o) read position in the
+ current byte */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc/syntFilter.c b/codecs/ilbc/syntFilter.c
new file mode 100755
index 0000000000000000000000000000000000000000..fe61eaa46e3e644420cc433bd1ec2978e1226937
--- /dev/null
+++ b/codecs/ilbc/syntFilter.c
@@ -0,0 +1,65 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ syntFilter.c
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * LP synthesis filter.
+ *---------------------------------------------------------------*/
+
+void syntFilter(
+ float *Out, /* (i/o) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len, /* (i) Length of signal */
+ float *mem /* (i/o) Filter state */
+){
+ int i, j;
+ float *po, *pi, *pa, *pm;
+
+ po=Out;
+
+ /* Filter first part using memory from past */
+
+ for (i=0;i<LPC_FILTERORDER;i++) {
+ pi=&Out[i-1];
+ pa=&a[1];
+ pm=&mem[LPC_FILTERORDER-1];
+ for (j=1;j<=i;j++) {
+ *po-=(*pa++)*(*pi--);
+ }
+ for (j=i+1;j<LPC_FILTERORDER+1;j++) {
+ *po-=(*pa++)*(*pm--);
+ }
+ po++;
+ }
+
+ /* Filter last part where the state is entierly in
+ the output vector */
+
+ for (i=LPC_FILTERORDER;i<len;i++) {
+ pi=&Out[i-1];
+ pa=&a[1];
+ for (j=1;j<LPC_FILTERORDER+1;j++) {
+ *po-=(*pa++)*(*pi--);
+ }
+ po++;
+ }
+
+ /* Update state vector */
+
+ memcpy(mem, &Out[len-LPC_FILTERORDER],
+ LPC_FILTERORDER*sizeof(float));
+}
+
+
+
diff --git a/codecs/ilbc/syntFilter.h b/codecs/ilbc/syntFilter.h
new file mode 100755
index 0000000000000000000000000000000000000000..5c731ac6d9f96d6b644d7697df8332100895c633
--- /dev/null
+++ b/codecs/ilbc/syntFilter.h
@@ -0,0 +1,26 @@
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ syntFilter.h
+
+ Copyright (c) 2001,
+ Global IP Sound AB.
+ All rights reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_SYNTFILTER_H
+#define __iLBC_SYNTFILTER_H
+
+void syntFilter(
+ float *Out, /* (i/o) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len, /* (i) Length of signal */
+ float *mem /* (i/o) Filter state */
+);
+
+#endif
+
+
diff --git a/codecs/ilbc_slin_ex.h b/codecs/ilbc_slin_ex.h
new file mode 100755
index 0000000000000000000000000000000000000000..e268933f43d72162e372668fdd94c6c8a201d5c4
--- /dev/null
+++ b/codecs/ilbc_slin_ex.h
@@ -0,0 +1,18 @@
+/*
+ * Raw 8-bit data
+ *
+ * Source: ilbc.out
+ *
+ * Copyright (C) 1999, Mark Spencer and Linux Support Services
+ *
+ * Distributed under the terms of the GNU General Public License
+ *
+ */
+
+static unsigned char ilbc_slin_ex[] = {
+0xff, 0xa0, 0xff, 0xfa, 0xf, 0x60, 0x12, 0x11, 0xa2, 0x47,
+0x22, 0x8c, 00, 00, 0x1, 0x2, 0x80, 0x43, 0xa0, 0x40,
+0x33, 0xff, 0xcf, 0xc0, 0xf3, 0xf3, 0x3f, 0x8f, 0x3f, 0xff,
+0xff, 0xff, 0xff, 0xfc, 0xf9, 0xe5, 0x55, 0x78, 0xb, 0xca,
+0xe1, 0x27, 0x94, 0x7b, 0xa8, 0x91, 0x2c, 0x36, 0x8, 0x56,
+00, 00 };
diff --git a/codecs/slin_ilbc_ex.h b/codecs/slin_ilbc_ex.h
new file mode 100755
index 0000000000000000000000000000000000000000..1e2b5779ee868dbccf8ed813f7a11e1e8fd210d8
--- /dev/null
+++ b/codecs/slin_ilbc_ex.h
@@ -0,0 +1,28 @@
+/*
+ * Signed 16-bit audio data
+ *
+ * Source: gsm.example
+ *
+ * Copyright (C) 1999, Mark Spencer
+ *
+ * Distributed under the terms of the GNU General Public License
+ *
+ */
+
+static signed short slin_ilbc_ex[] = {
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 0xfff8, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 0x0008, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+0x0008, 000000, 000000, 000000, 0xfff8, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000,
+000000, 000000, 000000, 000000, 000000, 000000, 0x0008, 000000, 000000, 000000 };
diff --git a/frame.c b/frame.c
index 7d677f9aa7826e159bbb77cc4e76daa0ee2eadbc..482014ca49b1f4ca4c436b9ada1efc40eab4d33e 100755
--- a/frame.c
+++ b/frame.c
@@ -365,6 +365,8 @@ int ast_getformatbyname(char *name)
return AST_FORMAT_G729A;
else if (!strcasecmp(name, "speex"))
return AST_FORMAT_SPEEX;
+ else if (!strcasecmp(name, "ilbc"))
+ return AST_FORMAT_ILBC;
else if (!strcasecmp(name, "all"))
return 0x7FFFFFFF;
return 0;
diff --git a/include/asterisk/frame.h b/include/asterisk/frame.h
index 2dbcccf086b6951dfd78b315a80bd1637987ee6f..c23ed71ceccc467be59a9212b3cc3e500d3676f6 100755
--- a/include/asterisk/frame.h
+++ b/include/asterisk/frame.h
@@ -131,6 +131,8 @@ struct ast_frame_chain {
#define AST_FORMAT_G729A (1 << 8)
/*! SpeeX Free Compression */
#define AST_FORMAT_SPEEX (1 << 9)
+/*! iLBC Free Compression */
+#define AST_FORMAT_ILBC (1 << 10)
/*! Maximum audio format */
#define AST_FORMAT_MAX_AUDIO (1 << 15)
/*! JPEG Images */
diff --git a/rtp.c b/rtp.c
index 3e02849e13f209e213f698af19d36eb955178ed0..78e325a8c9ac1d4eae929de0e177dad3e96c3d25 100755
--- a/rtp.c
+++ b/rtp.c
@@ -30,6 +30,7 @@
#include <asterisk/logger.h>
#include <asterisk/options.h>
#include <asterisk/channel.h>
+#include <asterisk/acl.h>
#include <asterisk/channel_pvt.h>
#define TYPE_SILENCE 0x2
@@ -332,6 +333,9 @@ struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
case AST_FORMAT_GSM:
rtp->f.samples = 160 * (rtp->f.datalen / 33);
break;
+ case AST_FORMAT_ILBC:
+ rtp->f.samples = 240 * (rtp->f.datalen / 52);
+ break;
case AST_FORMAT_ADPCM:
rtp->f.samples = rtp->f.datalen * 2;
break;
@@ -370,6 +374,7 @@ static struct {
{{1, AST_FORMAT_LPC10}, "audio", "LPC"},
{{1, AST_FORMAT_G729A}, "audio", "G729"},
{{1, AST_FORMAT_SPEEX}, "audio", "SPEEX"},
+ {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
{{0, AST_RTP_DTMF}, "audio", "telephone-event"},
{{0, AST_RTP_CN}, "audio", "CN"},
{{1, AST_FORMAT_JPEG}, "video", "JPEG"},
@@ -401,6 +406,7 @@ static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
[34] = {1, AST_FORMAT_H263},
[101] = {0, AST_RTP_DTMF},
[110] = {1, AST_FORMAT_SPEEX},
+ [120] = {1, AST_FORMAT_ILBC},
};
void ast_rtp_pt_clear(struct ast_rtp* rtp)
@@ -710,6 +716,9 @@ static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec
case AST_FORMAT_GSM:
pred = rtp->lastts + (f->datalen * 160 / 33);
break;
+ case AST_FORMAT_ILBC:
+ pred = rtp->lastts + (f->datalen * 240 / 52);
+ break;
case AST_FORMAT_G723_1:
pred = rtp->lastts + g723_samples(f->data, f->datalen);
break;
@@ -822,6 +831,18 @@ int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
while((f = ast_smoother_read(rtp->smoother)))
ast_rtp_raw_write(rtp, f, codec);
break;
+ case AST_FORMAT_ILBC:
+ if (!rtp->smoother) {
+ rtp->smoother = ast_smoother_new(52);
+ }
+ if (!rtp->smoother) {
+ ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
+ return -1;
+ }
+ ast_smoother_feed(rtp->smoother, _f);
+ while((f = ast_smoother_read(rtp->smoother)))
+ ast_rtp_raw_write(rtp, f, codec);
+ break;
default:
ast_log(LOG_WARNING, "Not sure about sending format %d packets\n", _f->subclass);
// fall through to...