From aa6b8344aec1d8f0f3c3f4604c52eb842f5faf4c Mon Sep 17 00:00:00 2001 From: sobomax Date: Mon, 12 Jan 2009 20:48:54 +0000 Subject: o Update to 1.2.30.2; o Make speex codec working with recent version of libspeex. PR: 129970. --- net/asterisk12/Makefile | 3 +- net/asterisk12/distinfo | 6 +- net/asterisk12/files/patch-codecs::Makefile | 19 +- net/asterisk12/files/patch-codecs_ilbc | 7194 ++++++++++++++++++++ .../files/patch-include_asterisk_astobj2.h | 14 + net/asterisk12/pkg-plist | 1 + 6 files changed, 7227 insertions(+), 10 deletions(-) create mode 100644 net/asterisk12/files/patch-codecs_ilbc create mode 100644 net/asterisk12/files/patch-include_asterisk_astobj2.h (limited to 'net') diff --git a/net/asterisk12/Makefile b/net/asterisk12/Makefile index c2f4851f3c99..7e8601e7deef 100644 --- a/net/asterisk12/Makefile +++ b/net/asterisk12/Makefile @@ -6,9 +6,8 @@ # PORTNAME= asterisk -PORTVERSION= 1.2.27 +PORTVERSION= 1.2.30.2 PKGNAMESUFFIX= 12 -PORTREVISION= 2 CATEGORIES= net MASTER_SITES= http://ftp.digium.com/pub/asterisk/ \ http://ftp.digium.com/pub/asterisk/old-releases/ diff --git a/net/asterisk12/distinfo b/net/asterisk12/distinfo index 70758082ccd9..b5fbda7ba356 100644 --- a/net/asterisk12/distinfo +++ b/net/asterisk12/distinfo @@ -1,6 +1,6 @@ -MD5 (asterisk-1.2.27.tar.gz) = b4bbd660472e56e2f80e0c0391e64b10 -SHA256 (asterisk-1.2.27.tar.gz) = 2407996df3487060b9db1a4ca73f405b633a802ba9c1454f7f3ccaaa856971e6 -SIZE (asterisk-1.2.27.tar.gz) = 10645295 +MD5 (asterisk-1.2.30.2.tar.gz) = 42beb96eaec0e9f8f8e803dbc8c92b3b +SHA256 (asterisk-1.2.30.2.tar.gz) = e796648e7d29dec74c0d6bd752e985b3ac1e44e77b2ea87818d6fe003975fd91 +SIZE (asterisk-1.2.30.2.tar.gz) = 10627557 MD5 (asterisk-1.2.26.1-codec-negotiation-20080118.diff.gz) = 2ae6d6cc44fdd89dab804bcf6ac79579 SHA256 (asterisk-1.2.26.1-codec-negotiation-20080118.diff.gz) = d489cf3921d0ff11571afd273b4cbd02b0e8ba5f225ac4c6fd6fc85a0de54f6b SIZE (asterisk-1.2.26.1-codec-negotiation-20080118.diff.gz) = 33572 diff --git a/net/asterisk12/files/patch-codecs::Makefile b/net/asterisk12/files/patch-codecs::Makefile index 646028d6b444..74435e63a935 100644 --- a/net/asterisk12/files/patch-codecs::Makefile +++ b/net/asterisk12/files/patch-codecs::Makefile @@ -12,7 +12,7 @@ $FreeBSD$ ifeq (${OSARCH},NetBSD) SOLINK+=-L$(CROSS_COMPILE_TARGET)/usr/pkg/lib endif -@@ -43,8 +43,8 @@ +@@ -43,28 +43,28 @@ UI_SPEEX=$(wildcard $(CROSS_COMPILE_TARGET)/usr/include/speex.h) UIS_SPEEX=$(wildcard $(CROSS_COMPILE_TARGET)/usr/include/speex/speex.h) @@ -22,26 +22,35 @@ $FreeBSD$ +ULIS_SPEEX=$(wildcard $(CROSS_COMPILE_TARGET)$(LOCALBASE)/include/speex/speex.h) ifneq (${UI_SPEEX},) MODSPEEX=codec_speex.so - LIBSPEEX+=-lspeex -lm -@@ -56,14 +56,14 @@ +- LIBSPEEX+=-lspeex -lm ++ LIBSPEEX+=-lspeex -lspeexdsp -lm + endif + ifneq (${UIS_SPEEX},) + MODSPEEX=codec_speex.so + CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/speex +- LIBSPEEX+=-lspeex -lm ++ LIBSPEEX+=-lspeex -lspeexdsp -lm endif ifneq (${ULI_SPEEX},) MODSPEEX=codec_speex.so - CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/local/include - LIBSPEEX=-L$(CROSS_COMPILE_TARGET)/usr/local/lib +- LIBSPEEX+=-lspeex -lm + CFLAGS+=-I$(CROSS_COMPILE_TARGET)$(LOCALBASE)/include + LIBSPEEX=-L$(CROSS_COMPILE_TARGET)$(LOCALBASE)/lib - LIBSPEEX+=-lspeex -lm ++ LIBSPEEX+=-lspeex -lspeexdsp -lm endif ifneq (${ULIS_SPEEX},) MODSPEEX=codec_speex.so - CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/local/include/speex - LIBSPEEX=-L$(CROSS_COMPILE_TARGET)/usr/local/lib +- LIBSPEEX+=-lspeex -lm + CFLAGS+=-I$(CROSS_COMPILE_TARGET)$(LOCALBASE)/include/speex + LIBSPEEX=-L$(CROSS_COMPILE_TARGET)$(LOCALBASE)/lib - LIBSPEEX+=-lspeex -lm ++ LIBSPEEX+=-lspeex -lspeexdsp -lm endif + ifneq ($(wildcard ilbc/iLBC_decode.h),) @@ -78,7 +78,7 @@ LIBLPC10=lpc10/liblpc10.a diff --git a/net/asterisk12/files/patch-codecs_ilbc b/net/asterisk12/files/patch-codecs_ilbc new file mode 100644 index 000000000000..167707cd510d --- /dev/null +++ b/net/asterisk12/files/patch-codecs_ilbc @@ -0,0 +1,7194 @@ +diff -druN codecs/ilbc/FrameClassify.c codecs/ilbc/FrameClassify.c +--- codecs/ilbc/FrameClassify.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/FrameClassify.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,110 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ FrameClassify.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include "iLBC_define.h" ++#include "FrameClassify.h" ++ ++/*---------------------------------------------------------------* ++ * Classification of subframes to localize start state ++ *--------------------------------------------------------------*/ ++ ++int FrameClassify( /* index to the max-energy sub-frame */ ++ iLBC_Enc_Inst_t *iLBCenc_inst, ++ /* (i/o) the encoder state structure */ ++ float *residual /* (i) lpc residual signal */ ++) { ++ float max_ssqEn, fssqEn[NSUB_MAX], bssqEn[NSUB_MAX], *pp; ++ int n, l, max_ssqEn_n; ++ const float ssqEn_win[NSUB_MAX-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_MAX*sizeof(float)); ++ memset(bssqEn, 0, NSUB_MAX*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; lnsub-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; lnsub-1; ++ pp=residual+n*SUBL; ++ for (l=0; lmode==20) l=1; ++ else l=0; ++ ++ max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[l]; ++ max_ssqEn_n=1; ++ for (n=2; nnsub; n++) { ++ ++ l++; ++ ++ ++ if ((fssqEn[n-1]+bssqEn[n])*ssqEn_win[l] > max_ssqEn) { ++ max_ssqEn=(fssqEn[n-1]+bssqEn[n]) * ++ ssqEn_win[l]; ++ max_ssqEn_n=n; ++ } ++ } ++ ++ return max_ssqEn_n; ++} ++ ++ +diff -druN codecs/ilbc/FrameClassify.h codecs/ilbc/FrameClassify.h +--- codecs/ilbc/FrameClassify.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/FrameClassify.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,26 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ FrameClassify.h ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++ ++ ++#ifndef __iLBC_FRAMECLASSIFY_H ++#define __iLBC_FRAMECLASSIFY_H ++ ++int FrameClassify( /* index to the max-energy sub-frame */ ++ iLBC_Enc_Inst_t *iLBCenc_inst, ++ /* (i/o) the encoder state structure */ ++ float *residual /* (i) lpc residual signal */ ++); ++ ++#endif ++ ++ +diff -druN codecs/ilbc/LPCdecode.c codecs/ilbc/LPCdecode.c +--- codecs/ilbc/LPCdecode.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/LPCdecode.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,152 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ LPC_decode.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include ++#include ++ ++#include "helpfun.h" ++#include "lsf.h" ++#include "iLBC_define.h" ++#include "LPCdecode.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 lpc_n /* (i) number of LPCs */ ++){ ++ 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]; ++ } ++ ++ if (lpc_n>1) { ++ ++ /* 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; ++ ++ if (iLBCdec_inst->mode==30) { ++ /* sub-frame 1: Interpolation between old and first */ ++ ++ LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, lsfdeq, ++ lsf_weightTbl_30ms[0], length); ++ memcpy(syntdenum,lp,lp_length*sizeof(float)); ++ bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, ++ lp_length); ++ ++ /* sub-frames 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_30ms[i], length); ++ memcpy(syntdenum + pos,lp,lp_length*sizeof(float)); ++ bwexpand(weightdenum + pos, lp, ++ LPC_CHIRP_WEIGHTDENUM, lp_length); ++ pos += lp_length; ++ } ++ } ++ else { ++ pos = 0; ++ for (i = 0; i < iLBCdec_inst->nsub; i++) { ++ LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, ++ lsfdeq, lsf_weightTbl_20ms[i], length); ++ memcpy(syntdenum+pos,lp,lp_length*sizeof(float)); ++ bwexpand(weightdenum+pos, lp, LPC_CHIRP_WEIGHTDENUM, ++ lp_length); ++ pos += lp_length; ++ } ++ } ++ ++ /* update memory */ ++ ++ ++ ++ if (iLBCdec_inst->mode==30) ++ memcpy(iLBCdec_inst->lsfdeqold, lsfdeq2, ++ length*sizeof(float)); ++ else ++ memcpy(iLBCdec_inst->lsfdeqold, lsfdeq, ++ length*sizeof(float)); ++ ++} ++ ++ +diff -druN codecs/ilbc/LPCdecode.h codecs/ilbc/LPCdecode.h +--- codecs/ilbc/LPCdecode.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/LPCdecode.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,44 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ LPC_decode.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 */ ++ int lpc_n /* (i) number of LPCs */ ++); ++ ++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 -druN codecs/ilbc/LPCencode.c codecs/ilbc/LPCencode.c +--- codecs/ilbc/LPCencode.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/LPCencode.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,228 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ LPCencode.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include ++ ++ ++ ++#include "iLBC_define.h" ++#include "LPCencode.h" ++#include "helpfun.h" ++#include "lsf.h" ++#include "constants.h" ++ ++/*----------------------------------------------------------------* ++ * lpc analysis (subrutine to LPCencode) ++ *---------------------------------------------------------------*/ ++ ++static void SimpleAnalysis( ++ float *lsf, /* (o) lsf coefficients */ ++ float *data, /* (i) new data vector */ ++ iLBC_Enc_Inst_t *iLBCenc_inst ++ /* (i/o) the encoder state structure */ ++){ ++ int k, is; ++ float temp[BLOCKL_MAX], lp[LPC_FILTERORDER + 1]; ++ float lp2[LPC_FILTERORDER + 1]; ++ float r[LPC_FILTERORDER + 1]; ++ ++ is=LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl; ++ memcpy(iLBCenc_inst->lpc_buffer+is,data, ++ iLBCenc_inst->blockl*sizeof(float)); ++ ++ /* No lookahead, last window is asymmetric */ ++ ++ for (k = 0; k < iLBCenc_inst->lpc_n; k++) { ++ ++ is = LPC_LOOKBACK; ++ ++ if (k < (iLBCenc_inst->lpc_n - 1)) { ++ window(temp, lpc_winTbl, ++ iLBCenc_inst->lpc_buffer, BLOCKL_MAX); ++ } else { ++ window(temp, lpc_asymwinTbl, ++ iLBCenc_inst->lpc_buffer + is, BLOCKL_MAX); ++ } ++ ++ autocorr(r, temp, BLOCKL_MAX, LPC_FILTERORDER); ++ window(r, r, lpc_lagwinTbl, LPC_FILTERORDER + 1); ++ ++ levdurb(lp, temp, r, LPC_FILTERORDER); ++ bwexpand(lp2, lp, LPC_CHIRP_SYNTDENUM, LPC_FILTERORDER+1); ++ ++ a2lsf(lsf + k*LPC_FILTERORDER, lp2); ++ } ++ is=LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl; ++ memmove(iLBCenc_inst->lpc_buffer, ++ iLBCenc_inst->lpc_buffer+LPC_LOOKBACK+BLOCKL_MAX-is, ++ is*sizeof(float)); ++} ++ ++/*----------------------------------------------------------------* ++ ++ ++ * lsf interpolator and conversion from lsf to a coefficients ++ * (subrutine to SimpleInterpolateLSF) ++ *---------------------------------------------------------------*/ ++ ++static 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) ++ *---------------------------------------------------------------*/ ++ ++static void SimpleInterpolateLSF( ++ float *syntdenum, /* (o) the synthesis filter denominator ++ resulting from the quantized ++ interpolated lsf */ ++ float *weightdenum, /* (o) the weighting filter denominator ++ resulting from the unquantized ++ interpolated lsf */ ++ float *lsf, /* (i) the unquantized lsf coefficients */ ++ float *lsfdeq, /* (i) the dequantized lsf coefficients */ ++ float *lsfold, /* (i) the unquantized lsf coefficients of ++ the previous signal frame */ ++ float *lsfdeqold, /* (i) the dequantized lsf coefficients of ++ the previous signal frame */ ++ int length, /* (i) should equate LPC_FILTERORDER */ ++ iLBC_Enc_Inst_t *iLBCenc_inst ++ /* (i/o) the encoder state structure */ ++){ ++ int i, pos, lp_length; ++ float lp[LPC_FILTERORDER + 1], *lsf2, *lsfdeq2; ++ ++ lsf2 = lsf + length; ++ lsfdeq2 = lsfdeq + length; ++ lp_length = length + 1; ++ ++ if (iLBCenc_inst->mode==30) { ++ /* sub-frame 1: Interpolation between old and first ++ set of lsf coefficients */ ++ ++ LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq, ++ lsf_weightTbl_30ms[0], length); ++ memcpy(syntdenum,lp,lp_length*sizeof(float)); ++ LSFinterpolate2a_enc(lp, lsfold, lsf, ++ ++ ++ lsf_weightTbl_30ms[0], length); ++ bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length); ++ ++ /* sub-frame 2 to 6: Interpolation between first ++ and second set of lsf coefficients */ ++ ++ pos = lp_length; ++ for (i = 1; i < iLBCenc_inst->nsub; i++) { ++ LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq2, ++ lsf_weightTbl_30ms[i], length); ++ memcpy(syntdenum + pos,lp,lp_length*sizeof(float)); ++ ++ LSFinterpolate2a_enc(lp, lsf, lsf2, ++ lsf_weightTbl_30ms[i], length); ++ bwexpand(weightdenum + pos, lp, ++ LPC_CHIRP_WEIGHTDENUM, lp_length); ++ pos += lp_length; ++ } ++ } ++ else { ++ pos = 0; ++ for (i = 0; i < iLBCenc_inst->nsub; i++) { ++ LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq, ++ lsf_weightTbl_20ms[i], length); ++ memcpy(syntdenum+pos,lp,lp_length*sizeof(float)); ++ LSFinterpolate2a_enc(lp, lsfold, lsf, ++ lsf_weightTbl_20ms[i], length); ++ bwexpand(weightdenum+pos, lp, ++ LPC_CHIRP_WEIGHTDENUM, lp_length); ++ pos += lp_length; ++ } ++ } ++ ++ /* update memory */ ++ ++ if (iLBCenc_inst->mode==30) { ++ memcpy(lsfold, lsf2, length*sizeof(float)); ++ memcpy(lsfdeqold, lsfdeq2, length*sizeof(float)); ++ } ++ else { ++ memcpy(lsfold, lsf, length*sizeof(float)); ++ memcpy(lsfdeqold, lsfdeq, length*sizeof(float)); ++ } ++} ++ ++/*----------------------------------------------------------------* ++ * lsf quantizer (subrutine to LPCencode) ++ *---------------------------------------------------------------*/ ++ ++static void SimplelsfQ( ++ float *lsfdeq, /* (o) dequantized lsf coefficients ++ (dimension FILTERORDER) */ ++ int *index, /* (o) quantization index */ ++ float *lsf, /* (i) the lsf coefficient vector to be ++ ++ ++ quantized (dimension FILTERORDER ) */ ++ int lpc_n /* (i) number of lsf sets to quantize */ ++){ ++ /* Quantize first LSF with memoryless split VQ */ ++ SplitVQ(lsfdeq, index, lsf, lsfCbTbl, LSF_NSPLIT, ++ dim_lsfCbTbl, size_lsfCbTbl); ++ ++ if (lpc_n==2) { ++ /* Quantize second LSF with memoryless split VQ */ ++ SplitVQ(lsfdeq + LPC_FILTERORDER, index + LSF_NSPLIT, ++ lsf + LPC_FILTERORDER, lsfCbTbl, LSF_NSPLIT, ++ dim_lsfCbTbl, size_lsfCbTbl); ++ } ++} ++ ++/*----------------------------------------------------------------* ++ * lpc encoder ++ *---------------------------------------------------------------*/ ++ ++void LPCencode( ++ float *syntdenum, /* (i/o) synthesis filter coefficients ++ before/after encoding */ ++ float *weightdenum, /* (i/o) weighting denumerator ++ coefficients before/after ++ encoding */ ++ int *lsf_index, /* (o) lsf quantization index */ ++ float *data, /* (i) lsf coefficients to quantize */ ++ iLBC_Enc_Inst_t *iLBCenc_inst ++ /* (i/o) the encoder state structure */ ++){ ++ float lsf[LPC_FILTERORDER * LPC_N_MAX]; ++ float lsfdeq[LPC_FILTERORDER * LPC_N_MAX]; ++ int change=0; ++ ++ SimpleAnalysis(lsf, data, iLBCenc_inst); ++ SimplelsfQ(lsfdeq, lsf_index, lsf, iLBCenc_inst->lpc_n); ++ change=LSF_check(lsfdeq, LPC_FILTERORDER, iLBCenc_inst->lpc_n); ++ SimpleInterpolateLSF(syntdenum, weightdenum, ++ lsf, lsfdeq, iLBCenc_inst->lsfold, ++ iLBCenc_inst->lsfdeqold, LPC_FILTERORDER, iLBCenc_inst); ++} ++ ++ ++ +diff -druN codecs/ilbc/LPCencode.h codecs/ilbc/LPCencode.h +--- codecs/ilbc/LPCencode.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/LPCencode.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,29 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ LPCencode.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 -druN codecs/ilbc/StateConstructW.c codecs/ilbc/StateConstructW.c +--- codecs/ilbc/StateConstructW.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/StateConstructW.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,76 @@ ++ ++/****************************************************************** ++ ++ ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ StateConstructW.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include ++#include ++ ++#include "iLBC_define.h" ++#include "StateConstructW.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 ++#include ++ ++#include "iLBC_define.h" ++#include "StateSearchW.h" ++#include "constants.h" ++#include "filter.h" ++#include "helpfun.h" ++ ++/*----------------------------------------------------------------* ++ * predictive noise shaping encoding of scaled start state ++ * (subrutine for StateSearchW) ++ *---------------------------------------------------------------*/ ++ ++void AbsQuantW( ++ iLBC_Enc_Inst_t *iLBCenc_inst, ++ /* (i) Encoder instance */ ++ 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; ++ float syntOutBuf[LPC_FILTERORDER+STATE_SHORT_LEN_30MS]; ++ 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, ++ iLBCenc_inst->state_short_len-SUBL, ++ LPC_FILTERORDER); ++ } ++ ++ /* encoding loop */ ++ ++ for (n=0; nstate_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( ++ iLBC_Enc_Inst_t *iLBCenc_inst, ++ /* (i) Encoder instance */ ++ 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; ++ float tmpbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN_30MS]; ++ float *tmp, numerator[1+LPC_FILTERORDER]; ++ float foutbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN_30MS], *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 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 ++#include "anaFilter.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 ++#include ++ ++/*----------------------------------------------------------------* ++ * 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; k0.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) ++#include ++#include ++ ++#include "iLBC_define.h" ++#include "doCPLC.h" ++ ++/*----------------------------------------------------------------* ++ * Compute cross correlation and pitch gain for pitch prediction ++ * of last subframe at given lag. ++ *---------------------------------------------------------------*/ ++ ++static void compCorr( ++ float *cc, /* (o) cross correlation coefficient */ ++ float *gc, /* (o) gain */ ++ float *pm, ++ 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, ftmp3; ++ ++ /* Guard against getting outside buffer */ ++ if ((bLen-sRange-lag)<0) { ++ sRange=bLen-lag; ++ } ++ ++ ftmp1 = 0.0; ++ ftmp2 = 0.0; ++ ftmp3 = 0.0; ++ for (i=0; i 0.0) { ++ *cc = ftmp1*ftmp1/ftmp2; ++ *gc = (float)fabs(ftmp1/ftmp2); ++ *pm=(float)fabs(ftmp1)/ ++ ((float)sqrt(ftmp2)*(float)sqrt(ftmp3)); ++ } ++ else { ++ *cc = 0.0; ++ *gc = 0.0; ++ *pm=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 use_gain; ++ float gain_comp, maxcc_comp, per, max_per; ++ int i, pick, use_lag; ++ ++ ++ float ftmp, randvec[BLOCKL_MAX], pitchfact, energy; ++ ++ /* 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, &max_per, ++ iLBCdec_inst->prevResidual, ++ lag, iLBCdec_inst->blockl, 60); ++ for (i=inlag-2;i<=inlag+3;i++) { ++ compCorr(&maxcc_comp, &gain_comp, &per, ++ iLBCdec_inst->prevResidual, ++ i, iLBCdec_inst->blockl, 60); ++ ++ if (maxcc_comp>maxcc) { ++ maxcc=maxcc_comp; ++ gain=gain_comp; ++ lag=i; ++ max_per=per; ++ } ++ } ++ ++ } ++ ++ /* previous frame lost, use recorded lag and periodicity */ ++ ++ else { ++ lag=iLBCdec_inst->prevLag; ++ max_per=iLBCdec_inst->per; ++ } ++ ++ /* downscaling */ ++ ++ use_gain=1.0; ++ if (iLBCdec_inst->consPLICount*iLBCdec_inst->blockl>320) ++ use_gain=(float)0.9; ++ else if (iLBCdec_inst->consPLICount* ++ iLBCdec_inst->blockl>2*320) ++ use_gain=(float)0.7; ++ else if (iLBCdec_inst->consPLICount* ++ iLBCdec_inst->blockl>3*320) ++ use_gain=(float)0.5; ++ else if (iLBCdec_inst->consPLICount* ++ ++ ++ iLBCdec_inst->blockl>4*320) ++ use_gain=(float)0.0; ++ ++ /* mix noise and pitch repeatition */ ++ ftmp=(float)sqrt(max_per); ++ if (ftmp>(float)0.7) ++ pitchfact=(float)1.0; ++ else if (ftmp>(float)0.4) ++ pitchfact=(ftmp-(float)0.4)/((float)0.7-(float)0.4); ++ else ++ pitchfact=0.0; ++ ++ ++ /* avoid repetition of same pitch cycle */ ++ use_lag=lag; ++ if (lag<80) { ++ use_lag=2*lag; ++ } ++ ++ /* compute concealed residual */ ++ ++ energy = 0.0; ++ for (i=0; iblockl; 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] = ++ iLBCdec_inst->prevResidual[ ++ iLBCdec_inst->blockl+pick]; ++ } else { ++ randvec[i] = randvec[pick]; ++ } ++ ++ /* pitch repeatition component */ ++ pick = i - use_lag; ++ ++ if (pick < 0) { ++ PLCresidual[i] = ++ iLBCdec_inst->prevResidual[ ++ iLBCdec_inst->blockl+pick]; ++ } else { ++ PLCresidual[i] = PLCresidual[pick]; ++ } ++ ++ /* mix random and periodicity component */ ++ ++ if (i<80) ++ PLCresidual[i] = use_gain*(pitchfact * ++ ++ ++ PLCresidual[i] + ++ ((float)1.0 - pitchfact) * randvec[i]); ++ else if (i<160) ++ PLCresidual[i] = (float)0.95*use_gain*(pitchfact * ++ PLCresidual[i] + ++ ((float)1.0 - pitchfact) * randvec[i]); ++ else ++ PLCresidual[i] = (float)0.9*use_gain*(pitchfact * ++ PLCresidual[i] + ++ ((float)1.0 - pitchfact) * randvec[i]); ++ ++ energy += PLCresidual[i] * PLCresidual[i]; ++ } ++ ++ /* less than 30 dB, use only noise */ ++ ++ if (sqrt(energy/(float)iLBCdec_inst->blockl) < 30.0) { ++ gain=0.0; ++ for (i=0; iblockl; i++) { ++ PLCresidual[i] = randvec[i]; ++ } ++ } ++ ++ /* use old LPC */ ++ ++ memcpy(PLClpc,iLBCdec_inst->prevLpc, ++ (LPC_FILTERORDER+1)*sizeof(float)); ++ ++ } ++ ++ /* no packet loss, copy input */ ++ ++ else { ++ memcpy(PLCresidual, decresidual, ++ iLBCdec_inst->blockl*sizeof(float)); ++ memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float)); ++ iLBCdec_inst->consPLICount = 0; ++ } ++ ++ /* update state */ ++ ++ if (PLI) { ++ iLBCdec_inst->prevLag = lag; ++ iLBCdec_inst->per=max_per; ++ } ++ ++ iLBCdec_inst->prevPLI = PLI; ++ memcpy(iLBCdec_inst->prevLpc, PLClpc, ++ (LPC_FILTERORDER+1)*sizeof(float)); ++ memcpy(iLBCdec_inst->prevResidual, PLCresidual, ++ iLBCdec_inst->blockl*sizeof(float)); ++} ++ ++ ++ ++ +diff -druN codecs/ilbc/doCPLC.h codecs/ilbc/doCPLC.h +--- codecs/ilbc/doCPLC.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/doCPLC.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,32 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ doCPLC.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 -druN codecs/ilbc/enhancer.c codecs/ilbc/enhancer.c +--- codecs/ilbc/enhancer.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/enhancer.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,665 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ enhancer.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include ++#include ++#include "iLBC_define.h" ++#include "enhancer.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 ++ *---------------------------------------------------------------*/ ++ ++static 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 dim1 ) { ++ hfl2=(int) (dim1/2); ++ for (j=0; j= 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; imaxv) { ++ 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 ++ *---------------------------------------------------------------*/ ++ ++static 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_MAX]; /* 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 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=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 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=0, ilag, i, ioffset; ++ float cc, maxcc; ++ float ftmp1, ftmp2; ++ float *inPtr, *enh_bufPtr1, *enh_bufPtr2; ++ float plc_pred[ENH_BLOCKL]; ++ ++ float lpState[6], downsampled[(ENH_NBLOCKS*ENH_BLOCKL+120)/2]; ++ int inLen=ENH_NBLOCKS*ENH_BLOCKL+120; ++ int start, plc_blockl, inlag; ++ ++ enh_buf=iLBCdec_inst->enh_buf; ++ enh_period=iLBCdec_inst->enh_period; ++ ++ memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl], ++ (ENH_BUFL-iLBCdec_inst->blockl)*sizeof(float)); ++ ++ memcpy(&enh_buf[ENH_BUFL-iLBCdec_inst->blockl], in, ++ iLBCdec_inst->blockl*sizeof(float)); ++ ++ if (iLBCdec_inst->mode==30) ++ plc_blockl=ENH_BLOCKL; ++ else ++ plc_blockl=40; ++ ++ /* when 20 ms frame, move processing one block */ ++ ioffset=0; ++ if (iLBCdec_inst->mode==20) ioffset=1; ++ ++ i=3-ioffset; ++ memmove(enh_period, &enh_period[i], ++ ++ ++ (ENH_NBLOCKS_TOT-i)*sizeof(float)); ++ ++ /* Set state information to the 6 samples right before ++ the samples to be downsampled. */ ++ ++ memcpy(lpState, ++ enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-126, ++ 6*sizeof(float)); ++ ++ /* Down sample a factor 2 to save computations */ ++ ++ DownSample(enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-120, ++ lpFilt_coefsTbl, inLen-ioffset*ENH_BLOCKL, ++ lpState, downsampled); ++ ++ /* Estimate the pitch in the down sampled domain. */ ++ for (iblock = 0; iblock maxcc) { ++ maxcc = cc; ++ lag = ilag; ++ } ++ } ++ ++ /* Store the estimated lag in the non-downsampled domain */ ++ enh_period[iblock+ENH_NBLOCKS_EXTRA+ioffset] = (float)lag*2; ++ ++ ++ } ++ ++ ++ /* PLC was performed on the previous packet */ ++ if (iLBCdec_inst->prev_enh_pl==1) { ++ ++ inlag=(int)enh_period[ENH_NBLOCKS_EXTRA+ioffset]; ++ ++ lag = inlag-1; ++ maxcc = xCorrCoef(in, in+lag, plc_blockl); ++ for (ilag=inlag; ilag<=inlag+1; ilag++) { ++ cc = xCorrCoef(in, in+ilag, plc_blockl); ++ ++ if (cc > maxcc) { ++ maxcc = cc; ++ lag = ilag; ++ } ++ } ++ ++ ++ ++ enh_period[ENH_NBLOCKS_EXTRA+ioffset-1]=(float)lag; ++ ++ /* compute new concealed residual for the old lookahead, ++ mix the forward PLC with a backward PLC from ++ the new frame */ ++ ++ inPtr=&in[lag-1]; ++ ++ enh_bufPtr1=&plc_pred[plc_blockl-1]; ++ ++ if (lag>plc_blockl) { ++ start=plc_blockl; ++ } else { ++ start=lag; ++ } ++ ++ for (isample = start; isample>0; isample--) { ++ *enh_bufPtr1-- = *inPtr--; ++ } ++ ++ enh_bufPtr2=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl]; ++ for (isample = (plc_blockl-1-lag); isample>=0; isample--) ++{ ++ *enh_bufPtr1-- = *enh_bufPtr2--; ++ } ++ ++ /* limit energy change */ ++ ftmp2=0.0; ++ ftmp1=0.0; ++ for (i=0;iblockl-i]* ++ enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i]; ++ ftmp1+=plc_pred[i]*plc_pred[i]; ++ } ++ ftmp1=(float)sqrt(ftmp1/(float)plc_blockl); ++ ftmp2=(float)sqrt(ftmp2/(float)plc_blockl); ++ if (ftmp1>(float)2.0*ftmp2 && ftmp1>0.0) { ++ for (i=0;iblockl]; ++ for (i=0; imode==20) { ++ /* Enhancer with 40 samples delay */ ++ for (iblock = 0; iblock<2; iblock++) { ++ enhancer(out+iblock*ENH_BLOCKL, enh_buf, ++ ENH_BUFL, (5+iblock)*ENH_BLOCKL+40, ++ ENH_ALPHA0, enh_period, enh_plocsTbl, ++ ENH_NBLOCKS_TOT); ++ } ++ } else if (iLBCdec_inst->mode==30) { ++ /* Enhancer with 80 samples delay */ ++ for (iblock = 0; iblock<3; 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 -druN codecs/ilbc/enhancer.h codecs/ilbc/enhancer.h +--- codecs/ilbc/enhancer.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/enhancer.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,33 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ enhancer.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 -druN codecs/ilbc/filter.c codecs/ilbc/filter.c +--- codecs/ilbc/filter.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/filter.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,168 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ filter.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++ ++ ++#include "iLBC_define.h" ++#include "filter.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 ++#include ++#include "constants.h" ++#include "gainquant.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 ++ ++/*----------------------------------------------------------------* ++ * 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 ++ ++#include "iLBC_define.h" ++#include "helpfun.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; nmaxlsf) { ++ lsf[pos]=maxlsf; ++ change=1; ++ } ++ } ++ } ++ } ++ ++ return change; ++} ++ ++ +diff -druN codecs/ilbc/helpfun.h codecs/ilbc/helpfun.h +--- codecs/ilbc/helpfun.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/helpfun.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,101 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ helpfun.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 -druN codecs/ilbc/hpInput.c codecs/ilbc/hpInput.c +--- codecs/ilbc/hpInput.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/hpInput.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,60 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ hpInput.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include "constants.h" ++#include "hpInput.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 ++ ++#include "iLBC_define.h" ++#include "iCBConstruct.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=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=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 1) { ++ for (k=1; k ++#include ++ ++#include "iLBC_define.h" ++#include "iCBSearch.h" ++#include "gainquant.h" ++#include "createCB.h" ++#include "filter.h" ++#include "constants.h" ++ ++/*----------------------------------------------------------------* ++ * Search routine for codebook encoding and gain quantization. ++ *---------------------------------------------------------------*/ ++ ++void iCBSearch( ++ iLBC_Enc_Inst_t *iLBCenc_inst, ++ /* (i) the encoder state structure */ ++ 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 sub-block 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; i0.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)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) 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 or 23 */ ++ ++ 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; j0.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) { ++ 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-iLBCenc_inst->state_short_len)) { ++ ++ if (index[stage] ++#include ++ ++#include "iLBC_define.h" ++#include "iLBC_decode.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 mode, /* (i) frame size mode */ ++ int use_enhancer /* (i) 1 to use enhancer ++ 0 to run without ++ enhancer */ ++){ ++ int i; ++ ++ iLBCdec_inst->mode = mode; ++ ++ if (mode==30) { ++ iLBCdec_inst->blockl = BLOCKL_30MS; ++ iLBCdec_inst->nsub = NSUB_30MS; ++ iLBCdec_inst->nasub = NASUB_30MS; ++ iLBCdec_inst->lpc_n = LPC_N_30MS; ++ ++ ++ iLBCdec_inst->no_of_bytes = NO_OF_BYTES_30MS; ++ iLBCdec_inst->no_of_words = NO_OF_WORDS_30MS; ++ iLBCdec_inst->state_short_len=STATE_SHORT_LEN_30MS; ++ /* ULP init */ ++ iLBCdec_inst->ULP_inst=&ULP_30msTbl; ++ } ++ else if (mode==20) { ++ iLBCdec_inst->blockl = BLOCKL_20MS; ++ iLBCdec_inst->nsub = NSUB_20MS; ++ iLBCdec_inst->nasub = NASUB_20MS; ++ iLBCdec_inst->lpc_n = LPC_N_20MS; ++ iLBCdec_inst->no_of_bytes = NO_OF_BYTES_20MS; ++ iLBCdec_inst->no_of_words = NO_OF_WORDS_20MS; ++ iLBCdec_inst->state_short_len=STATE_SHORT_LEN_20MS; ++ /* ULP init */ ++ iLBCdec_inst->ULP_inst=&ULP_20msTbl; ++ } ++ else { ++ exit(2); ++ } ++ ++ 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_MAX)*sizeof(float)); ++ for (i=0; iold_syntdenum[i*(LPC_FILTERORDER+1)]=1.0; ++ ++ iLBCdec_inst->last_lag = 20; ++ ++ iLBCdec_inst->prevLag = 120; ++ iLBCdec_inst->per = 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_MAX*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;ienh_period[i]=(float)40.0; ++ ++ iLBCdec_inst->prev_enh_pl = 0; ++ ++ return (iLBCdec_inst->blockl); ++} ++ ++ ++ ++/*----------------------------------------------------------------* ++ * frame residual decoder function (subrutine to iLBC_decode) ++ *---------------------------------------------------------------*/ ++ ++static void Decode( ++ iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state ++ structure */ ++ 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_MAX], mem[CB_MEML]; ++ int k, meml_gotten, Nfor, Nback, i; ++ int diff, start_pos; ++ int subcount, subframe; ++ ++ diff = STATE_LEN - iLBCdec_inst->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], iLBCdec_inst->state_short_len); ++ ++ ++ if (state_first) { /* put adaptive part in the end */ ++ ++ ++ ++ /* setup memory */ ++ ++ memset(mem, 0, ++ (CB_MEML-iLBCdec_inst->state_short_len)*sizeof(float)); ++ memcpy(mem+CB_MEML-iLBCdec_inst->state_short_len, ++ decresidual+start_pos, ++ iLBCdec_inst->state_short_len*sizeof(float)); ++ ++ /* construct decoded vector */ ++ ++ iCBConstruct( ++ &decresidual[start_pos+iLBCdec_inst->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; kstate_short_len)]; ++ } ++ ++ /* setup memory */ ++ ++ meml_gotten = iLBCdec_inst->state_short_len; ++ for (k=0; knsub-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 sub-frames to encode */ ++ ++ for (subframe=0; subframe 0 ) { ++ ++ /* setup memory */ ++ ++ meml_gotten = SUBL*(iLBCdec_inst->nsub+1-start); ++ ++ if ( meml_gotten > CB_MEML ) { ++ meml_gotten=CB_MEML; ++ } ++ for (k=0; k0) { /* the data are good */ ++ ++ /* decode data */ ++ ++ pbytes=bytes; ++ pos=0; ++ ++ /* Set everything to zero before decoding */ ++ ++ for (k=0; kstate_short_len; k++) { ++ idxVec[k]=0; ++ } ++ for (k=0; knasub; i++) { ++ for (k=0; knasub; i++) { ++ for (k=0; klpc_n; k++){ ++ unpack( &pbytes, &lastpart, ++ iLBCdec_inst->ULP_inst->lsf_bits[k][ulp], &pos); ++ packcombine(&lsf_i[k], lastpart, ++ iLBCdec_inst->ULP_inst->lsf_bits[k][ulp]); ++ } ++ ++ ++ ++ /* Start block info */ ++ ++ unpack( &pbytes, &lastpart, ++ iLBCdec_inst->ULP_inst->start_bits[ulp], &pos); ++ packcombine(&start, lastpart, ++ iLBCdec_inst->ULP_inst->start_bits[ulp]); ++ ++ unpack( &pbytes, &lastpart, ++ iLBCdec_inst->ULP_inst->startfirst_bits[ulp], &pos); ++ packcombine(&state_first, lastpart, ++ iLBCdec_inst->ULP_inst->startfirst_bits[ulp]); ++ ++ unpack( &pbytes, &lastpart, ++ iLBCdec_inst->ULP_inst->scale_bits[ulp], &pos); ++ packcombine(&idxForMax, lastpart, ++ iLBCdec_inst->ULP_inst->scale_bits[ulp]); ++ ++ for (k=0; kstate_short_len; k++) { ++ unpack( &pbytes, &lastpart, ++ iLBCdec_inst->ULP_inst->state_bits[ulp], &pos); ++ packcombine(idxVec+k, lastpart, ++ iLBCdec_inst->ULP_inst->state_bits[ulp]); ++ } ++ ++ /* 23/22 (20ms/30ms) sample block */ ++ ++ for (k=0; kULP_inst->extra_cb_index[k][ulp], ++ &pos); ++ packcombine(extra_cb_index+k, lastpart, ++ iLBCdec_inst->ULP_inst->extra_cb_index[k][ulp]); ++ } ++ for (k=0; kULP_inst->extra_cb_gain[k][ulp], ++ &pos); ++ packcombine(extra_gain_index+k, lastpart, ++ iLBCdec_inst->ULP_inst->extra_cb_gain[k][ulp]); ++ } ++ ++ /* The two/four (20ms/30ms) 40 sample sub-blocks */ ++ ++ for (i=0; inasub; i++) { ++ for (k=0; kULP_inst->cb_index[i][k][ulp], ++ &pos); ++ packcombine(cb_index+i*CB_NSTAGES+k, lastpart, ++ iLBCdec_inst->ULP_inst->cb_index[i][k][ulp]); ++ } ++ } ++ ++ for (i=0; inasub; i++) { ++ ++ ++ for (k=0; kULP_inst->cb_gain[i][k][ulp], ++ &pos); ++ packcombine(gain_index+i*CB_NSTAGES+k, lastpart, ++ iLBCdec_inst->ULP_inst->cb_gain[i][k][ulp]); ++ } ++ } ++ } ++ /* Extract last bit. If it is 1 this indicates an ++ empty/lost frame */ ++ unpack( &pbytes, &last_bit, 1, &pos); ++ ++ /* Check for bit errors or empty/lost frames */ ++ if (start<1) ++ mode = 0; ++ if (iLBCdec_inst->mode==20 && start>3) ++ mode = 0; ++ if (iLBCdec_inst->mode==30 && start>5) ++ mode = 0; ++ if (last_bit==1) ++ 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, iLBCdec_inst->lpc_n); ++ check=LSF_check(lsfdeq, LPC_FILTERORDER, ++ iLBCdec_inst->lpc_n); ++ DecoderInterpolateLSF(syntdenum, weightdenum, ++ lsfdeq, LPC_FILTERORDER, iLBCdec_inst); ++ ++ Decode(iLBCdec_inst, 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)*(iLBCdec_inst->nsub - 1), ++ (*iLBCdec_inst).last_lag, iLBCdec_inst); ++ ++ ++ memcpy(decresidual, PLCresidual, ++ iLBCdec_inst->blockl*sizeof(float)); ++ } ++ ++ ++ ++ } ++ ++ if (mode == 0) { ++ /* the data is bad (either a PLC call ++ * was made or a severe bit error was detected) ++ */ ++ ++ /* packet loss conceal */ ++ ++ memset(zeros, 0, BLOCKL_MAX*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, ++ iLBCdec_inst->blockl*sizeof(float)); ++ ++ order_plus_one = LPC_FILTERORDER + 1; ++ for (i = 0; i < iLBCdec_inst->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 */ ++ ++ if (iLBCdec_inst->mode==20) { ++ /* Enhancer has 40 samples delay */ ++ i=0; ++ syntFilter(data + i*SUBL, ++ iLBCdec_inst->old_syntdenum + ++ (i+iLBCdec_inst->nsub-1)*(LPC_FILTERORDER+1), ++ SUBL, iLBCdec_inst->syntMem); ++ for (i=1; i < iLBCdec_inst->nsub; i++) { ++ syntFilter(data + i*SUBL, ++ syntdenum + (i-1)*(LPC_FILTERORDER+1), ++ SUBL, iLBCdec_inst->syntMem); ++ } ++ } else if (iLBCdec_inst->mode==30) { ++ /* Enhancer has 80 samples delay */ ++ for (i=0; i < 2; i++) { ++ syntFilter(data + i*SUBL, ++ ++ ++ iLBCdec_inst->old_syntdenum + ++ (i+iLBCdec_inst->nsub-2)*(LPC_FILTERORDER+1), ++ SUBL, iLBCdec_inst->syntMem); ++ } ++ for (i=2; i < iLBCdec_inst->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_MAX-ENH_BLOCKL], ++ &decresidual[BLOCKL_MAX-ENH_BLOCKL-lag], ENH_BLOCKL); ++ ++ for (ilag=21; ilag<120; ilag++) { ++ cc = xCorrCoef(&decresidual[BLOCKL_MAX-ENH_BLOCKL], ++ &decresidual[BLOCKL_MAX-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, ++ iLBCdec_inst->blockl*sizeof(float)); ++ for (i=0; i < iLBCdec_inst->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, iLBCdec_inst->blockl, ++ decblock,iLBCdec_inst->hpomem); ++ ++ /* memcpy(decblock,data,iLBCdec_inst->blockl*sizeof(float));*/ ++ ++ memcpy(iLBCdec_inst->old_syntdenum, syntdenum, ++ ++ iLBCdec_inst->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 -druN codecs/ilbc/iLBC_decode.h codecs/ilbc/iLBC_decode.h +--- codecs/ilbc/iLBC_decode.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/iLBC_decode.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,40 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ iLBC_decode.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 mode, /* (i) frame size mode */ ++ 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 -druN codecs/ilbc/iLBC_define.h codecs/ilbc/iLBC_define.h +--- codecs/ilbc/iLBC_define.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/iLBC_define.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,201 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ iLBC_define.h ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++#include ++ ++#ifndef __iLBC_ILBCDEFINE_H ++#define __iLBC_ILBCDEFINE_H ++ ++/* general codec settings */ ++ ++#define FS (float)8000.0 ++#define BLOCKL_20MS 160 ++#define BLOCKL_30MS 240 ++#define BLOCKL_MAX 240 ++#define NSUB_20MS 4 ++#define NSUB_30MS 6 ++#define NSUB_MAX 6 ++#define NASUB_20MS 2 ++#define NASUB_30MS 4 ++#define NASUB_MAX 4 ++#define SUBL 40 ++#define STATE_LEN 80 ++#define STATE_SHORT_LEN_30MS 58 ++#define STATE_SHORT_LEN_20MS 57 ++ ++/* 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_20MS 1 ++#define LPC_N_30MS 2 ++#define LPC_N_MAX 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_MAX/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 ++ ++/* Down sampling */ ++ ++#define FILTERORDER_DS 7 ++#define DELAY_DS 3 ++#define FACTOR_DS 2 ++ ++/* bit stream defs */ ++ ++#define NO_OF_BYTES_20MS 38 ++#define NO_OF_BYTES_30MS 50 ++#define NO_OF_WORDS_20MS 19 ++#define NO_OF_WORDS_30MS 25 ++#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_ULP_Inst_t_ { ++ int lsf_bits[6][ULP_CLASSES+2]; ++ int start_bits[ULP_CLASSES+2]; ++ int startfirst_bits[ULP_CLASSES+2]; ++ int scale_bits[ULP_CLASSES+2]; ++ int state_bits[ULP_CLASSES+2]; ++ int extra_cb_index[CB_NSTAGES][ULP_CLASSES+2]; ++ int extra_cb_gain[CB_NSTAGES][ULP_CLASSES+2]; ++ int cb_index[NSUB_MAX][CB_NSTAGES][ULP_CLASSES+2]; ++ int cb_gain[NSUB_MAX][CB_NSTAGES][ULP_CLASSES+2]; ++} iLBC_ULP_Inst_t; ++ ++/* type definition encoder instance */ ++typedef struct iLBC_Enc_Inst_t_ { ++ ++ /* flag for frame size mode */ ++ int mode; ++ ++ /* basic parameters for different frame sizes */ ++ int blockl; ++ int nsub; ++ int nasub; ++ int no_of_bytes, no_of_words; ++ int lpc_n; ++ int state_short_len; ++ const iLBC_ULP_Inst_t *ULP_inst; ++ ++ /* 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_MAX]; ++ ++ /* state of input HP filter */ ++ float hpimem[4]; ++ ++} iLBC_Enc_Inst_t; ++ ++/* type definition decoder instance */ ++typedef struct iLBC_Dec_Inst_t_ { ++ ++ ++ /* flag for frame size mode */ ++ int mode; ++ ++ /* basic parameters for different frame sizes */ ++ int blockl; ++ int nsub; ++ int nasub; ++ int no_of_bytes, no_of_words; ++ int lpc_n; ++ int state_short_len; ++ const iLBC_ULP_Inst_t *ULP_inst; ++ ++ /* 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 prevLpc[LPC_FILTERORDER+1]; ++ float prevResidual[NSUB_MAX*SUBL]; ++ float per; ++ unsigned long seed; ++ ++ /* previous synthesis filter parameters */ ++ float old_syntdenum[(LPC_FILTERORDER + 1)*NSUB_MAX]; ++ ++ /* 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 -druN codecs/ilbc/iLBC_encode.c codecs/ilbc/iLBC_encode.c +--- codecs/ilbc/iLBC_encode.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/iLBC_encode.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,514 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ iLBC_encode.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include ++#include ++#include ++ ++#include "iLBC_define.h" ++#include "iLBC_encode.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 */ ++ int mode /* (i) frame size mode */ ++){ ++ iLBCenc_inst->mode = mode; ++ if (mode==30) { ++ iLBCenc_inst->blockl = BLOCKL_30MS; ++ iLBCenc_inst->nsub = NSUB_30MS; ++ ++ ++ iLBCenc_inst->nasub = NASUB_30MS; ++ iLBCenc_inst->lpc_n = LPC_N_30MS; ++ iLBCenc_inst->no_of_bytes = NO_OF_BYTES_30MS; ++ iLBCenc_inst->no_of_words = NO_OF_WORDS_30MS; ++ iLBCenc_inst->state_short_len=STATE_SHORT_LEN_30MS; ++ /* ULP init */ ++ iLBCenc_inst->ULP_inst=&ULP_30msTbl; ++ } ++ else if (mode==20) { ++ iLBCenc_inst->blockl = BLOCKL_20MS; ++ iLBCenc_inst->nsub = NSUB_20MS; ++ iLBCenc_inst->nasub = NASUB_20MS; ++ iLBCenc_inst->lpc_n = LPC_N_20MS; ++ iLBCenc_inst->no_of_bytes = NO_OF_BYTES_20MS; ++ iLBCenc_inst->no_of_words = NO_OF_WORDS_20MS; ++ iLBCenc_inst->state_short_len=STATE_SHORT_LEN_20MS; ++ /* ULP init */ ++ iLBCenc_inst->ULP_inst=&ULP_20msTbl; ++ } ++ else { ++ exit(2); ++ } ++ ++ 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+BLOCKL_MAX)*sizeof(float)); ++ memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float)); ++ ++ return (iLBCenc_inst->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_MAX]; ++ float residual[BLOCKL_MAX], reverseResidual[BLOCKL_MAX]; ++ ++ int start, idxForMax, idxVec[STATE_LEN]; ++ float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML]; ++ int n, k, meml_gotten, Nfor, Nback, i, pos; ++ ++ ++ int gain_index[CB_NSTAGES*NASUB_MAX], ++ extra_gain_index[CB_NSTAGES]; ++ int cb_index[CB_NSTAGES*NASUB_MAX],extra_cb_index[CB_NSTAGES]; ++ int lsf_i[LSF_NSPLIT*LPC_N_MAX]; ++ 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_MAX*(LPC_FILTERORDER+1)]; ++ float weightdenum[NSUB_MAX*(LPC_FILTERORDER+1)]; ++ float decresidual[BLOCKL_MAX]; ++ ++ /* high pass filtering of input signal if such is not done ++ prior to calling this function */ ++ ++ hpInput(block, iLBCenc_inst->blockl, ++ data, (*iLBCenc_inst).hpimem); ++ ++ /* otherwise simply copy */ ++ ++ /*memcpy(data,block,iLBCenc_inst->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; nnsub; n++) { ++ anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)], ++ SUBL, &residual[n*SUBL], iLBCenc_inst->anaMem); ++ } ++ ++ /* find state location */ ++ ++ start = FrameClassify(iLBCenc_inst, residual); ++ ++ /* check if state should be in first or last part of the ++ two subframes */ ++ ++ diff = STATE_LEN - iLBCenc_inst->state_short_len; ++ en1 = 0; ++ index = (start-1)*SUBL; ++ for (i = 0; i < iLBCenc_inst->state_short_len; i++) { ++ en1 += residual[index+i]*residual[index+i]; ++ } ++ en2 = 0; ++ index = (start-1)*SUBL+diff; ++ for (i = 0; i < iLBCenc_inst->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(iLBCenc_inst, &residual[start_pos], ++ &syntdenum[(start-1)*(LPC_FILTERORDER+1)], ++ &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax, ++ idxVec, iLBCenc_inst->state_short_len, state_first); ++ ++ StateConstructW(idxForMax, idxVec, ++ &syntdenum[(start-1)*(LPC_FILTERORDER+1)], ++ &decresidual[start_pos], iLBCenc_inst->state_short_len); ++ ++ /* predictive quantization in state */ ++ ++ if (state_first) { /* put adaptive part in the end */ ++ ++ /* setup memory */ ++ ++ memset(mem, 0, ++ (CB_MEML-iLBCenc_inst->state_short_len)*sizeof(float)); ++ memcpy(mem+CB_MEML-iLBCenc_inst->state_short_len, ++ decresidual+start_pos, ++ iLBCenc_inst->state_short_len*sizeof(float)); ++ memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); ++ ++ /* encode sub-frames */ ++ ++ iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index, ++ &residual[start_pos+iLBCenc_inst->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+iLBCenc_inst->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; kstate_short_len)]; ++ } ++ ++ /* setup memory */ ++ ++ meml_gotten = iLBCenc_inst->state_short_len; ++ for (k=0; knsub-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 sub-frames to encode */ ++ ++ for (subframe=0; subframe 0 ) { ++ ++ /* create reverse order vectors */ ++ ++ for (n=0; nnsub+1-start); ++ ++ ++ if ( meml_gotten > CB_MEML ) { ++ meml_gotten=CB_MEML; ++ } ++ for (k=0; klpc_n; k++) { ++ packsplit(&lsf_i[k], &firstpart, &lsf_i[k], ++ iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], ++ iLBCenc_inst->ULP_inst->lsf_bits[k][ulp]+ ++ iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+1]+ ++ iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], &pos); ++ } ++ ++ /* Start block info */ ++ ++ packsplit(&start, &firstpart, &start, ++ iLBCenc_inst->ULP_inst->start_bits[ulp], ++ iLBCenc_inst->ULP_inst->start_bits[ulp]+ ++ iLBCenc_inst->ULP_inst->start_bits[ulp+1]+ ++ iLBCenc_inst->ULP_inst->start_bits[ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->start_bits[ulp], &pos); ++ ++ packsplit(&state_first, &firstpart, &state_first, ++ iLBCenc_inst->ULP_inst->startfirst_bits[ulp], ++ iLBCenc_inst->ULP_inst->startfirst_bits[ulp]+ ++ iLBCenc_inst->ULP_inst->startfirst_bits[ulp+1]+ ++ iLBCenc_inst->ULP_inst->startfirst_bits[ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->startfirst_bits[ulp], &pos); ++ ++ packsplit(&idxForMax, &firstpart, &idxForMax, ++ iLBCenc_inst->ULP_inst->scale_bits[ulp], ++ iLBCenc_inst->ULP_inst->scale_bits[ulp]+ ++ iLBCenc_inst->ULP_inst->scale_bits[ulp+1]+ ++ iLBCenc_inst->ULP_inst->scale_bits[ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->scale_bits[ulp], &pos); ++ ++ ++ ++ for (k=0; kstate_short_len; k++) { ++ packsplit(idxVec+k, &firstpart, idxVec+k, ++ iLBCenc_inst->ULP_inst->state_bits[ulp], ++ iLBCenc_inst->ULP_inst->state_bits[ulp]+ ++ iLBCenc_inst->ULP_inst->state_bits[ulp+1]+ ++ iLBCenc_inst->ULP_inst->state_bits[ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->state_bits[ulp], &pos); ++ } ++ ++ /* 23/22 (20ms/30ms) sample block */ ++ ++ for (k=0;kULP_inst->extra_cb_index[k][ulp], ++ iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp]+ ++ iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+1]+ ++ iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], ++ &pos); ++ } ++ ++ for (k=0;kULP_inst->extra_cb_gain[k][ulp], ++ iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp]+ ++ iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+1]+ ++ iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], ++ &pos); ++ } ++ ++ /* The two/four (20ms/30ms) 40 sample sub-blocks */ ++ ++ for (i=0; inasub; i++) { ++ for (k=0; kULP_inst->cb_index[i][k][ulp], ++ iLBCenc_inst->ULP_inst->cb_index[i][k][ulp]+ ++ iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+1]+ ++ iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], ++ &pos); ++ } ++ } ++ ++ for (i=0; inasub; i++) { ++ for (k=0; kULP_inst->cb_gain[i][k][ulp], ++ iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp]+ ++ iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+1]+ ++ iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+2]); ++ dopack( &pbytes, firstpart, ++ iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], ++ &pos); ++ } ++ } ++ } ++ ++ /* set the last bit to zero (otherwise the decoder ++ will treat it as a lost frame) */ ++ dopack( &pbytes, 0, 1, &pos); ++} ++ ++ ++ +diff -druN codecs/ilbc/iLBC_encode.h codecs/ilbc/iLBC_encode.h +--- codecs/ilbc/iLBC_encode.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/iLBC_encode.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,37 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ iLBC_encode.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 */ ++ int mode /* (i) frame size mode */ ++); ++ ++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 -druN codecs/ilbc/lsf.c codecs/ilbc/lsf.c +--- codecs/ilbc/lsf.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/lsf.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,264 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ lsf.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include ++#include ++ ++#include "iLBC_define.h" ++#include "lsf.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= 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= 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 ++#include ++ ++#include "iLBC_define.h" ++#include "constants.h" ++#include "helpfun.h" ++#include "packing.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<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 -druN codecs/ilbc/packing.h codecs/ilbc/packing.h +--- codecs/ilbc/packing.h 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/packing.h 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,67 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ packing.h ++ ++ Copyright (C) The Internet Society (2004). ++ 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 -druN codecs/ilbc/syntFilter.c codecs/ilbc/syntFilter.c +--- codecs/ilbc/syntFilter.c 1969-12-31 16:00:00.000000000 -0800 ++++ codecs/ilbc/syntFilter.c 2005-11-29 10:24:39.000000000 -0800 +@@ -0,0 +1,108 @@ ++ ++/****************************************************************** ++ ++ iLBC Speech Coder ANSI-C Source Code ++ ++ syntFilter.c ++ ++ Copyright (C) The Internet Society (2004). ++ All Rights Reserved. ++ ++******************************************************************/ ++ ++#include "iLBC_define.h" ++#include "syntFilter.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