From 46c6d062dd6503d6f491d26946d2099be7b9253b Mon Sep 17 00:00:00 2001 From: kpfleming Date: Wed, 26 Mar 2008 15:53:46 +0000 Subject: due to licensing restrictions, we cannot distribute the source code for iLBC encoding and decoding... so remove it, and add instructions on how the user can obtain it themselves git-svn-id: http://svn.digium.com/svn/asterisk/branches/1.2@110869 f38db490-d61c-443f-a65b-d21fe96a405b --- UPGRADE.txt | 18 ++ codecs/ilbc/FrameClassify.c | 110 ------- codecs/ilbc/FrameClassify.h | 26 -- codecs/ilbc/LPCdecode.c | 152 --------- codecs/ilbc/LPCdecode.h | 44 --- codecs/ilbc/LPCencode.c | 228 ------------- codecs/ilbc/LPCencode.h | 29 -- codecs/ilbc/StateConstructW.c | 76 ----- codecs/ilbc/StateConstructW.h | 27 -- codecs/ilbc/StateSearchW.c | 194 ----------- codecs/ilbc/StateSearchW.h | 48 --- codecs/ilbc/anaFilter.c | 71 ---- codecs/ilbc/anaFilter.h | 26 -- codecs/ilbc/constants.c | 729 ------------------------------------------ codecs/ilbc/constants.h | 74 ----- codecs/ilbc/createCB.c | 216 ------------- codecs/ilbc/createCB.h | 56 ---- codecs/ilbc/doCPLC.c | 259 --------------- codecs/ilbc/doCPLC.h | 32 -- codecs/ilbc/enhancer.c | 665 -------------------------------------- codecs/ilbc/enhancer.h | 33 -- codecs/ilbc/filter.c | 168 ---------- codecs/ilbc/filter.h | 73 ----- codecs/ilbc/gainquant.c | 107 ------- codecs/ilbc/gainquant.h | 31 -- codecs/ilbc/getCBvec.c | 181 ----------- codecs/ilbc/getCBvec.h | 28 -- codecs/ilbc/helpfun.c | 308 ------------------ codecs/ilbc/helpfun.h | 101 ------ codecs/ilbc/hpInput.c | 60 ---- codecs/ilbc/hpInput.h | 27 -- codecs/ilbc/hpOutput.c | 59 ---- codecs/ilbc/hpOutput.h | 25 -- codecs/ilbc/iCBConstruct.c | 108 ------- codecs/ilbc/iCBConstruct.h | 38 --- codecs/ilbc/iCBSearch.c | 480 --------------------------- codecs/ilbc/iCBSearch.h | 35 -- codecs/ilbc/iLBC_decode.c | 619 ----------------------------------- codecs/ilbc/iLBC_decode.h | 40 --- codecs/ilbc/iLBC_define.h | 201 ------------ codecs/ilbc/iLBC_encode.c | 514 ----------------------------- codecs/ilbc/iLBC_encode.h | 37 --- codecs/ilbc/lsf.c | 264 --------------- codecs/ilbc/lsf.h | 30 -- codecs/ilbc/packing.c | 175 ---------- codecs/ilbc/packing.h | 67 ---- codecs/ilbc/syntFilter.c | 108 ------- codecs/ilbc/syntFilter.h | 27 -- 48 files changed, 18 insertions(+), 7006 deletions(-) delete mode 100644 codecs/ilbc/FrameClassify.c delete mode 100644 codecs/ilbc/FrameClassify.h delete mode 100644 codecs/ilbc/LPCdecode.c delete mode 100644 codecs/ilbc/LPCdecode.h delete mode 100644 codecs/ilbc/LPCencode.c delete mode 100644 codecs/ilbc/LPCencode.h delete mode 100644 codecs/ilbc/StateConstructW.c delete mode 100644 codecs/ilbc/StateConstructW.h delete mode 100644 codecs/ilbc/StateSearchW.c delete mode 100644 codecs/ilbc/StateSearchW.h delete mode 100644 codecs/ilbc/anaFilter.c delete mode 100644 codecs/ilbc/anaFilter.h delete mode 100644 codecs/ilbc/constants.c delete mode 100644 codecs/ilbc/constants.h delete mode 100644 codecs/ilbc/createCB.c delete mode 100644 codecs/ilbc/createCB.h delete mode 100644 codecs/ilbc/doCPLC.c delete mode 100644 codecs/ilbc/doCPLC.h delete mode 100644 codecs/ilbc/enhancer.c delete mode 100644 codecs/ilbc/enhancer.h delete mode 100644 codecs/ilbc/filter.c delete mode 100644 codecs/ilbc/filter.h delete mode 100644 codecs/ilbc/gainquant.c delete mode 100644 codecs/ilbc/gainquant.h delete mode 100644 codecs/ilbc/getCBvec.c delete mode 100644 codecs/ilbc/getCBvec.h delete mode 100644 codecs/ilbc/helpfun.c delete mode 100644 codecs/ilbc/helpfun.h delete mode 100644 codecs/ilbc/hpInput.c delete mode 100644 codecs/ilbc/hpInput.h delete mode 100644 codecs/ilbc/hpOutput.c delete mode 100644 codecs/ilbc/hpOutput.h delete mode 100644 codecs/ilbc/iCBConstruct.c delete mode 100644 codecs/ilbc/iCBConstruct.h delete mode 100644 codecs/ilbc/iCBSearch.c delete mode 100644 codecs/ilbc/iCBSearch.h delete mode 100644 codecs/ilbc/iLBC_decode.c delete mode 100644 codecs/ilbc/iLBC_decode.h delete mode 100644 codecs/ilbc/iLBC_define.h delete mode 100644 codecs/ilbc/iLBC_encode.c delete mode 100644 codecs/ilbc/iLBC_encode.h delete mode 100644 codecs/ilbc/lsf.c delete mode 100644 codecs/ilbc/lsf.h delete mode 100644 codecs/ilbc/packing.c delete mode 100644 codecs/ilbc/packing.h delete mode 100644 codecs/ilbc/syntFilter.c delete mode 100644 codecs/ilbc/syntFilter.h diff --git a/UPGRADE.txt b/UPGRADE.txt index 76e557773..e4a78237a 100644 --- a/UPGRADE.txt +++ b/UPGRADE.txt @@ -203,3 +203,21 @@ GetVar Manager Action: This has been changed to a manner similar to the SetVar action and is now > Variable: name > Value: value + +iLBC Codec: + +* Previously, the Asterisk source code distribution included the iLBC + encoder/decoder source code, from Global IP Solutions + (http://www.gipscorp.com). This code is not licensed for + distribution, and thus has been removed from the Asterisk source + code distribution. If you wish to use codec_ilbc to support iLBC + channels in Asterisk, you must go to: + + http://ilbcfreeware.org + + and obtain the iLBC source code from that site, including agreeing + to the license agreement specified. The site has instructions on how + to extract the source code from the RFC file where it has been + published; after you have done that, copy the resulting *.c and *.h + files into the codecs/ilbc directory of the Asterisk source code + tree and follow your normal steps of building Asterisk. diff --git a/codecs/ilbc/FrameClassify.c b/codecs/ilbc/FrameClassify.c deleted file mode 100644 index c982fd667..000000000 --- a/codecs/ilbc/FrameClassify.c +++ /dev/null @@ -1,110 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/FrameClassify.h b/codecs/ilbc/FrameClassify.h deleted file mode 100644 index 35cbd325b..000000000 --- a/codecs/ilbc/FrameClassify.h +++ /dev/null @@ -1,26 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/LPCdecode.c b/codecs/ilbc/LPCdecode.c deleted file mode 100644 index f4bc9896d..000000000 --- a/codecs/ilbc/LPCdecode.c +++ /dev/null @@ -1,152 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/LPCdecode.h b/codecs/ilbc/LPCdecode.h deleted file mode 100644 index 1f55a622e..000000000 --- a/codecs/ilbc/LPCdecode.h +++ /dev/null @@ -1,44 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/LPCencode.c b/codecs/ilbc/LPCencode.c deleted file mode 100644 index 4d5fcff21..000000000 --- a/codecs/ilbc/LPCencode.c +++ /dev/null @@ -1,228 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/LPCencode.h b/codecs/ilbc/LPCencode.h deleted file mode 100644 index 5712163c2..000000000 --- a/codecs/ilbc/LPCencode.h +++ /dev/null @@ -1,29 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/StateConstructW.c b/codecs/ilbc/StateConstructW.c deleted file mode 100644 index e48fe035d..000000000 --- a/codecs/ilbc/StateConstructW.c +++ /dev/null @@ -1,76 +0,0 @@ - -/****************************************************************** - - - - 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 --git a/codecs/ilbc/doCPLC.h b/codecs/ilbc/doCPLC.h deleted file mode 100644 index a619f0def..000000000 --- a/codecs/ilbc/doCPLC.h +++ /dev/null @@ -1,32 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/enhancer.c b/codecs/ilbc/enhancer.c deleted file mode 100644 index 7c7829802..000000000 --- a/codecs/ilbc/enhancer.c +++ /dev/null @@ -1,665 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/enhancer.h b/codecs/ilbc/enhancer.h deleted file mode 100644 index aa37b1843..000000000 --- a/codecs/ilbc/enhancer.h +++ /dev/null @@ -1,33 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/filter.c b/codecs/ilbc/filter.c deleted file mode 100644 index f4ba63386..000000000 --- a/codecs/ilbc/filter.c +++ /dev/null @@ -1,168 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/helpfun.h b/codecs/ilbc/helpfun.h deleted file mode 100644 index 291a761d9..000000000 --- a/codecs/ilbc/helpfun.h +++ /dev/null @@ -1,101 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/hpInput.c b/codecs/ilbc/hpInput.c deleted file mode 100644 index 16b98f3df..000000000 --- a/codecs/ilbc/hpInput.c +++ /dev/null @@ -1,60 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/iLBC_decode.h b/codecs/ilbc/iLBC_decode.h deleted file mode 100644 index 0d5c905cd..000000000 --- a/codecs/ilbc/iLBC_decode.h +++ /dev/null @@ -1,40 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/iLBC_define.h b/codecs/ilbc/iLBC_define.h deleted file mode 100644 index 73a90ed66..000000000 --- a/codecs/ilbc/iLBC_define.h +++ /dev/null @@ -1,201 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/iLBC_encode.c b/codecs/ilbc/iLBC_encode.c deleted file mode 100644 index bd1496498..000000000 --- a/codecs/ilbc/iLBC_encode.c +++ /dev/null @@ -1,514 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/iLBC_encode.h b/codecs/ilbc/iLBC_encode.h deleted file mode 100644 index 3628e7545..000000000 --- a/codecs/ilbc/iLBC_encode.h +++ /dev/null @@ -1,37 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/lsf.c b/codecs/ilbc/lsf.c deleted file mode 100644 index 055c21cb5..000000000 --- a/codecs/ilbc/lsf.c +++ /dev/null @@ -1,264 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/packing.h b/codecs/ilbc/packing.h deleted file mode 100644 index ed114b1c1..000000000 --- a/codecs/ilbc/packing.h +++ /dev/null @@ -1,67 +0,0 @@ - -/****************************************************************** - - 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 --git a/codecs/ilbc/syntFilter.c b/codecs/ilbc/syntFilter.c deleted file mode 100644 index bb7f7a559..000000000 --- a/codecs/ilbc/syntFilter.c +++ /dev/null @@ -1,108 +0,0 @@ - -/****************************************************************** - - 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