[Asterisk-cvs] asterisk/codecs/ilbc FrameClassify.c, 1.2,
1.3 FrameClassify.h, 1.1, 1.2 LPCdecode.c, 1.2,
1.3 LPCdecode.h, 1.1, 1.2 LPCencode.c, 1.3, 1.4 LPCencode.h,
1.1, 1.2 StateConstructW.c, 1.2, 1.3 StateConstructW.h, 1.1,
1.2 StateSearchW.c, 1.2, 1.3 StateSearchW.h, 1.1,
1.2 anaFilter.c, 1.2, 1.3 anaFilter.h, 1.1, 1.2 constants.c,
1.1, 1.2 constants.h, 1.1, 1.2 createCB.c, 1.2, 1.3 createCB.h,
1.1, 1.2 doCPLC.c, 1.2, 1.3 doCPLC.h, 1.1, 1.2 enhancer.c, 1.2,
1.3 enhancer.h, 1.1, 1.2 filter.c, 1.2, 1.3 filter.h, 1.1,
1.2 gainquant.c, 1.2, 1.3 gainquant.h, 1.1, 1.2 getCBvec.c,
1.2, 1.3 getCBvec.h, 1.1, 1.2 helpfun.c, 1.3, 1.4 helpfun.h,
1.2, 1.3 hpInput.c, 1.2, 1.3 hpInput.h, 1.1, 1.2 hpOutput.c,
1.2, 1.3 hpOutput.h, 1.1, 1.2 iCBConstruct.c, 1.2,
1.3 iCBConstruct.h, 1.1, 1.2 iCBSearch.c, 1.4, 1.5 iCBSearch.h,
1.1, 1.2 iLBC_decode.c, 1.2, 1.3 iLBC_decode.h, 1.1,
1.2 iLBC_define.h, 1.1, 1.2 iLBC_encode.c, 1.2,
1.3 iLBC_encode.h, 1.1, 1.2 lsf.c, 1.2, 1.3 lsf.h, 1.1,
1.2 packing.c, 1.2, 1.3 packing.h, 1.1, 1.2 syntFilter.c, 1.2,
1.3 syntFilter.h, 1.1, 1.2
markster at lists.digium.com
markster at lists.digium.com
Thu Oct 14 01:15:29 CDT 2004
Update of /usr/cvsroot/asterisk/codecs/ilbc
In directory mongoose.digium.com:/tmp/cvs-serv9772/codecs/ilbc
Modified Files:
FrameClassify.c FrameClassify.h LPCdecode.c LPCdecode.h
LPCencode.c LPCencode.h StateConstructW.c StateConstructW.h
StateSearchW.c StateSearchW.h anaFilter.c anaFilter.h
constants.c constants.h createCB.c createCB.h doCPLC.c
doCPLC.h enhancer.c enhancer.h filter.c filter.h gainquant.c
gainquant.h getCBvec.c getCBvec.h helpfun.c helpfun.h
hpInput.c hpInput.h hpOutput.c hpOutput.h iCBConstruct.c
iCBConstruct.h iCBSearch.c iCBSearch.h iLBC_decode.c
iLBC_decode.h iLBC_define.h iLBC_encode.c iLBC_encode.h lsf.c
lsf.h packing.c packing.h syntFilter.c syntFilter.h
Log Message:
Update to new iLBC codec
Index: FrameClassify.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/FrameClassify.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- FrameClassify.c 15 Aug 2003 04:38:39 -0000 1.2
+++ FrameClassify.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,101 +1,109 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- FrameClassify.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- 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 */
- float *residual /* (i) lpc residual signal */
-){
- float max_ssqEn, fssqEn[NSUB], bssqEn[NSUB], *pp;
- int n, l, max_ssqEn_n;
- const float ssqEn_win[NSUB-1]={(float)0.8,(float)0.9,
- (float)1.0,(float)0.9,(float)0.8};
- const float sampEn_win[5]={(float)1.0/(float)6.0,
- (float)2.0/(float)6.0, (float)3.0/(float)6.0,
- (float)4.0/(float)6.0, (float)5.0/(float)6.0};
-
- /* init the front and back energies to zero */
-
- memset(fssqEn, 0, NSUB*sizeof(float));
- memset(bssqEn, 0, NSUB*sizeof(float));
-
- /* Calculate front of first seqence */
-
- n=0;
- pp=residual;
- for(l=0;l<5;l++){
- fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
- pp++;
- }
- for(l=5;l<SUBL;l++){
- fssqEn[n] += (*pp) * (*pp);
- pp++;
- }
-
- /* Calculate front and back of all middle sequences */
-
- for(n=1;n<NSUB-1;n++) {
- pp=residual+n*SUBL;
- for(l=0;l<5;l++){
- fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
- bssqEn[n] += (*pp) * (*pp);
- pp++;
- }
- for(l=5;l<SUBL-5;l++){
- fssqEn[n] += (*pp) * (*pp);
- bssqEn[n] += (*pp) * (*pp);
- pp++;
- }
- for(l=SUBL-5;l<SUBL;l++){
- fssqEn[n] += (*pp) * (*pp);
- bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
- pp++;
- }
- }
-
- /* Calculate back of last seqence */
-
- n=NSUB-1;
- pp=residual+n*SUBL;
- for(l=0;l<SUBL-5;l++){
- bssqEn[n] += (*pp) * (*pp);
- pp++;
- }
- for(l=SUBL-5;l<SUBL;l++){
- bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
- pp++;
- }
-
- /* find the index to the weighted 80 sample with
- most energy */
-
- max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[0];
- max_ssqEn_n=1;
- for (n=2;n<NSUB;n++) {
-
- if ((fssqEn[n-1]+bssqEn[n])*ssqEn_win[n-1] > max_ssqEn) {
- max_ssqEn=(fssqEn[n-1]+bssqEn[n]) *
- ssqEn_win[n-1];
- max_ssqEn_n=n;
- }
- }
-
- return max_ssqEn_n;
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ FrameClassify.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include "iLBC_define.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; l<SUBL; l++) {
+ fssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+
+ /* Calculate front and back of all middle sequences */
+
+ for (n=1; n<iLBCenc_inst->nsub-1; n++) {
+ pp=residual+n*SUBL;
+ for (l=0; l<5; l++) {
+ fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
+ bssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+ for (l=5; l<SUBL-5; l++) {
+ fssqEn[n] += (*pp) * (*pp);
+ bssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+ for (l=SUBL-5; l<SUBL; l++) {
+ fssqEn[n] += (*pp) * (*pp);
+ bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
+ pp++;
+ }
+ }
+
+ /* Calculate back of last seqence */
+
+ n=iLBCenc_inst->nsub-1;
+ pp=residual+n*SUBL;
+ for (l=0; l<SUBL-5; l++) {
+ bssqEn[n] += (*pp) * (*pp);
+ pp++;
+ }
+ for (l=SUBL-5; l<SUBL; l++) {
+ bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
+ pp++;
+ }
+
+ /* find the index to the weighted 80 sample with
+ most energy */
+
+ if (iLBCenc_inst->mode==20) l=1;
+ else l=0;
+
+ max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[l];
+ max_ssqEn_n=1;
+ for (n=2; n<iLBCenc_inst->nsub; 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;
+}
+
+
Index: FrameClassify.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/FrameClassify.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- FrameClassify.h 15 Apr 2003 04:36:52 -0000 1.1
+++ FrameClassify.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,23 +1,26 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- FrameClassify.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_FRAMECLASSIFY_H
-#define __iLBC_FRAMECLASSIFY_H
-
-int FrameClassify( /* Index to the max-energy sub frame */
- float *residual /* (i) lpc residual signal */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: LPCdecode.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/LPCdecode.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- LPCdecode.c 15 Aug 2003 04:38:39 -0000 1.2
+++ LPCdecode.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,122 +1,151 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- LPC_decode.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <string.h>
-
-#include "helpfun.h"
-#include "lsf.h"
-#include "iLBC_define.h"
-#include "constants.h"
-#include "LPCdecode.h"
-
-/*----------------------------------------------------------------*
- * interpolation of lsf coefficients for the decoder
- *---------------------------------------------------------------*/
-
-void LSFinterpolate2a_dec(
- float *a, /* (o) lpc coefficients for a sub frame */
- float *lsf1, /* (i) first lsf coefficient vector */
- float *lsf2, /* (i) second lsf coefficient vector */
- float coef, /* (i) interpolation weight */
- int length /* (i) length of lsf vectors */
-){
- float lsftmp[LPC_FILTERORDER];
-
- interpolate(lsftmp, lsf1, lsf2, coef, length);
- lsf2a(a, lsftmp);
-}
-
-/*----------------------------------------------------------------*
- * obtain dequantized lsf coefficients from quantization index
- *---------------------------------------------------------------*/
-
-void SimplelsfDEQ(
- float *lsfdeq, /* (o) dequantized lsf coefficients */
- int *index /* (i) quantization index */
-){
- int i,j, pos, cb_pos;
-
- /* decode first LSF */
-
- pos = 0;
- cb_pos = 0;
- for (i = 0; i < LSF_NSPLIT; i++) {
- for (j = 0; j < dim_lsfCbTbl[i]; j++) {
- lsfdeq[pos + j] = lsfCbTbl[cb_pos +
- (long)(index[i])*dim_lsfCbTbl[i] + j];
- }
- pos += dim_lsfCbTbl[i];
- cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i];
- }
-
- /* decode last LSF */
-
- pos = 0;
- cb_pos = 0;
- for (i = 0; i < LSF_NSPLIT; i++) {
- for (j = 0; j < dim_lsfCbTbl[i]; j++) {
- lsfdeq[LPC_FILTERORDER + pos + j] = lsfCbTbl[cb_pos +
- (long)(index[LSF_NSPLIT + i])*dim_lsfCbTbl[i] + j];
- }
- pos += dim_lsfCbTbl[i];
- cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i];
- }
-}
-
-/*----------------------------------------------------------------*
- * obtain synthesis and weighting filters form lsf coefficients
- *---------------------------------------------------------------*/
-
-void DecoderInterpolateLSF(
- float *syntdenum, /* (o) synthesis filter coefficients */
- float *weightdenum, /* (o) weighting denumerator
- coefficients */
- float *lsfdeq, /* (i) dequantized lsf coefficients */
- int length, /* (i) length of lsf coefficient vector */
- iLBC_Dec_Inst_t *iLBCdec_inst
- /* (i) the decoder state structure */
-){
- int i, pos, lp_length;
- float lp[LPC_FILTERORDER + 1], *lsfdeq2;
-
- lsfdeq2 = lsfdeq + length;
- lp_length = length + 1;
-
- /* subframe 1: Interpolation between old and first */
-
- LSFinterpolate2a_dec(lp, (*iLBCdec_inst).lsfdeqold, lsfdeq,
- lsf_weightTbl[0], length);
- memcpy(syntdenum,lp,lp_length*sizeof(float));
- bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
-
- /* subframes 2 to 6: interpolation between first and last
- LSF */
-
- pos = lp_length;
- for (i = 1; i < 6; i++) {
- LSFinterpolate2a_dec(lp, lsfdeq, lsfdeq2, lsf_weightTbl[i],
- length);
- memcpy(syntdenum + pos,lp,lp_length*sizeof(float));
- bwexpand(weightdenum + pos, lp,
- LPC_CHIRP_WEIGHTDENUM, lp_length);
- pos += lp_length;
- }
-
- /* update memory */
-
- memcpy((*iLBCdec_inst).lsfdeqold, lsfdeq2, length*sizeof(float));
-
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ LPC_decode.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "helpfun.h"
+#include "lsf.h"
+#include "iLBC_define.h"
+#include "constants.h"
+
+/*---------------------------------------------------------------*
+ * interpolation of lsf coefficients for the decoder
+ *--------------------------------------------------------------*/
+
+void LSFinterpolate2a_dec(
+ float *a, /* (o) lpc coefficients for a sub-frame */
+ float *lsf1, /* (i) first lsf coefficient vector */
+
+
+ float *lsf2, /* (i) second lsf coefficient vector */
+ float coef, /* (i) interpolation weight */
+ int length /* (i) length of lsf vectors */
+){
+ float lsftmp[LPC_FILTERORDER];
+
+ interpolate(lsftmp, lsf1, lsf2, coef, length);
+ lsf2a(a, lsftmp);
+}
+
+/*---------------------------------------------------------------*
+ * obtain dequantized lsf coefficients from quantization index
+ *--------------------------------------------------------------*/
+
+void SimplelsfDEQ(
+ float *lsfdeq, /* (o) dequantized lsf coefficients */
+ int *index, /* (i) quantization index */
+ int 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));
+
+}
+
+
Index: LPCdecode.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/LPCdecode.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- LPCdecode.h 15 Apr 2003 04:36:52 -0000 1.1
+++ LPCdecode.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,42 +1,44 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- LPC_decode.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_LPC_DECODE_H
-#define __iLBC_LPC_DECODE_H
-
-void LSFinterpolate2a_dec(
- float *a, /* (o) lpc coefficients for a sub frame */
- float *lsf1, /* (i) first lsf coefficient vector */
- float *lsf2, /* (i) second lsf coefficient vector */
- float coef, /* (i) interpolation weight */
- int length /* (i) length of lsf vectors */
-);
-
-void SimplelsfDEQ(
- float *lsfdeq, /* (o) dequantized lsf coefficients */
- int *index /* (i) quantization index */
-);
-
-void DecoderInterpolateLSF(
- float *syntdenum, /* (o) synthesis filter coefficients */
- float *weightdenum, /* (o) weighting denumerator
- coefficients */
- float *lsfdeq, /* (i) dequantized lsf coefficients */
- int length, /* (i) length of lsf coefficient vector */
- iLBC_Dec_Inst_t *iLBCdec_inst
- /* (i) the decoder state structure */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: LPCencode.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/LPCencode.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- LPCencode.c 15 Aug 2003 04:38:39 -0000 1.3
+++ LPCencode.c 14 Oct 2004 05:15:48 -0000 1.4
@@ -1,185 +1,227 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- LPCencode.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <string.h>
-
-#include "iLBC_define.h"
-#include "helpfun.h"
-#include "lsf.h"
-#include "constants.h"
-#include "LPCencode.h"
-
-/*----------------------------------------------------------------*
- * lpc analysis (subrutine to LPCencode)
- *---------------------------------------------------------------*/
-
-static void SimpleAnalysis(
- float *lsf, /* (o) lsf coefficients */
- float *data, /* (i) new data vector */
- float *lpc_buffer /* (i) buffer containing old data */
-){
- int k, is;
- float temp[BLOCKL], lp[LPC_FILTERORDER + 1];
- float lp2[LPC_FILTERORDER + 1];
- float r[LPC_FILTERORDER + 1];
-
- memcpy(lpc_buffer+LPC_LOOKBACK,data,BLOCKL*sizeof(float));
-
- /* No lookahead, last window is asymmetric */
-
- for (k = 0; k < LPC_N; k++) {
-
- is = LPC_LOOKBACK;
-
- if (k < (LPC_N - 1)) {
- lbc_window(temp, lpc_winTbl, lpc_buffer, BLOCKL);
- } else {
- lbc_window(temp, lpc_asymwinTbl, lpc_buffer + is, BLOCKL);
- }
-
- autocorr(r, temp, BLOCKL, LPC_FILTERORDER);
- lbc_window(r, r, lpc_lagwinTbl, LPC_FILTERORDER + 1);
-
- levdurb(lp, temp, r, LPC_FILTERORDER);
- bwexpand(lp2, lp, LPC_CHIRP_SYNTDENUM, LPC_FILTERORDER+1);
-
- a2lsf(lsf + k*LPC_FILTERORDER, lp2);
- }
- memcpy(lpc_buffer, lpc_buffer+BLOCKL,
- LPC_LOOKBACK*sizeof(float));
-}
-
-/*----------------------------------------------------------------*
- * lsf interpolator and conversion from lsf to a coefficients
- * (subrutine to SimpleInterpolateLSF)
- *---------------------------------------------------------------*/
-
-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 FILTERORDER */
-){
- int i, pos, lp_length;
- float lp[LPC_FILTERORDER + 1], *lsf2, *lsfdeq2;
-
- lsf2 = lsf + length;
- lsfdeq2 = lsfdeq + length;
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ LPCencode.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <string.h>
+
+
+
+#include "iLBC_define.h"
+#include "helpfun.h"
+#include "lsf.h"
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * lpc analysis (subrutine to LPCencode)
+ *---------------------------------------------------------------*/
+
+void SimpleAnalysis(
+ float *lsf, /* (o) lsf coefficients */
+ float *data, /* (i) new data vector */
+ iLBC_Enc_Inst_t *iLBCenc_inst
+ /* (i/o) the encoder state structure */
+){
+ int k, is;
+ float temp[BLOCKL_MAX], lp[LPC_FILTERORDER + 1];
+ float lp2[LPC_FILTERORDER + 1];
+ float r[LPC_FILTERORDER + 1];
+
+ is=LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl;
+ memcpy(iLBCenc_inst->lpc_buffer+is,data,
+ iLBCenc_inst->blockl*sizeof(float));
+
+ /* No lookahead, last window is asymmetric */
+
+ for (k = 0; k < iLBCenc_inst->lpc_n; k++) {
+
+ is = LPC_LOOKBACK;
+
+ if (k < (iLBCenc_inst->lpc_n - 1)) {
+ window(temp, lpc_winTbl,
+ iLBCenc_inst->lpc_buffer, BLOCKL_MAX);
+ } else {
+ window(temp, lpc_asymwinTbl,
+ iLBCenc_inst->lpc_buffer + is, BLOCKL_MAX);
+ }
+
+ autocorr(r, temp, BLOCKL_MAX, LPC_FILTERORDER);
+ window(r, r, lpc_lagwinTbl, LPC_FILTERORDER + 1);
+
+ levdurb(lp, temp, r, LPC_FILTERORDER);
+ bwexpand(lp2, lp, LPC_CHIRP_SYNTDENUM, LPC_FILTERORDER+1);
+
+ a2lsf(lsf + k*LPC_FILTERORDER, lp2);
+ }
+ is=LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl;
+ memmove(iLBCenc_inst->lpc_buffer,
+ iLBCenc_inst->lpc_buffer+LPC_LOOKBACK+BLOCKL_MAX-is,
+ is*sizeof(float));
+}
+
+/*----------------------------------------------------------------*
+
+
+ * lsf interpolator and conversion from lsf to a coefficients
+ * (subrutine to SimpleInterpolateLSF)
+ *---------------------------------------------------------------*/
+
+void LSFinterpolate2a_enc(
+ float *a, /* (o) lpc coefficients */
+ float *lsf1,/* (i) first set of lsf coefficients */
+ float *lsf2,/* (i) second set of lsf coefficients */
+ float coef, /* (i) weighting coefficient to use between
+ lsf1 and lsf2 */
+ long length /* (i) length of coefficient vectors */
+){
+ float lsftmp[LPC_FILTERORDER];
+
+ interpolate(lsftmp, lsf1, lsf2, coef, length);
+ lsf2a(a, lsftmp);
+}
+
+/*----------------------------------------------------------------*
+ * lsf interpolator (subrutine to LPCencode)
+ *---------------------------------------------------------------*/
+
+void SimpleInterpolateLSF(
+ float *syntdenum, /* (o) the synthesis filter denominator
+ resulting from the quantized
+ interpolated lsf */
+ float *weightdenum, /* (o) the weighting filter denominator
+ resulting from the unquantized
+ interpolated lsf */
+ float *lsf, /* (i) the unquantized lsf coefficients */
+ float *lsfdeq, /* (i) the dequantized lsf coefficients */
+ float *lsfold, /* (i) the unquantized lsf coefficients of
+ the previous signal frame */
+ float *lsfdeqold, /* (i) the dequantized lsf coefficients of
+ the previous signal frame */
+ int length, /* (i) should equate LPC_FILTERORDER */
+ iLBC_Enc_Inst_t *iLBCenc_inst
+ /* (i/o) the encoder state structure */
+){
+ int i, pos, lp_length;
+ float lp[LPC_FILTERORDER + 1], *lsf2, *lsfdeq2;
+
+ lsf2 = lsf + length;
+ lsfdeq2 = lsfdeq + length;
lp_length = length + 1;
-
- /* subframe 1: Interpolation between old and first set of
- lsf coefficients */
-
- LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
- lsf_weightTbl[0], length);
- memcpy(syntdenum,lp,lp_length*sizeof(float));
- LSFinterpolate2a_enc(lp, lsfold, lsf, lsf_weightTbl[0], length);
- bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
-
- /* subframe 2 to 6: Interpolation between first and second
- set of lsf coefficients */
-
- pos = lp_length;
- for (i = 1; i < NSUB; i++) {
- LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq2,
- lsf_weightTbl[i], length);
- memcpy(syntdenum + pos,lp,lp_length*sizeof(float));
-
- LSFinterpolate2a_enc(lp, lsf, lsf2,
- lsf_weightTbl[i], length);
- bwexpand(weightdenum + pos, lp,
- LPC_CHIRP_WEIGHTDENUM, lp_length);
- pos += lp_length;
- }
-
- /* update memory */
-
- memcpy(lsfold, lsf2, length*sizeof(float));
- memcpy(lsfdeqold, lsfdeq2, length*sizeof(float));
-}
-
-/*----------------------------------------------------------------*
- * lsf quantizer (subrutine to LPCencode)
- *---------------------------------------------------------------*/
-
-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 ) */
-){
- /* Quantize first LSF with memoryless split VQ */
- SplitVQ(lsfdeq, index, lsf, lsfCbTbl, LSF_NSPLIT,
- dim_lsfCbTbl, size_lsfCbTbl);
-
- /* Quantize second LSF with memoryless split VQ */
- SplitVQ(lsfdeq + LPC_FILTERORDER, index + LSF_NSPLIT,
- lsf + LPC_FILTERORDER, lsfCbTbl, LSF_NSPLIT,
- dim_lsfCbTbl, size_lsfCbTbl);
-}
-
-/*----------------------------------------------------------------*
- * lpc encoder
- *---------------------------------------------------------------*/
-
-void LPCencode(
- float *syntdenum, /* (i/o) synthesis filter coefficients
- before/after encoding */
- float *weightdenum, /* (i/o) weighting denumerator coefficients
- before/after encoding */
- int *lsf_index, /* (o) lsf quantization index */
- float *data, /* (i) lsf coefficients to quantize */
- iLBC_Enc_Inst_t *iLBCenc_inst
- /* (i/o) the encoder state structure */
-){
- float lsf[LPC_FILTERORDER * LPC_N];
- float lsfdeq[LPC_FILTERORDER * LPC_N];
- int change=0;
-
- SimpleAnalysis(lsf, data, (*iLBCenc_inst).lpc_buffer);
- SimplelsfQ(lsfdeq, lsf_index, lsf);
- change=LSF_check(lsfdeq, LPC_FILTERORDER, LPC_N);
- SimpleInterpolateLSF(syntdenum, weightdenum,
- lsf, lsfdeq, (*iLBCenc_inst).lsfold,
- (*iLBCenc_inst).lsfdeqold, LPC_FILTERORDER);
-}
-
+ if (iLBCenc_inst->mode==30) {
+ /* sub-frame 1: Interpolation between old and first
+ set of lsf coefficients */
+
+ LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
+ lsf_weightTbl_30ms[0], length);
+ memcpy(syntdenum,lp,lp_length*sizeof(float));
+ LSFinterpolate2a_enc(lp, lsfold, lsf,
+
+
+ lsf_weightTbl_30ms[0], length);
+ bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
+
+ /* sub-frame 2 to 6: Interpolation between first
+ and second set of lsf coefficients */
+
+ pos = lp_length;
+ for (i = 1; i < iLBCenc_inst->nsub; i++) {
+ LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq2,
+ lsf_weightTbl_30ms[i], length);
+ memcpy(syntdenum + pos,lp,lp_length*sizeof(float));
+
+ LSFinterpolate2a_enc(lp, lsf, lsf2,
+ lsf_weightTbl_30ms[i], length);
+ bwexpand(weightdenum + pos, lp,
+ LPC_CHIRP_WEIGHTDENUM, lp_length);
+ pos += lp_length;
+ }
+ }
+ else {
+ pos = 0;
+ for (i = 0; i < iLBCenc_inst->nsub; i++) {
+ LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
+ lsf_weightTbl_20ms[i], length);
+ memcpy(syntdenum+pos,lp,lp_length*sizeof(float));
+ LSFinterpolate2a_enc(lp, lsfold, lsf,
+ lsf_weightTbl_20ms[i], length);
+ bwexpand(weightdenum+pos, lp,
+ LPC_CHIRP_WEIGHTDENUM, lp_length);
+ pos += lp_length;
+ }
+ }
+
+ /* update memory */
+
+ if (iLBCenc_inst->mode==30) {
+ memcpy(lsfold, lsf2, length*sizeof(float));
+ memcpy(lsfdeqold, lsfdeq2, length*sizeof(float));
+ }
+ else {
+ memcpy(lsfold, lsf, length*sizeof(float));
+ memcpy(lsfdeqold, lsfdeq, length*sizeof(float));
+ }
+}
+
+/*----------------------------------------------------------------*
+ * lsf quantizer (subrutine to LPCencode)
+ *---------------------------------------------------------------*/
+
+void SimplelsfQ(
+ float *lsfdeq, /* (o) dequantized lsf coefficients
+ (dimension FILTERORDER) */
+ int *index, /* (o) quantization index */
+ float *lsf, /* (i) the lsf coefficient vector to be
+
+
+ quantized (dimension FILTERORDER ) */
+ int lpc_n /* (i) number of lsf sets to quantize */
+){
+ /* Quantize first LSF with memoryless split VQ */
+ SplitVQ(lsfdeq, index, lsf, lsfCbTbl, LSF_NSPLIT,
+ dim_lsfCbTbl, size_lsfCbTbl);
+
+ if (lpc_n==2) {
+ /* Quantize second LSF with memoryless split VQ */
+ SplitVQ(lsfdeq + LPC_FILTERORDER, index + LSF_NSPLIT,
+ lsf + LPC_FILTERORDER, lsfCbTbl, LSF_NSPLIT,
+ dim_lsfCbTbl, size_lsfCbTbl);
+ }
+}
+
+/*----------------------------------------------------------------*
+ * lpc encoder
+ *---------------------------------------------------------------*/
+
+void LPCencode(
+ float *syntdenum, /* (i/o) synthesis filter coefficients
+ before/after encoding */
+ float *weightdenum, /* (i/o) weighting denumerator
+ coefficients before/after
+ encoding */
+ int *lsf_index, /* (o) lsf quantization index */
+ float *data, /* (i) lsf coefficients to quantize */
+ iLBC_Enc_Inst_t *iLBCenc_inst
+ /* (i/o) the encoder state structure */
+){
+ float lsf[LPC_FILTERORDER * LPC_N_MAX];
+ float lsfdeq[LPC_FILTERORDER * LPC_N_MAX];
+ int change=0;
+
+ SimpleAnalysis(lsf, data, iLBCenc_inst);
+ SimplelsfQ(lsfdeq, lsf_index, lsf, iLBCenc_inst->lpc_n);
+ change=LSF_check(lsfdeq, LPC_FILTERORDER, iLBCenc_inst->lpc_n);
+ SimpleInterpolateLSF(syntdenum, weightdenum,
+ lsf, lsfdeq, iLBCenc_inst->lsfold,
+ iLBCenc_inst->lsfdeqold, LPC_FILTERORDER, iLBCenc_inst);
+}
+
+
+
Index: LPCencode.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/LPCencode.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- LPCencode.h 15 Apr 2003 04:36:52 -0000 1.1
+++ LPCencode.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,30 +1,29 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- LPCencode.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_LPCENCOD_H
-#define __iLBC_LPCENCOD_H
-
-void LPCencode(
- float *syntdenum, /* (i/o) synthesis filter coefficients
- before/after encoding */
- float *weightdenum, /* (i/o) weighting denumerator coefficients
- before/after encoding */
- int *lsf_index, /* (o) lsf quantization index */
- float *data, /* (i) lsf coefficients to quantize */
- iLBC_Enc_Inst_t *iLBCenc_inst
- /* (i/o) the encoder state structure */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: StateConstructW.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/StateConstructW.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- StateConstructW.c 15 Aug 2003 04:38:39 -0000 1.2
+++ StateConstructW.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,73 +1,75 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- StateConstructW.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <string.h>
-
-#include "iLBC_define.h"
-#include "constants.h"
-#include "filter.h"
-#include "StateConstructW.h"
-
-/*----------------------------------------------------------------*
- * decoding of the start state
- *---------------------------------------------------------------*/
-
-void StateConstructW(
- int idxForMax, /* (i) 6-bit index for the quantization of
- max amplitude */
- int *idxVec, /* (i) vector of quantization indexes */
- float *syntDenum, /* (i) synthesis filter denumerator */
- float *out, /* (o) the decoded state vector */
- int len /* (i) length of a state vector */
-){
- float maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_LEN], *tmp,
- numerator[LPC_FILTERORDER+1];
- float foutbuf[LPC_FILTERORDER+2*STATE_LEN], *fout;
- int k,tmpi;
-
- /* decoding of the maximum value */
-
- maxVal = state_frgqTbl[idxForMax];
- maxVal = (float)pow(10,maxVal)/(float)4.5;
-
- /* initialization of buffers and coefficients */
-
- memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
- memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
- for(k=0; k<LPC_FILTERORDER; k++){
- numerator[k]=syntDenum[LPC_FILTERORDER-k];
- }
- numerator[LPC_FILTERORDER]=syntDenum[0];
- tmp = &tmpbuf[LPC_FILTERORDER];
- fout = &foutbuf[LPC_FILTERORDER];
-
- /* decoding of the sample values */
-
- for(k=0; k<len; k++){
- tmpi = len-1-k;
- /* maxVal = 1/scal */
- tmp[k] = maxVal*state_sq3Tbl[idxVec[tmpi]];
- }
-
- /* circular convolution with all-pass filter */
-
- memset(tmp+len, 0, len*sizeof(float));
- ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
- LPC_FILTERORDER, fout);
- for(k=0;k<len;k++){
- out[k] = fout[len-1-k]+fout[2*len-1-k];
- }
-}
-
-
+
+/******************************************************************
+
+
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateConstructW.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include "filter.h"
+
+/*----------------------------------------------------------------*
+ * decoding of the start state
+ *---------------------------------------------------------------*/
+
+void StateConstructW(
+ int idxForMax, /* (i) 6-bit index for the quantization of
+ max amplitude */
+ int *idxVec, /* (i) vector of quantization indexes */
+ float *syntDenum, /* (i) synthesis filter denumerator */
+ float *out, /* (o) the decoded state vector */
+ int len /* (i) length of a state vector */
+){
+ float maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_LEN], *tmp,
+ numerator[LPC_FILTERORDER+1];
+ float foutbuf[LPC_FILTERORDER+2*STATE_LEN], *fout;
+ int k,tmpi;
+
+ /* decoding of the maximum value */
+
+ maxVal = state_frgqTbl[idxForMax];
+ maxVal = (float)pow(10,maxVal)/(float)4.5;
+
+ /* initialization of buffers and coefficients */
+
+ memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
+ memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
+ for (k=0; k<LPC_FILTERORDER; k++) {
+ numerator[k]=syntDenum[LPC_FILTERORDER-k];
+ }
+ numerator[LPC_FILTERORDER]=syntDenum[0];
+ tmp = &tmpbuf[LPC_FILTERORDER];
+ fout = &foutbuf[LPC_FILTERORDER];
+
+ /* decoding of the sample values */
+
+ for (k=0; k<len; k++) {
+ tmpi = len-1-k;
+ /* maxVal = 1/scal */
+
+
+ tmp[k] = maxVal*state_sq3Tbl[idxVec[tmpi]];
+ }
+
+ /* circular convolution with all-pass filter */
+
+ memset(tmp+len, 0, len*sizeof(float));
+ ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
+ LPC_FILTERORDER, fout);
+ for (k=0;k<len;k++) {
+ out[k] = fout[len-1-k]+fout[2*len-1-k];
+ }
+}
+
+
Index: StateConstructW.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/StateConstructW.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- StateConstructW.h 15 Apr 2003 04:36:52 -0000 1.1
+++ StateConstructW.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,28 +1,27 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- StateConstructW.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_STATECONSTRUCTW_H
-#define __iLBC_STATECONSTRUCTW_H
-
-void StateConstructW(
- int idxForMax, /* (i) 6-bit index for the quantization of
- max amplitude */
- int *idxVec, /* (i) vector of quantization indexes */
- float *syntDenum, /* (i) synthesis filter denumerator */
- float *out, /* (o) the decoded state vector */
- int len /* (i) length of a state vector */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateConstructW.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_STATECONSTRUCTW_H
+#define __iLBC_STATECONSTRUCTW_H
+
+void StateConstructW(
+ int idxForMax, /* (i) 6-bit index for the quantization of
+ max amplitude */
+ int *idxVec, /* (i) vector of quantization indexes */
+ float *syntDenum, /* (i) synthesis filter denumerator */
+ float *out, /* (o) the decoded state vector */
+ int len /* (i) length of a state vector */
+);
+
+#endif
+
+
Index: StateSearchW.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/StateSearchW.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- StateSearchW.c 15 Aug 2003 04:38:39 -0000 1.2
+++ StateSearchW.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,178 +1,193 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- StateSearchW.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <string.h>
-
-#include "iLBC_define.h"
-#include "constants.h"
-#include "filter.h"
-#include "helpfun.h"
-#include "StateSearchW.h"
-
-/*----------------------------------------------------------------*
- * predictive noise shaping encoding of scaled start state
- * (subrutine for StateSearchW)
- *---------------------------------------------------------------*/
-
-void AbsQuantW(
- float *in, /* (i) vector to encode */
- float *syntDenum, /* (i) denominator of synthesis filter */
- float *weightDenum, /* (i) denominator of weighting filter */
- int *out, /* (o) vector of quantizer indexes */
- int len, /* (i) length of vector to encode and
- vector of quantizer indexes */
- int state_first /* (i) position of start state in the
- 80 vec */
-){
- float *syntOut, syntOutBuf[LPC_FILTERORDER+STATE_SHORT_LEN];
- float toQ, xq;
- int n;
- int index;
-
- /* initialization of buffer for filtering */
-
- memset(syntOutBuf, 0, LPC_FILTERORDER*sizeof(float));
-
- /* initialization of pointer for filtering */
-
- syntOut = &syntOutBuf[LPC_FILTERORDER];
-
- /* synthesis and weighting filters on input */
-
- if (state_first) {
- AllPoleFilter (in, weightDenum, SUBL, LPC_FILTERORDER);
- } else {
- AllPoleFilter (in, weightDenum, STATE_SHORT_LEN-SUBL,
- LPC_FILTERORDER);
- }
-
- /* encoding loop */
-
- for(n=0;n<len;n++){
-
- /* time update of filter coefficients */
-
- if ((state_first)&&(n==SUBL)){
- syntDenum += (LPC_FILTERORDER+1);
- weightDenum += (LPC_FILTERORDER+1);
-
- /* synthesis and weighting filters on input */
- AllPoleFilter (&in[n], weightDenum, len-n,
- LPC_FILTERORDER);
-
- } else if ((state_first==0)&&(n==(STATE_SHORT_LEN-SUBL))) {
- syntDenum += (LPC_FILTERORDER+1);
- weightDenum += (LPC_FILTERORDER+1);
-
- /* synthesis and weighting filters on input */
- AllPoleFilter (&in[n], weightDenum, len-n,
- LPC_FILTERORDER);
-
- }
-
- /* prediction of synthesized and weighted input */
-
- syntOut[n] = 0.0;
- AllPoleFilter (&syntOut[n], weightDenum, 1, LPC_FILTERORDER);
-
- /* quantization */
-
- toQ = in[n]-syntOut[n];
- sort_sq(&xq, &index, toQ, state_sq3Tbl, 8);
- out[n]=index;
- syntOut[n] = state_sq3Tbl[out[n]];
-
- /* update of the prediction filter */
-
- AllPoleFilter(&syntOut[n], weightDenum, 1, LPC_FILTERORDER);
- }
-}
-
-/*----------------------------------------------------------------*
- * encoding of start state
- *---------------------------------------------------------------*/
-
-void StateSearchW(
- float *residual,/* (i) target residual vector */
- float *syntDenum, /* (i) lpc synthesis filter */
- float *weightDenum, /* (i) weighting filter denuminator */
- int *idxForMax, /* (o) quantizer index for maximum
- amplitude */
- int *idxVec, /* (o) vector of quantization indexes */
- int len, /* (i) length of all vectors */
- int state_first /* (i) position of start state in the
- 80 vec */
-){
- float dtmp, maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN];
- float *tmp, numerator[1+LPC_FILTERORDER];
- float foutbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN], *fout;
- int k;
- float qmax, scal;
-
- /* initialization of buffers and filter coefficients */
-
- memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
- memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
- for(k=0; k<LPC_FILTERORDER; k++){
- numerator[k]=syntDenum[LPC_FILTERORDER-k];
- }
- numerator[LPC_FILTERORDER]=syntDenum[0];
- tmp = &tmpbuf[LPC_FILTERORDER];
- fout = &foutbuf[LPC_FILTERORDER];
-
- /* circular convolution with the all-pass filter */
-
- memcpy(tmp, residual, len*sizeof(float));
- memset(tmp+len, 0, len*sizeof(float));
- ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
- LPC_FILTERORDER, fout);
- for(k=0;k<len;k++){
- fout[k] += fout[k+len];
- }
-
- /* identification of the maximum amplitude value */
-
- maxVal = fout[0];
- for(k=1; k<len; k++){
-
- if(fout[k]*fout[k] > maxVal*maxVal){
- maxVal = fout[k];
- }
- }
- maxVal=(float)fabs(maxVal);
-
- /* encoding of the maximum amplitude value */
-
- if(maxVal < 10.0){
- maxVal = 10.0;
- }
- maxVal = (float)log10(maxVal);
- sort_sq(&dtmp, idxForMax, maxVal, state_frgqTbl, 64);
-
- /* decoding of the maximum amplitude representation value,
- and corresponding scaling of start state */
-
- maxVal=state_frgqTbl[*idxForMax];
- qmax = (float)pow(10,maxVal);
- scal = (float)(4.5)/qmax;
- for(k=0;k<len;k++){
- fout[k] *= scal;
- }
-
- /* predictive noise shaping encoding of scaled start state */
-
- AbsQuantW(fout,syntDenum,weightDenum,idxVec, len, state_first);
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateSearchW.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include "filter.h"
+#include "helpfun.h"
+
+/*----------------------------------------------------------------*
+ * predictive noise shaping encoding of scaled start state
+ * (subrutine for StateSearchW)
+ *---------------------------------------------------------------*/
+
+void AbsQuantW(
+ 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; n<len; n++) {
+
+ /* time update of filter coefficients */
+
+ if ((state_first)&&(n==SUBL)){
+ syntDenum += (LPC_FILTERORDER+1);
+ weightDenum += (LPC_FILTERORDER+1);
+
+ /* synthesis and weighting filters on input */
+ AllPoleFilter (&in[n], weightDenum, len-n,
+ LPC_FILTERORDER);
+
+ } else if ((state_first==0)&&
+ (n==(iLBCenc_inst->state_short_len-SUBL))) {
+ syntDenum += (LPC_FILTERORDER+1);
+ weightDenum += (LPC_FILTERORDER+1);
+
+ /* synthesis and weighting filters on input */
+ AllPoleFilter (&in[n], weightDenum, len-n,
+ LPC_FILTERORDER);
+
+ }
+
+ /* prediction of synthesized and weighted input */
+
+ syntOut[n] = 0.0;
+ AllPoleFilter (&syntOut[n], weightDenum, 1,
+ LPC_FILTERORDER);
+
+ /* quantization */
+
+ toQ = in[n]-syntOut[n];
+ sort_sq(&xq, &index, toQ, state_sq3Tbl, 8);
+ out[n]=index;
+ syntOut[n] = state_sq3Tbl[out[n]];
+
+ /* update of the prediction filter */
+
+
+
+ AllPoleFilter(&syntOut[n], weightDenum, 1,
+ LPC_FILTERORDER);
+ }
+}
+
+/*----------------------------------------------------------------*
+ * encoding of start state
+ *---------------------------------------------------------------*/
+
+void StateSearchW(
+ 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<LPC_FILTERORDER; k++) {
+ numerator[k]=syntDenum[LPC_FILTERORDER-k];
+ }
+ numerator[LPC_FILTERORDER]=syntDenum[0];
+ tmp = &tmpbuf[LPC_FILTERORDER];
+ fout = &foutbuf[LPC_FILTERORDER];
+
+ /* circular convolution with the all-pass filter */
+
+ memcpy(tmp, residual, len*sizeof(float));
+ memset(tmp+len, 0, len*sizeof(float));
+ ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
+ LPC_FILTERORDER, fout);
+ for (k=0; k<len; k++) {
+ fout[k] += fout[k+len];
+ }
+
+ /* identification of the maximum amplitude value */
+
+ maxVal = fout[0];
+
+
+ for (k=1; k<len; k++) {
+
+ if (fout[k]*fout[k] > maxVal*maxVal){
+ maxVal = fout[k];
+ }
+ }
+ maxVal=(float)fabs(maxVal);
+
+ /* encoding of the maximum amplitude value */
+
+ if (maxVal < 10.0) {
+ maxVal = 10.0;
+ }
+ maxVal = (float)log10(maxVal);
+ sort_sq(&dtmp, idxForMax, maxVal, state_frgqTbl, 64);
+
+ /* decoding of the maximum amplitude representation value,
+ and corresponding scaling of start state */
+
+ maxVal=state_frgqTbl[*idxForMax];
+ qmax = (float)pow(10,maxVal);
+ scal = (float)(4.5)/qmax;
+ for (k=0; k<len; k++){
+ fout[k] *= scal;
+ }
+
+ /* predictive noise shaping encoding of scaled start state */
+
+ AbsQuantW(iLBCenc_inst, fout,syntDenum,
+ weightDenum,idxVec, len, state_first);
+}
+
+
Index: StateSearchW.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/StateSearchW.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- StateSearchW.h 15 Apr 2003 04:36:52 -0000 1.1
+++ StateSearchW.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,43 +1,48 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- StateSearchW.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_STATESEARCHW_H
-#define __iLBC_STATESEARCHW_H
-
-void AbsQuantW(
- float *in, /* (i) vector to encode */
- float *syntDenum, /* (i) denominator of synthesis filter */
- float *weightDenum, /* (i) denominator of weighting filter */
- int *out, /* (o) vector of quantizer indexes */
- int len, /* (i) length of vector to encode and
- vector of quantizer indexes */
- int state_first /* (i) position of start state in the
- 80 vec */
-);
-
-void StateSearchW(
- float *residual,/* (i) target residual vector */
- float *syntDenum, /* (i) lpc synthesis filter */
- float *weightDenum, /* (i) weighting filter denuminator */
- int *idxForMax, /* (o) quantizer index for maximum
- amplitude */
- int *idxVec, /* (o) vector of quantization indexes */
- int len, /* (i) length of all vectors */
- int state_first /* (i) position of start state in the
- 80 vec */
-);
-
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ StateSearchW.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_STATESEARCHW_H
+#define __iLBC_STATESEARCHW_H
+
+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 */
+);
+
+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 */
+);
+
+
+#endif
+
+
Index: anaFilter.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/anaFilter.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- anaFilter.c 15 Aug 2003 04:38:39 -0000 1.2
+++ anaFilter.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,69 +1,70 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- anaFilter.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <string.h>
-#include "iLBC_define.h"
-#include "anaFilter.h"
-
-/*----------------------------------------------------------------*
- * LP analysis filter.
- *---------------------------------------------------------------*/
-
-void anaFilter(
- float *In, /* (i) Signal to be filtered */
- float *a, /* (i) LP parameters */
- int len,/* (i) Length of signal */
- float *Out, /* (o) Filtered signal */
- float *mem /* (i/o) Filter state */
-){
- int i, j;
- float *po, *pi, *pm, *pa;
-
- po = Out;
-
- /* Filter first part using memory from past */
-
- for (i=0;i<LPC_FILTERORDER;i++) {
- pi = &In[i];
- pm = &mem[LPC_FILTERORDER-1];
- pa = a;
- *po=0.0;
- for (j=0;j<=i;j++) {
- *po+=(*pa++)*(*pi--);
- }
- for (j=i+1;j<LPC_FILTERORDER+1;j++) {
- *po+=(*pa++)*(*pm--);
- }
- po++;
- }
-
- /* Filter last part where the state is entierly
- in the input vector */
-
- for (i=LPC_FILTERORDER;i<len;i++) {
- pi = &In[i];
- pa = a;
- *po=0.0;
- for (j=0;j<LPC_FILTERORDER+1;j++) {
- *po+=(*pa++)*(*pi--);
- }
- po++;
- }
-
- /* Update state vector */
-
- memcpy(mem, &In[len-LPC_FILTERORDER],
- LPC_FILTERORDER*sizeof(float));
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ anaFilter.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <string.h>
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * LP analysis filter.
+
+
+ *---------------------------------------------------------------*/
+
+void anaFilter(
+ float *In, /* (i) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len,/* (i) Length of signal */
+ float *Out, /* (o) Filtered signal */
+ float *mem /* (i/o) Filter state */
+){
+ int i, j;
+ float *po, *pi, *pm, *pa;
+
+ po = Out;
+
+ /* Filter first part using memory from past */
+
+ for (i=0; i<LPC_FILTERORDER; i++) {
+ pi = &In[i];
+ pm = &mem[LPC_FILTERORDER-1];
+ pa = a;
+ *po=0.0;
+ for (j=0; j<=i; j++) {
+ *po+=(*pa++)*(*pi--);
+ }
+ for (j=i+1; j<LPC_FILTERORDER+1; j++) {
+
+ *po+=(*pa++)*(*pm--);
+ }
+ po++;
+ }
+
+ /* Filter last part where the state is entierly
+ in the input vector */
+
+ for (i=LPC_FILTERORDER; i<len; i++) {
+ pi = &In[i];
+ pa = a;
+ *po=0.0;
+ for (j=0; j<LPC_FILTERORDER+1; j++) {
+ *po+=(*pa++)*(*pi--);
+ }
+ po++;
+ }
+
+ /* Update state vector */
+
+ memcpy(mem, &In[len-LPC_FILTERORDER],
+ LPC_FILTERORDER*sizeof(float));
+}
+
+
Index: anaFilter.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/anaFilter.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- anaFilter.h 15 Apr 2003 04:36:52 -0000 1.1
+++ anaFilter.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,27 +1,26 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- anaFilter.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_ANAFILTER_H
-#define __iLBC_ANAFILTER_H
-
-void anaFilter(
- float *In, /* (i) Signal to be filtered */
- float *a, /* (i) LP parameters */
- int len,/* (i) Length of signal */
- float *Out, /* (o) Filtered signal */
- float *mem /* (i/o) Filter state */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ anaFilter.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ANAFILTER_H
+#define __iLBC_ANAFILTER_H
+
+void anaFilter(
+ float *In, /* (i) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len,/* (i) Length of signal */
+ float *Out, /* (o) Filtered signal */
+ float *mem /* (i/o) Filter state */
+);
+
+#endif
+
+
Index: constants.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/constants.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- constants.c 15 Apr 2003 04:36:52 -0000 1.1
+++ constants.c 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,685 +1,729 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- constants.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
[...1383 lines suppressed...]
+(float)1.720581, (float)1.995728, (float)2.299438, (float)2.557007,
+(float)1.619385, (float)2.173950, (float)2.574219, (float)2.787964,
+(float)1.883179, (float)2.220459, (float)2.474365, (float)2.825073,
+(float)1.447632, (float)2.045044, (float)2.555542, (float)2.744873,
+(float)1.502686, (float)2.156616, (float)2.653320, (float)2.846558,
+(float)1.711548, (float)1.944092, (float)2.282959, (float)2.685791,
+(float)1.499756, (float)1.867554, (float)2.341064, (float)2.578857,
+(float)1.916870, (float)2.135132, (float)2.568237, (float)2.826050,
+(float)1.498047, (float)1.711182, (float)2.223267, (float)2.755127,
+
+
+(float)1.808716, (float)1.997559, (float)2.256470, (float)2.758545,
+(float)2.088501, (float)2.402710, (float)2.667358, (float)2.890259,
+(float)1.545044, (float)1.819214, (float)2.324097, (float)2.692993,
+(float)1.796021, (float)2.012573, (float)2.505737, (float)2.784912,
+(float)1.786499, (float)2.041748, (float)2.290405, (float)2.650757,
+(float)1.938232, (float)2.264404, (float)2.529053, (float)2.796143
+};
+
+
Index: constants.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/constants.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- constants.h 15 Apr 2003 04:36:52 -0000 1.1
+++ constants.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,85 +1,74 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- constants.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_CONSTANTS_H
-#define __iLBC_CONSTANTS_H
-
-#include "iLBC_define.h"
-
-/* bit allocation */
-
-extern int lsf_bitsTbl[];
-extern int start_bitsTbl;
-extern int scale_bitsTbl;
-extern int state_bitsTbl;
-extern int cb_bitsTbl[5][CB_NSTAGES];
-extern int search_rangeTbl[5][CB_NSTAGES];
-extern int gain_bitsTbl[];
-
-/* ULP bit allocation */
-
-extern int ulp_lsf_bitsTbl[6][ULP_CLASSES+2];
-extern int ulp_start_bitsTbl[];
-extern int ulp_startfirst_bitsTbl[];
-extern int ulp_scale_bitsTbl[];
-extern int ulp_state_bitsTbl[];
-extern int ulp_extra_cb_indexTbl[CB_NSTAGES][ULP_CLASSES+2];
-extern int ulp_extra_cb_gainTbl[CB_NSTAGES][ULP_CLASSES+2];
-extern int ulp_cb_indexTbl[NASUB][CB_NSTAGES][ULP_CLASSES+2];
-extern int ulp_cb_gainTbl[NASUB][CB_NSTAGES][ULP_CLASSES+2];
-
-/* high pass filters */
-
-extern float hpi_zero_coefsTbl[];
-extern float hpi_pole_coefsTbl[];
-extern float hpo_zero_coefsTbl[];
-extern float hpo_pole_coefsTbl[];
-
-/* low pass filters */
-extern float lpFilt_coefsTbl[];
-
-/* LPC analysis and quantization */
-
-extern float lpc_winTbl[];
-extern float lpc_asymwinTbl[];
-extern float lpc_lagwinTbl[];
-extern float lsfCbTbl[];
-extern float lsfmeanTbl[];
-extern int dim_lsfCbTbl[];
-extern int size_lsfCbTbl[];
-extern float lsf_weightTbl[];
-
-/* state quantization tables */
-
-extern float state_sq3Tbl[];
-extern float state_frgqTbl[];
-
-/* gain quantization tables */
-
-extern float gain_sq3Tbl[];
-extern float gain_sq4Tbl[];
-extern float gain_sq5Tbl[];
-
-/* adaptive codebook definitions */
-
-extern int memLfTbl[];
-extern int stMemLTbl;
-extern float cbfiltersTbl[CB_FILTERLEN];
-
-/* enhancer definitions */
-
-extern float polyphaserTbl[];
-extern float enh_plocsTbl[];
-
-#endif
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ constants.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+
+
+******************************************************************/
+
+#ifndef __iLBC_CONSTANTS_H
+#define __iLBC_CONSTANTS_H
+
+#include "iLBC_define.h"
+
+
+/* ULP bit allocation */
+
+extern const iLBC_ULP_Inst_t ULP_20msTbl;
+extern const iLBC_ULP_Inst_t ULP_30msTbl;
+
+/* high pass filters */
+
+extern float hpi_zero_coefsTbl[];
+extern float hpi_pole_coefsTbl[];
+extern float hpo_zero_coefsTbl[];
+extern float hpo_pole_coefsTbl[];
+
+/* low pass filters */
+extern float lpFilt_coefsTbl[];
+
+/* LPC analysis and quantization */
+
+extern float lpc_winTbl[];
+extern float lpc_asymwinTbl[];
+extern float lpc_lagwinTbl[];
+extern float lsfCbTbl[];
+extern float lsfmeanTbl[];
+extern int dim_lsfCbTbl[];
+extern int size_lsfCbTbl[];
+extern float lsf_weightTbl_30ms[];
+extern float lsf_weightTbl_20ms[];
+
+/* state quantization tables */
+
+extern float state_sq3Tbl[];
+extern float state_frgqTbl[];
+
+/* gain quantization tables */
+
+extern float gain_sq3Tbl[];
+extern float gain_sq4Tbl[];
+extern float gain_sq5Tbl[];
+
+/* adaptive codebook definitions */
+
+extern int search_rangeTbl[5][CB_NSTAGES];
+extern int memLfTbl[];
+extern int stMemLTbl;
+extern float cbfiltersTbl[CB_FILTERLEN];
+
+
+
+/* enhancer definitions */
+
+extern float polyphaserTbl[];
+extern float enh_plocsTbl[];
+
+#endif
+
Index: createCB.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/createCB.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- createCB.c 15 Aug 2003 04:38:39 -0000 1.2
+++ createCB.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,208 +1,215 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- createCB.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include "iLBC_define.h"
-#include "constants.h"
-#include "createCB.h"
-#include <string.h>
-#include <math.h>
-
-/*----------------------------------------------------------------*
- * Construct an additional codebook vector by filtering the
- * initial codebook buffer. This vector is then used to expand
- * the codebook with an additional section.
- *---------------------------------------------------------------*/
-
-void filteredCBvecs(
- float *cbvectors, /* (o) Codebook vectors for the higher
-section */
- float *mem, /* (i) Buffer to create codebook vector from
-*/
- int lMem /* (i) Length of buffer */
-){
- int j, k;
- float *pp, *pp1;
- float tempbuff2[CB_MEML+CB_FILTERLEN];
- float *pos;
-
- memset(tempbuff2, 0, (CB_HALFFILTERLEN-1)*sizeof(float));
- memcpy(&tempbuff2[CB_HALFFILTERLEN-1], mem, lMem*sizeof(float));
- memset(&tempbuff2[lMem+CB_HALFFILTERLEN-1], 0,
- (CB_HALFFILTERLEN+1)*sizeof(float));
-
- /* Create codebook vector for higher section by filtering */
-
- /* do filtering */
- pos=cbvectors;
- memset(pos, 0, lMem*sizeof(float));
- for (k=0; k<lMem; k++) {
- pp=&tempbuff2[k];
- pp1=&cbfiltersTbl[0];
- for (j=0;j<CB_FILTERLEN;j++) {
- (*pos)+=(*pp++)*(*pp1++);
- }
- pos++;
- }
-}
-
-/*----------------------------------------------------------------*
- * Search the augmented part of the codebook to find the best
- * measure.
- *----------------------------------------------------------------*/
-
-void searchAugmentedCB(
- int low, /* (i) Start index for the search */
- int high, /* (i) End index for the search */
- int stage, /* (i) Current stage */
- int startIndex, /* (i) Codebook index for the first
- aug vector */
- float *target, /* (i) Target vector for encoding */
- float *buffer, /* (i) Pointer to the end of the buffer for
- augmented codebook construction */
- float *max_measure, /* (i/o) Currently maximum measure */
- int *best_index,/* (o) Currently the best index */
- float *gain, /* (o) Currently the best gain */
- float *energy, /* (o) Energy of augmented codebook
- vectors */
- float *invenergy/* (o) Inv energy of augmented codebook
- vectors */
-) {
- int lagcount, ilow, j, tmpIndex;
- float *pp, *ppo, *ppi, *ppe, crossDot, alfa;
- float weighted, measure, nrjRecursive;
- float ftmp;
-
- /* Compute the energy for the first (low-5)
- noninterpolated samples */
- nrjRecursive = (float) 0.0;
- pp = buffer - low + 1;
- for (j=0; j<(low-5); j++) {
- nrjRecursive += ( (*pp)*(*pp) );
- pp++;
- }
- ppe = buffer - low;
-
-
- for (lagcount=low; lagcount<=high; lagcount++) {
-
- /* Index of the codebook vector used for retrieving
- energy values */
- tmpIndex = startIndex+lagcount-20;
-
- ilow = lagcount-4;
-
- /* Update the energy recursively to save complexity */
- nrjRecursive = nrjRecursive + (*ppe)*(*ppe);
- ppe--;
- energy[tmpIndex] = nrjRecursive;
-
- /* Compute cross dot product for the first (low-5) samples */
- crossDot = (float) 0.0;
- pp = buffer-lagcount;
- for (j=0; j<ilow; j++) {
- crossDot += target[j]*(*pp++);
- }
-
- /* interpolation */
- alfa = (float) 0.2;
- ppo = buffer-4;
- ppi = buffer-lagcount-4;
- for (j=ilow; j<lagcount; j++) {
- weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
- ppo++;
- ppi++;
- energy[tmpIndex] += weighted*weighted;
- crossDot += target[j]*weighted;
- alfa += (float)0.2;
- }
-
- /* Compute energy and cross dot product for the
- remaining samples */
- pp = buffer - lagcount;
- for (j=lagcount; j<SUBL; j++) {
- energy[tmpIndex] += (*pp)*(*pp);
- crossDot += target[j]*(*pp++);
- }
-
- if(energy[tmpIndex]>0.0) {
- invenergy[tmpIndex]=(float)1.0/(energy[tmpIndex]+EPS);
- } else {
- invenergy[tmpIndex] = (float) 0.0;
- }
-
- if (stage==0) {
- measure = (float)-10000000.0;
-
- if (crossDot > 0.0) {
- measure = crossDot*crossDot*invenergy[tmpIndex];
- }
- }
- else {
- measure = crossDot*crossDot*invenergy[tmpIndex];
- }
-
- /* check if measure is better */
- ftmp = crossDot*invenergy[tmpIndex];
-
- if ((measure>*max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
- *best_index = tmpIndex;
- *max_measure = measure;
- *gain = ftmp;
- }
- }
-}
-
-
-/*----------------------------------------------------------------*
- * Recreate a specific codebook vector from the augmented part.
- *
- *----------------------------------------------------------------*/
-
-void createAugmentedVec(
- int index, /* (i) Index for the augmented vector
- to be created */
- float *buffer, /* (i) Pointer to the end of the buffer for
- augmented codebook construction */
- float *cbVec/* (o) The construced codebook vector */
-) {
- int ilow, j;
- float *pp, *ppo, *ppi, alfa, alfa1, weighted;
-
- ilow = index-5;
-
- /* copy the first noninterpolated part */
-
- pp = buffer-index;
- memcpy(cbVec,pp,sizeof(float)*index);
-
- /* interpolation */
-
- alfa1 = (float)0.2;
- alfa = 0.0;
- ppo = buffer-5;
- ppi = buffer-index-5;
- for (j=ilow; j<index; j++) {
- weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
- ppo++;
- ppi++;
- cbVec[j] = weighted;
- alfa += alfa1;
- }
-
- /* copy the second noninterpolated part */
-
- pp = buffer - index;
- memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index));
-}
-
-
+
+
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ createCB.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include <string.h>
+#include <math.h>
+
+/*----------------------------------------------------------------*
+ * Construct an additional codebook vector by filtering the
+ * initial codebook buffer. This vector is then used to expand
+ * the codebook with an additional section.
+ *---------------------------------------------------------------*/
+
+void filteredCBvecs(
+ float *cbvectors, /* (o) Codebook vectors for the
+ higher section */
+ float *mem, /* (i) Buffer to create codebook
+ vector from */
+ int lMem /* (i) Length of buffer */
+){
+ int j, k;
+ float *pp, *pp1;
+ float tempbuff2[CB_MEML+CB_FILTERLEN];
+ float *pos;
+
+ memset(tempbuff2, 0, (CB_HALFFILTERLEN-1)*sizeof(float));
+ memcpy(&tempbuff2[CB_HALFFILTERLEN-1], mem, lMem*sizeof(float));
+ memset(&tempbuff2[lMem+CB_HALFFILTERLEN-1], 0,
+ (CB_HALFFILTERLEN+1)*sizeof(float));
+
+ /* Create codebook vector for higher section by filtering */
+
+ /* do filtering */
+ pos=cbvectors;
+ memset(pos, 0, lMem*sizeof(float));
+ for (k=0; k<lMem; k++) {
+ pp=&tempbuff2[k];
+ pp1=&cbfiltersTbl[CB_FILTERLEN-1];
+ for (j=0;j<CB_FILTERLEN;j++) {
+ (*pos)+=(*pp++)*(*pp1--);
+ }
+ pos++;
+ }
+}
+
+
+
+/*----------------------------------------------------------------*
+ * Search the augmented part of the codebook to find the best
+ * measure.
+ *----------------------------------------------------------------*/
+
+void searchAugmentedCB(
+ int low, /* (i) Start index for the search */
+ int high, /* (i) End index for the search */
+ int stage, /* (i) Current stage */
+ int startIndex, /* (i) Codebook index for the first
+ aug vector */
+ float *target, /* (i) Target vector for encoding */
+ float *buffer, /* (i) Pointer to the end of the buffer for
+ augmented codebook construction */
+ float *max_measure, /* (i/o) Currently maximum measure */
+ int *best_index,/* (o) Currently the best index */
+ float *gain, /* (o) Currently the best gain */
+ float *energy, /* (o) Energy of augmented codebook
+ vectors */
+ float *invenergy/* (o) Inv energy of augmented codebook
+ vectors */
+) {
+ int icount, ilow, j, tmpIndex;
+ float *pp, *ppo, *ppi, *ppe, crossDot, alfa;
+ float weighted, measure, nrjRecursive;
+ float ftmp;
+
+ /* Compute the energy for the first (low-5)
+ noninterpolated samples */
+ nrjRecursive = (float) 0.0;
+ pp = buffer - low + 1;
+ for (j=0; j<(low-5); j++) {
+ nrjRecursive += ( (*pp)*(*pp) );
+ pp++;
+ }
+ ppe = buffer - low;
+
+
+ for (icount=low; icount<=high; icount++) {
+
+ /* Index of the codebook vector used for retrieving
+ energy values */
+ tmpIndex = startIndex+icount-20;
+
+ ilow = icount-4;
+
+ /* Update the energy recursively to save complexity */
+ nrjRecursive = nrjRecursive + (*ppe)*(*ppe);
+ ppe--;
+ energy[tmpIndex] = nrjRecursive;
+
+ /* Compute cross dot product for the first (low-5)
+ samples */
+ crossDot = (float) 0.0;
+
+
+ pp = buffer-icount;
+ for (j=0; j<ilow; j++) {
+ crossDot += target[j]*(*pp++);
+ }
+
+ /* interpolation */
+ alfa = (float) 0.2;
+ ppo = buffer-4;
+ ppi = buffer-icount-4;
+ for (j=ilow; j<icount; j++) {
+ weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
+ ppo++;
+ ppi++;
+ energy[tmpIndex] += weighted*weighted;
+ crossDot += target[j]*weighted;
+ alfa += (float)0.2;
+ }
+
+ /* Compute energy and cross dot product for the
+ remaining samples */
+ pp = buffer - icount;
+ for (j=icount; j<SUBL; j++) {
+ energy[tmpIndex] += (*pp)*(*pp);
+ crossDot += target[j]*(*pp++);
+ }
+
+ if (energy[tmpIndex]>0.0) {
+ invenergy[tmpIndex]=(float)1.0/(energy[tmpIndex]+EPS);
+ } else {
+ invenergy[tmpIndex] = (float) 0.0;
+ }
+
+ if (stage==0) {
+ measure = (float)-10000000.0;
+
+ if (crossDot > 0.0) {
+ measure = crossDot*crossDot*invenergy[tmpIndex];
+ }
+ }
+ else {
+ measure = crossDot*crossDot*invenergy[tmpIndex];
+ }
+
+ /* check if measure is better */
+ ftmp = crossDot*invenergy[tmpIndex];
+
+ if ((measure>*max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
+ *best_index = tmpIndex;
+ *max_measure = measure;
+ *gain = ftmp;
+ }
+ }
+}
+
+
+
+
+/*----------------------------------------------------------------*
+ * Recreate a specific codebook vector from the augmented part.
+ *
+ *----------------------------------------------------------------*/
+
+void createAugmentedVec(
+ int index, /* (i) Index for the augmented vector
+ to be created */
+ float *buffer, /* (i) Pointer to the end of the buffer for
+ augmented codebook construction */
+ float *cbVec/* (o) The construced codebook vector */
+) {
+ int ilow, j;
+ float *pp, *ppo, *ppi, alfa, alfa1, weighted;
+
+ ilow = index-5;
+
+ /* copy the first noninterpolated part */
+
+ pp = buffer-index;
+ memcpy(cbVec,pp,sizeof(float)*index);
+
+ /* interpolation */
+
+ alfa1 = (float)0.2;
+ alfa = 0.0;
+ ppo = buffer-5;
+ ppi = buffer-index-5;
+ for (j=ilow; j<index; j++) {
+ weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
+ ppo++;
+ ppi++;
+ cbVec[j] = weighted;
+ alfa += alfa1;
+ }
+
+ /* copy the second noninterpolated part */
+
+ pp = buffer - index;
+ memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index));
+}
+
+
Index: createCB.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/createCB.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- createCB.h 15 Apr 2003 04:36:52 -0000 1.1
+++ createCB.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,55 +1,56 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- createCB.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_CREATECB_H
-#define __iLBC_CREATECB_H
-
-void filteredCBvecs(
- float *cbvectors, /* (o) Codebook vector for the
- higher section */
- float *mem, /* (i) Buffer to create codebook
- vectors from */
- int lMem /* (i) Length of buffer */
-);
-
-void searchAugmentedCB(
- int low, /* (i) Start index for the search */
- int high, /* (i) End index for the search */
- int stage, /* (i) Current stage */
- int startIndex, /* (i) CB index for the first
- augmented vector */
- float *target, /* (i) Target vector for encoding */
- float *buffer, /* (i) Pointer to the end of the
- buffer for augmented codebook
- construction */
- float *max_measure, /* (i/o) Currently maximum measure */
- int *best_index,/* (o) Currently the best index */
- float *gain, /* (o) Currently the best gain */
- float *energy, /* (o) Energy of augmented
- codebook vectors */
- float *invenergy/* (o) Inv energy of aug codebook
- vectors */
-);
-
-void createAugmentedVec(
- int index, /* (i) Index for the aug vector
- to be created */
- float *buffer, /* (i) Pointer to the end of the
- buffer for augmented codebook
- construction */
- float *cbVec /* (o) The construced codebook vector */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ createCB.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_CREATECB_H
+#define __iLBC_CREATECB_H
+
+void filteredCBvecs(
+ float *cbvectors, /* (o) Codebook vector for the
+ higher section */
+ float *mem, /* (i) Buffer to create codebook
+ vectors from */
+ int lMem /* (i) Length of buffer */
+);
+
+void searchAugmentedCB(
+ int low, /* (i) Start index for the search */
+ int high, /* (i) End index for the search */
+ int stage, /* (i) Current stage */
+ int startIndex, /* (i) CB index for the first
+ augmented vector */
+ float *target, /* (i) Target vector for encoding */
+ float *buffer, /* (i) Pointer to the end of the
+ buffer for augmented codebook
+ construction */
+ float *max_measure, /* (i/o) Currently maximum measure */
+ int *best_index,/* (o) Currently the best index */
+ float *gain, /* (o) Currently the best gain */
+ float *energy, /* (o) Energy of augmented
+ codebook vectors */
+ float *invenergy/* (o) Inv energy of aug codebook
+ vectors */
+);
+
+void createAugmentedVec(
+ int index, /* (i) Index for the aug vector
+ to be created */
+ float *buffer, /* (i) Pointer to the end of the
+ buffer for augmented codebook
+ construction */
+ float *cbVec /* (o) The construced codebook vector */
+);
+
+#endif
+
+
Index: doCPLC.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/doCPLC.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- doCPLC.c 15 Aug 2003 04:38:39 -0000 1.2
+++ doCPLC.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,304 +1,258 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- doCPLC.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <string.h>
-
-#include "iLBC_define.h"
-#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 *buffer, /* (i) signal buffer */
- int lag, /* (i) pitch lag */
- int bLen, /* (i) length of buffer */
- int sRange /* (i) correlation search length */
-){
- int i;
- float ftmp1, ftmp2;
-
- ftmp1 = 0.0;
- ftmp2 = 0.0;
- for (i=0; i<sRange; i++) {
- ftmp1 += buffer[bLen-sRange+i] *
- buffer[bLen-sRange+i-lag];
- ftmp2 += buffer[bLen-sRange+i-lag] *
- buffer[bLen-sRange+i-lag];
- }
-
- if (ftmp2 > 0.0) {
- *cc = ftmp1*ftmp1/ftmp2;
- *gc = (float)fabs(ftmp1/ftmp2);
- }
- else {
- *cc = 0.0;
- *gc = 0.0;
- }
-}
-
-/*----------------------------------------------------------------*
- * Packet loss concealment routine. Conceals a residual signal
- * and LP parameters. If no packet loss, update state.
- *---------------------------------------------------------------*/
-
-void doThePLC(
- float *PLCresidual, /* (o) concealed residual */
- float *PLClpc, /* (o) concealed LP parameters */
- int PLI, /* (i) packet loss indicator
- 0 - no PL, 1 = PL */
- float *decresidual, /* (i) decoded residual */
- float *lpc, /* (i) decoded LPC (only used for no PL) */
- int inlag, /* (i) pitch lag */
- iLBC_Dec_Inst_t *iLBCdec_inst
- /* (i/o) decoder instance */
-){
- int lag=20, randlag;
- float gain, maxcc;
- float gain_comp, maxcc_comp;
- int i, pick, offset;
- float ftmp, ftmp1, randvec[BLOCKL], pitchfact;
-
- /* Packet Loss */
-
- if (PLI == 1) {
-
- (*iLBCdec_inst).consPLICount += 1;
-
- /* if previous frame not lost,
- determine pitch pred. gain */
-
- if ((*iLBCdec_inst).prevPLI != 1) {
-
- /* Search around the previous lag to find the
- best pitch period */
-
- lag=inlag-3;
- compCorr(&maxcc, &gain, (*iLBCdec_inst).prevResidual,
- lag, BLOCKL, 60);
- for (i=inlag-2;i<=inlag+3;i++) {
- compCorr(&maxcc_comp, &gain_comp,
- (*iLBCdec_inst).prevResidual,
- i, BLOCKL, 60);
-
- if (maxcc_comp>maxcc) {
- maxcc=maxcc_comp;
- gain=gain_comp;
- lag=i;
- }
- }
-
- if (gain > 1.0) {
- gain = 1.0;
- }
- }
-
- /* previous frame lost, use recorded lag and gain */
-
- else {
- lag=(*iLBCdec_inst).prevLag;
- gain=(*iLBCdec_inst).prevGain;
- }
-
- /* Attenuate signal and scale down pitch pred gain if
- several frames lost consecutively */
-
-
- if ((*iLBCdec_inst).consPLICount > 1) {
- gain *= (float)0.9;
- }
-
- /* Compute mixing factor of picth repeatition and noise */
-
-
- if (gain > PLC_XT_MIX) {
- pitchfact = PLC_YT_MIX;
- } else if (gain < PLC_XB_MIX) {
- pitchfact = PLC_YB_MIX;
- } else {
- pitchfact = PLC_YB_MIX + (gain - PLC_XB_MIX) *
- (PLC_YT_MIX-PLC_YB_MIX)/(PLC_XT_MIX-PLC_XB_MIX);
- }
-
- /* compute concealed residual */
-
- (*iLBCdec_inst).energy = 0.0;
- for (i=0; i<BLOCKL; i++) {
-
- /* noise component */
-
- (*iLBCdec_inst).seed=((*iLBCdec_inst).seed*69069L+1) &
- (0x80000000L-1);
- randlag = 50 + ((signed long) (*iLBCdec_inst).seed)%70;
- pick = i - randlag;
-
- if (pick < 0) {
- randvec[i] = gain *
- (*iLBCdec_inst).prevResidual[BLOCKL+pick];
- } else {
- randvec[i] = gain * randvec[pick];
- }
-
- /* pitch repeatition component */
-
- pick = i - lag;
-
- if (pick < 0) {
- PLCresidual[i] = gain *
- (*iLBCdec_inst).prevResidual[BLOCKL+pick];
- } else {
- PLCresidual[i] = gain * PLCresidual[pick];
- }
-
- /* mix noise and pitch repeatition */
-
- PLCresidual[i] = (pitchfact * PLCresidual[i] +
- ((float)1.0 - pitchfact) * randvec[i]);
-
- (*iLBCdec_inst).energy += PLCresidual[i] *
- PLCresidual[i];
- }
-
- /* less than 30 dB, use only noise */
-
- if (sqrt((*iLBCdec_inst).energy/(float)BLOCKL) < 30.0) {
- (*iLBCdec_inst).energy = 0.0;
- gain=0.0;
- for (i=0; i<BLOCKL; i++) {
- PLCresidual[i] = randvec[i];
- (*iLBCdec_inst).energy += PLCresidual[i] *
- PLCresidual[i];
- }
- }
-
- /* conceal LPC by bandwidth expansion of old LPC */
-
- ftmp=PLC_BWEXPAND;
- PLClpc[0]=(float)1.0;
- for (i=1; i<LPC_FILTERORDER+1; i++) {
- PLClpc[i] = ftmp * (*iLBCdec_inst).prevLpc[i];
- ftmp *= PLC_BWEXPAND;
- }
-
- }
-
- /* previous frame lost and this frame OK, mixing in
- with new frame */
-
- else if ((*iLBCdec_inst).prevPLI == 1) {
-
- lag = (*iLBCdec_inst).prevLag;
- gain = (*iLBCdec_inst).prevGain;
-
- /* if pitch pred gain high, do overlap-add */
-
- if (gain >= PLC_GAINTHRESHOLD) {
-
- /* Compute mixing factor of pitch repeatition
- and noise */
-
- if (gain > PLC_XT_MIX) {
- pitchfact = PLC_YT_MIX;
- } else if (gain < PLC_XB_MIX) {
- pitchfact = PLC_YB_MIX;
- } else {
- pitchfact = PLC_YB_MIX + (gain - PLC_XB_MIX) *
- (PLC_YT_MIX-PLC_YB_MIX)/(PLC_XT_MIX-PLC_XB_MIX);
- }
-
- /* compute concealed residual for 3 subframes */
-
- for (i=0; i<3*SUBL; i++) {
-
- (*iLBCdec_inst).seed=((*iLBCdec_inst).seed*
- 69069L+1) & (0x80000000L-1);
- randlag = 50 + ((signed long)
- (*iLBCdec_inst).seed)%70;
-
- /* noise component */
-
- pick = i - randlag;
-
- if (pick < 0) {
- randvec[i] = gain *
- (*iLBCdec_inst).prevResidual[BLOCKL+pick];
- } else {
- randvec[i] = gain * randvec[pick];
- }
-
- /* pitch repeatition component */
-
- pick = i - lag;
-
- if (pick < 0) {
- PLCresidual[i] = gain *
- (*iLBCdec_inst).prevResidual[BLOCKL+pick];
- } else {
- PLCresidual[i] = gain * PLCresidual[pick];
- }
-
- /* mix noise and pitch repeatition */
-
- PLCresidual[i] = (pitchfact * PLCresidual[i] +
- ((float)1.0 - pitchfact) * randvec[i]);
- }
-
- /* interpolate concealed residual with actual
- residual */
-
- offset = 3*SUBL;
- for (i=0; i<offset; i++) {
- ftmp1 = (float) (i+1) / (float) (offset+1);
- ftmp = (float)1.0 - ftmp1;
- PLCresidual[i]=PLCresidual[i]*ftmp+
- decresidual[i]*ftmp1;
- }
-
- memcpy(PLCresidual+offset, decresidual+offset,
- (BLOCKL-offset)*sizeof(float));
-
- } else {
- memcpy(PLCresidual, decresidual, BLOCKL*sizeof(float));
- }
-
- /* copy LPC */
-
- memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float));
-
- (*iLBCdec_inst).consPLICount = 0;
- }
-
- /* no packet loss, copy input */
-
- else {
- memcpy(PLCresidual, decresidual, BLOCKL*sizeof(float));
- memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float));
- }
-
- /* update state */
-
- (*iLBCdec_inst).prevLag = lag;
- (*iLBCdec_inst).prevGain = gain;
- (*iLBCdec_inst).prevPLI = PLI;
- memcpy((*iLBCdec_inst).prevLpc, PLClpc,
- (LPC_FILTERORDER+1)*sizeof(float));
- memcpy((*iLBCdec_inst).prevResidual, PLCresidual,
- BLOCKL*sizeof(float));
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ doCPLC.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * Compute cross correlation and pitch gain for pitch prediction
+ * of last subframe at given lag.
+ *---------------------------------------------------------------*/
+
+void compCorr(
+ float *cc, /* (o) cross correlation coefficient */
+ float *gc, /* (o) gain */
+ float *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<sRange; i++) {
+ ftmp1 += buffer[bLen-sRange+i] *
+ buffer[bLen-sRange+i-lag];
+ ftmp2 += buffer[bLen-sRange+i-lag] *
+ buffer[bLen-sRange+i-lag];
+ ftmp3 += buffer[bLen-sRange+i] *
+ buffer[bLen-sRange+i];
+ }
+
+ if (ftmp2 > 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; i<iLBCdec_inst->blockl; i++) {
+
+ /* noise component */
+
+ iLBCdec_inst->seed=(iLBCdec_inst->seed*69069L+1) &
+ (0x80000000L-1);
+ randlag = 50 + ((signed long) iLBCdec_inst->seed)%70;
+ pick = i - randlag;
+
+ if (pick < 0) {
+ randvec[i] =
+ 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; i<iLBCdec_inst->blockl; 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));
+}
+
+
+
+
Index: doCPLC.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/doCPLC.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- doCPLC.h 15 Apr 2003 04:36:52 -0000 1.1
+++ doCPLC.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,31 +1,32 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- doCPLC.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_DOLPC_H
-#define __iLBC_DOLPC_H
-
-void doThePLC(
- float *PLCresidual, /* (o) concealed residual */
- float *PLClpc, /* (o) concealed LP parameters */
- int PLI, /* (i) packet loss indicator
- 0 - no PL, 1 = PL */
- float *decresidual, /* (i) decoded residual */
- float *lpc, /* (i) decoded LPC (only used for no PL) */
- int inlag, /* (i) pitch lag */
- iLBC_Dec_Inst_t *iLBCdec_inst
- /* (i/o) decoder instance */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: enhancer.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/enhancer.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- enhancer.c 15 Aug 2003 04:38:39 -0000 1.2
+++ enhancer.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,601 +1,664 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- enhancer.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
[...1233 lines suppressed...]
+ 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);
+}
+
+
Index: enhancer.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/enhancer.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- enhancer.h 15 Apr 2003 04:36:52 -0000 1.1
+++ enhancer.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,34 +1,33 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- enhancer.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __ENHANCER_H
-#define __ENHANCER_H
-
-#include "iLBC_define.h"
-
-float xCorrCoef(
- float *target, /* (i) first array */
- float *regressor, /* (i) second array */
- int subl /* (i) dimension arrays */
-);
-
-int enhancerInterface(
- float *out, /* (o) the enhanced recidual signal */
- float *in, /* (i) the recidual signal to enhance */
- iLBC_Dec_Inst_t *iLBCdec_inst
- /* (i/o) the decoder state structure */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: filter.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/filter.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- filter.c 15 Aug 2003 04:38:39 -0000 1.2
+++ filter.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,162 +1,167 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- filter.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- 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<lengthInOut;n++){
- for(k=1;k<=orderCoef;k++){
- *InOut -= Coef[k]*InOut[-k];
- }
- InOut++;
- }
-}
-
-/*----------------------------------------------------------------*
- * all-zero filter
- *---------------------------------------------------------------*/
-
-void AllZeroFilter(
- float *In, /* (i) In[0] to In[lengthInOut-1] contain filter
- input samples */
- float *Coef,/* (i) filter coefficients (Coef[0] is assumed
- to be 1.0) */
- int lengthInOut,/* (i) number of input/output samples */
- int orderCoef, /* (i) number of filter coefficients */
- float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
- contain the filter state, on exit Out[0]
- to Out[lengthInOut-1] contain filtered
- samples */
-){
- int n,k;
-
- for(n=0;n<lengthInOut;n++){
- *Out = Coef[0]*In[0];
- for(k=1;k<=orderCoef;k++){
- *Out += Coef[k]*In[-k];
- }
- Out++;
- In++;
- }
-}
-
-/*----------------------------------------------------------------*
- * pole-zero filter
- *---------------------------------------------------------------*/
-
-void ZeroPoleFilter(
- float *In, /* (i) In[0] to In[lengthInOut-1] contain filter
- input samples In[-orderCoef] to In[-1]
- contain state of all-zero section */
- float *ZeroCoef,/* (i) filter coefficients for all-zero
- section (ZeroCoef[0] is assumed to
- be 1.0) */
- float *PoleCoef,/* (i) filter coefficients for all-pole section
- (ZeroCoef[0] is assumed to be 1.0) */
- int lengthInOut,/* (i) number of input/output samples */
- int orderCoef, /* (i) number of filter coefficients */
- float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
- contain state of all-pole section. On exit
- Out[0] to Out[lengthInOut-1] contain
- filtered samples */
-){
- AllZeroFilter(In,ZeroCoef,lengthInOut,orderCoef,Out);
- AllPoleFilter(Out,PoleCoef,lengthInOut,orderCoef);
-}
-
-/*----------------------------------------------------------------*
- * downsample (LP filter and decimation)
- *---------------------------------------------------------------*/
-
-void DownSample (
- float *In, /* (i) input samples */
- float *Coef, /* (i) filter coefficients */
- int lengthIn, /* (i) number of input samples */
- float *state, /* (i) filter state */
- float *Out /* (o) downsampled output */
-){
- float o;
- float *Out_ptr = Out;
- float *Coef_ptr, *In_ptr;
- float *state_ptr;
- int i, j, stop;
-
- /* LP filter and decimate at the same time */
-
- for (i = DELAY_DS; i < lengthIn; i+=FACTOR_DS)
- {
- Coef_ptr = &Coef[0];
- In_ptr = &In[i];
- state_ptr = &state[FILTERORDER_DS-2];
-
- o = (float)0.0;
-
- stop = (i < FILTERORDER_DS) ? i + 1 : FILTERORDER_DS;
-
- for (j = 0;j < stop; j++)
- {
- o += *Coef_ptr++ * (*In_ptr--);
- }
- for (j = i + 1; j < FILTERORDER_DS; j++)
- {
- o += *Coef_ptr++ * (*state_ptr--);
- }
-
- *Out_ptr++ = o;
- }
-
- /* Get the last part (use zeros as input for the future) */
-
- for (i=(lengthIn+FACTOR_DS); i<(lengthIn+DELAY_DS);
- i+=FACTOR_DS) {
-
- o=(float)0.0;
-
- if (i<lengthIn) {
- Coef_ptr = &Coef[0];
- In_ptr = &In[i];
- for (j=0;j<FILTERORDER_DS;j++) {
- o += *Coef_ptr++ * (*Out_ptr--);
- }
- } else {
- Coef_ptr = &Coef[i-lengthIn];
- In_ptr = &In[lengthIn-1];
- for (j=0;j<FILTERORDER_DS-(i-lengthIn);j++) {
- o += *Coef_ptr++ * (*In_ptr--);
- }
- }
- *Out_ptr++ = o;
- }
-}
-
-
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ filter.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * all-pole filter
+ *---------------------------------------------------------------*/
+
+void AllPoleFilter(
+ float *InOut, /* (i/o) on entrance InOut[-orderCoef] to
+ InOut[-1] contain the state of the
+ filter (delayed samples). InOut[0] to
+ InOut[lengthInOut-1] contain the filter
+ input, on en exit InOut[-orderCoef] to
+ InOut[-1] is unchanged and InOut[0] to
+ InOut[lengthInOut-1] contain filtered
+ samples */
+ float *Coef,/* (i) filter coefficients, Coef[0] is assumed
+ to be 1.0 */
+ int lengthInOut,/* (i) number of input/output samples */
+ int orderCoef /* (i) number of filter coefficients */
+){
+ int n,k;
+
+ for(n=0;n<lengthInOut;n++){
+ for(k=1;k<=orderCoef;k++){
+ *InOut -= Coef[k]*InOut[-k];
+ }
+ InOut++;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * all-zero filter
+ *---------------------------------------------------------------*/
+
+void AllZeroFilter(
+ float *In, /* (i) In[0] to In[lengthInOut-1] contain
+ filter input samples */
+ float *Coef,/* (i) filter coefficients (Coef[0] is assumed
+ to be 1.0) */
+ int lengthInOut,/* (i) number of input/output samples */
+ int orderCoef, /* (i) number of filter coefficients */
+ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
+ contain the filter state, on exit Out[0]
+ to Out[lengthInOut-1] contain filtered
+ samples */
+){
+ int n,k;
+
+ for(n=0;n<lengthInOut;n++){
+ *Out = Coef[0]*In[0];
+ for(k=1;k<=orderCoef;k++){
+ *Out += Coef[k]*In[-k];
+ }
+
+
+ Out++;
+ In++;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * pole-zero filter
+ *---------------------------------------------------------------*/
+
+void ZeroPoleFilter(
+ float *In, /* (i) In[0] to In[lengthInOut-1] contain
+ filter input samples In[-orderCoef] to
+ In[-1] contain state of all-zero
+ section */
+ float *ZeroCoef,/* (i) filter coefficients for all-zero
+ section (ZeroCoef[0] is assumed to
+ be 1.0) */
+ float *PoleCoef,/* (i) filter coefficients for all-pole section
+ (ZeroCoef[0] is assumed to be 1.0) */
+ int lengthInOut,/* (i) number of input/output samples */
+ int orderCoef, /* (i) number of filter coefficients */
+ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
+ contain state of all-pole section. On
+ exit Out[0] to Out[lengthInOut-1]
+ contain filtered samples */
+){
+ AllZeroFilter(In,ZeroCoef,lengthInOut,orderCoef,Out);
+ AllPoleFilter(Out,PoleCoef,lengthInOut,orderCoef);
+}
+
+/*----------------------------------------------------------------*
+ * downsample (LP filter and decimation)
+ *---------------------------------------------------------------*/
+
+void DownSample (
+ float *In, /* (i) input samples */
+ float *Coef, /* (i) filter coefficients */
+ int lengthIn, /* (i) number of input samples */
+ float *state, /* (i) filter state */
+ float *Out /* (o) downsampled output */
+){
+ float o;
+ float *Out_ptr = Out;
+ float *Coef_ptr, *In_ptr;
+ float *state_ptr;
+ int i, j, stop;
+
+ /* LP filter and decimate at the same time */
+
+ for (i = DELAY_DS; i < lengthIn; i+=FACTOR_DS)
+ {
+ Coef_ptr = &Coef[0];
+ In_ptr = &In[i];
+ state_ptr = &state[FILTERORDER_DS-2];
+
+
+
+ o = (float)0.0;
+
+ stop = (i < FILTERORDER_DS) ? i + 1 : FILTERORDER_DS;
+
+ for (j = 0; j < stop; j++)
+ {
+ o += *Coef_ptr++ * (*In_ptr--);
+ }
+ for (j = i + 1; j < FILTERORDER_DS; j++)
+ {
+ o += *Coef_ptr++ * (*state_ptr--);
+ }
+
+ *Out_ptr++ = o;
+ }
+
+ /* Get the last part (use zeros as input for the future) */
+
+ for (i=(lengthIn+FACTOR_DS); i<(lengthIn+DELAY_DS);
+ i+=FACTOR_DS) {
+
+ o=(float)0.0;
+
+ if (i<lengthIn) {
+ Coef_ptr = &Coef[0];
+ In_ptr = &In[i];
+ for (j=0; j<FILTERORDER_DS; j++) {
+ o += *Coef_ptr++ * (*Out_ptr--);
+ }
+ } else {
+ Coef_ptr = &Coef[i-lengthIn];
+ In_ptr = &In[lengthIn-1];
+ for (j=0; j<FILTERORDER_DS-(i-lengthIn); j++) {
+ o += *Coef_ptr++ * (*In_ptr--);
+ }
+ }
+ *Out_ptr++ = o;
+ }
+}
+
+
Index: filter.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/filter.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- filter.h 15 Apr 2003 04:36:52 -0000 1.1
+++ filter.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,72 +1,73 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- filter.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_FILTER_H
-#define __iLBC_FILTER_H
-
-void AllPoleFilter(
- float *InOut, /* (i/o) on entrance InOut[-orderCoef] to
- InOut[-1] contain the state of the filter
- (delayed samples). InOut[0] to
- InOut[lengthInOut-1] contain the filter
- input, on en exit InOut[-orderCoef] to
- InOut[-1] is unchanged and InOut[0] to
- InOut[lengthInOut-1] contain filtered
- samples */
- float *Coef,/* (i) filter coefficients, Coef[0] is assumed to
- be 1.0 */
- int lengthInOut,/* (i) number of input/output samples */
- int orderCoef /* (i) number of filter coefficients */
-);
-
-void AllZeroFilter(
- float *In, /* (i) In[0] to In[lengthInOut-1] contain filter
- input samples */
- float *Coef,/* (i) filter coefficients (Coef[0] is assumed
- to be 1.0) */
- int lengthInOut,/* (i) number of input/output samples */
- int orderCoef, /* (i) number of filter coefficients */
- float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
- contain the filter state, on exit Out[0]
- to Out[lengthInOut-1] contain filtered
- samples */
-);
-
-void ZeroPoleFilter(
- float *In, /* (i) In[0] to In[lengthInOut-1] contain filter
- input samples In[-orderCoef] to In[-1]
- contain state of all-zero section */
- float *ZeroCoef,/* (i) filter coefficients for all-zero
- section (ZeroCoef[0] is assumed to
- be 1.0) */
- float *PoleCoef,/* (i) filter coefficients for all-pole section
- (ZeroCoef[0] is assumed to be 1.0) */
- int lengthInOut,/* (i) number of input/output samples */
- int orderCoef, /* (i) number of filter coefficients */
- float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
- contain state of all-pole section. On exit
- Out[0] to Out[lengthInOut-1] contain
- filtered samples */
-);
-
-void DownSample (
- float *In, /* (i) input samples */
- float *Coef, /* (i) filter coefficients */
- int lengthIn, /* (i) number of input samples */
- float *state, /* (i) filter state */
- float *Out /* (o) downsampled output */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ filter.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_FILTER_H
+#define __iLBC_FILTER_H
+
+void AllPoleFilter(
+ float *InOut, /* (i/o) on entrance InOut[-orderCoef] to
+ InOut[-1] contain the state of the
+ filter (delayed samples). InOut[0] to
+ InOut[lengthInOut-1] contain the filter
+ input, on en exit InOut[-orderCoef] to
+ InOut[-1] is unchanged and InOut[0] to
+ InOut[lengthInOut-1] contain filtered
+ samples */
+ float *Coef,/* (i) filter coefficients, Coef[0] is assumed
+ to be 1.0 */
+ int lengthInOut,/* (i) number of input/output samples */
+ int orderCoef /* (i) number of filter coefficients */
+);
+
+
+
+void AllZeroFilter(
+ float *In, /* (i) In[0] to In[lengthInOut-1] contain
+ filter input samples */
+ float *Coef,/* (i) filter coefficients (Coef[0] is assumed
+ to be 1.0) */
+ int lengthInOut,/* (i) number of input/output samples */
+ int orderCoef, /* (i) number of filter coefficients */
+ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
+ contain the filter state, on exit Out[0]
+ to Out[lengthInOut-1] contain filtered
+ samples */
+);
+
+void ZeroPoleFilter(
+ float *In, /* (i) In[0] to In[lengthInOut-1] contain filter
+ input samples In[-orderCoef] to In[-1]
+ contain state of all-zero section */
+ float *ZeroCoef,/* (i) filter coefficients for all-zero
+ section (ZeroCoef[0] is assumed to
+ be 1.0) */
+ float *PoleCoef,/* (i) filter coefficients for all-pole section
+ (ZeroCoef[0] is assumed to be 1.0) */
+ int lengthInOut,/* (i) number of input/output samples */
+ int orderCoef, /* (i) number of filter coefficients */
+ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
+ contain state of all-pole section. On
+ exit Out[0] to Out[lengthInOut-1]
+ contain filtered samples */
+);
+
+void DownSample (
+ float *In, /* (i) input samples */
+ float *Coef, /* (i) filter coefficients */
+ int lengthIn, /* (i) number of input samples */
+ float *state, /* (i) filter state */
+ float *Out /* (o) downsampled output */
+);
+
+#endif
+
+
Index: gainquant.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/gainquant.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- gainquant.c 15 Aug 2003 04:38:39 -0000 1.2
+++ gainquant.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,104 +1,106 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- gainquant.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <string.h>
-#include <math.h>
-#include "constants.h"
-#include "filter.h"
-#include "gainquant.h"
-
-/*----------------------------------------------------------------*
- * quantizer for the gain in the gain-shape coding of residual
- *---------------------------------------------------------------*/
-
-float gainquant(/* (o) quantized gain value */
- float in, /* (i) gain value */
- float maxIn,/* (i) maximum of gain value */
- int cblen, /* (i) number of quantization indices */
- int *index /* (o) quantization index */
-){
- int i, tindex;
- float minmeasure,measure, *cb, scale;
-
- /* ensure a lower bound on the scaling factor */
-
- scale=maxIn;
-
- if (scale<0.1) {
- scale=(float)0.1;
- }
-
- /* select the quantization table */
-
- if (cblen == 8) {
- cb = gain_sq3Tbl;
- } else if (cblen == 16) {
- cb = gain_sq4Tbl;
- } else {
- cb = gain_sq5Tbl;
- }
-
- /* select the best index in the quantization table */
-
- minmeasure=10000000.0;
- tindex=0;
- for (i=0;i<cblen;i++) {
- measure=(in-scale*cb[i])*(in-scale*cb[i]);
-
- if (measure<minmeasure) {
- tindex=i;
- minmeasure=measure;
- }
- }
- *index=tindex;
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ gainquant.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+
+
+******************************************************************/
+
+#include <string.h>
+#include <math.h>
+#include "constants.h"
+#include "filter.h"
+
+/*----------------------------------------------------------------*
+ * quantizer for the gain in the gain-shape coding of residual
+ *---------------------------------------------------------------*/
+
+float gainquant(/* (o) quantized gain value */
+ float in, /* (i) gain value */
+ float maxIn,/* (i) maximum of gain value */
+ int cblen, /* (i) number of quantization indices */
+ int *index /* (o) quantization index */
+){
+ int i, tindex;
+ float minmeasure,measure, *cb, scale;
+
+ /* ensure a lower bound on the scaling factor */
+
+ scale=maxIn;
+
+ if (scale<0.1) {
+ scale=(float)0.1;
+ }
+
+ /* select the quantization table */
+
+ if (cblen == 8) {
+ cb = gain_sq3Tbl;
+ } else if (cblen == 16) {
+ cb = gain_sq4Tbl;
+ } else {
+ cb = gain_sq5Tbl;
+ }
+
+ /* select the best index in the quantization table */
+
+ minmeasure=10000000.0;
+ tindex=0;
+ for (i=0; i<cblen; i++) {
+ measure=(in-scale*cb[i])*(in-scale*cb[i]);
- /* return the quantized value */
-
- return scale*cb[tindex];
-}
-
-/*----------------------------------------------------------------*
- * decoder for quantized gains in the gain-shape coding of
- * residual
- *---------------------------------------------------------------*/
-
-float gaindequant( /* (o) quantized gain value */
- int index, /* (i) quantization index */
- float maxIn,/* (i) maximum of unquantized gain */
- int cblen /* (i) number of quantization indices */
-){
- float scale;
-
- /* obtain correct scale factor */
-
- scale=(float)fabs(maxIn);
-
- if (scale<0.1) {
- scale=(float)0.1;
- }
-
- /* select the quantization table and return the decoded value */
-
- if (cblen==8) {
- return scale*gain_sq3Tbl[index];
- } else if (cblen==16) {
- return scale*gain_sq4Tbl[index];
- }
- else if (cblen==32) {
- return scale*gain_sq5Tbl[index];
- }
-
- return 0.0;
-}
-
-
+ if (measure<minmeasure) {
+ tindex=i;
+ minmeasure=measure;
+ }
+ }
+ *index=tindex;
+
+ /* return the quantized value */
+
+
+
+ return scale*cb[tindex];
+}
+
+/*----------------------------------------------------------------*
+ * decoder for quantized gains in the gain-shape coding of
+ * residual
+ *---------------------------------------------------------------*/
+
+float gaindequant( /* (o) quantized gain value */
+ int index, /* (i) quantization index */
+ float maxIn,/* (i) maximum of unquantized gain */
+ int cblen /* (i) number of quantization indices */
+){
+ float scale;
+
+ /* obtain correct scale factor */
+
+ scale=(float)fabs(maxIn);
+
+ if (scale<0.1) {
+ scale=(float)0.1;
+ }
+
+ /* select the quantization table and return the decoded value */
+
+ if (cblen==8) {
+ return scale*gain_sq3Tbl[index];
+ } else if (cblen==16) {
+ return scale*gain_sq4Tbl[index];
+ }
+ else if (cblen==32) {
+ return scale*gain_sq5Tbl[index];
+ }
+
+ return 0.0;
+}
+
+
Index: gainquant.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/gainquant.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- gainquant.h 15 Apr 2003 04:36:52 -0000 1.1
+++ gainquant.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,32 +1,31 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- gainquant.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_GAINQUANT_H
-#define __iLBC_GAINQUANT_H
-
-float gainquant(/* (o) quantized gain value */
- float in, /* (i) gain value */
- float maxIn,/* (i) maximum of gain value */
- int cblen, /* (i) number of quantization indices */
- int *index /* (o) quantization index */
-);
-
-float gaindequant( /* (o) quantized gain value */
- int index, /* (i) quantization index */
- float maxIn,/* (i) maximum of unquantized gain */
- int cblen /* (i) number of quantization indices */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ gainquant.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_GAINQUANT_H
+#define __iLBC_GAINQUANT_H
+
+float gainquant(/* (o) quantized gain value */
+ float in, /* (i) gain value */
+ float maxIn,/* (i) maximum of gain value */
+ int cblen, /* (i) number of quantization indices */
+ int *index /* (o) quantization index */
+);
+
+float gaindequant( /* (o) quantized gain value */
+ int index, /* (i) quantization index */
+ float maxIn,/* (i) maximum of unquantized gain */
+ int cblen /* (i) number of quantization indices */
+);
+
+#endif
+
+
Index: getCBvec.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/getCBvec.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- getCBvec.c 15 Aug 2003 04:38:39 -0000 1.2
+++ getCBvec.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,172 +1,180 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- getCBvec.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include "iLBC_define.h"
-#include "constants.h"
-#include "getCBvec.h"
-#include <string.h>
-
-/*----------------------------------------------------------------*
- * Construct codebook vector for given index.
- *---------------------------------------------------------------*/
-
-void getCBvec(
- float *cbvec, /* (o) Constructed codebook vector */
- float *mem, /* (i) Codebook buffer */
- int index, /* (i) Codebook index */
- int lMem, /* (i) Length of codebook buffer */
- int cbveclen/* (i) Codebook vector length */
-){
- int j, k, n, memInd, sFilt;
- float tmpbuf[CB_MEML];
- int base_size;
- int ilow, ihigh;
- float alfa, alfa1;
-
- /* Determine size of codebook sections */
-
- base_size=lMem-cbveclen+1;
-
- if (cbveclen==SUBL) {
- base_size+=cbveclen/2;
- }
-
- /* No filter -> First codebook section */
-
- if (index<lMem-cbveclen+1) {
-
- /* first non-interpolated vectors */
-
- k=index+cbveclen;
- /* get vector */
- memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
-
- } else if (index < base_size) {
-
- k=2*(index-(lMem-cbveclen+1))+cbveclen;
-
- ihigh=k/2;
- ilow=ihigh-5;
-
- /* Copy first noninterpolated part */
-
- memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
-
- /* interpolation */
-
- alfa1=(float)0.2;
- alfa=0.0;
- for (j=ilow; j<ihigh; j++) {
- cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+
- alfa*mem[lMem-k+j];
- alfa+=alfa1;
- }
-
- /* Copy second noninterpolated part */
-
- memcpy(cbvec+ihigh, mem+lMem-k+ihigh,
- (cbveclen-ihigh)*sizeof(float));
-
- }
-
- /* Higher codebbok section based on filtering */
-
- else {
-
- /* first non-interpolated vectors */
-
- if (index-base_size<lMem-cbveclen+1) {
- float tempbuff2[CB_MEML+CB_FILTERLEN+1];
- float *pos;
- float *pp, *pp1;
-
- memset(tempbuff2, 0, CB_HALFFILTERLEN*sizeof(float));
- memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
- lMem*sizeof(float));
- memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
- (CB_HALFFILTERLEN+1)*sizeof(float));
-
- k=index-base_size+cbveclen;
- sFilt=lMem-k;
- memInd=sFilt+1-CB_HALFFILTERLEN;
-
- /* do filtering */
- pos=cbvec;
- memset(pos, 0, cbveclen*sizeof(float));
- for (n=0; n<cbveclen; n++) {
- pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];
- pp1=&cbfiltersTbl[0];
- for (j=0;j<CB_FILTERLEN;j++) {
- (*pos)+=(*pp++)*(*pp1++);
- }
- pos++;
- }
- }
-
- /* interpolated vectors */
-
- else {
- float tempbuff2[CB_MEML+CB_FILTERLEN+1];
-
- float *pos;
- float *pp, *pp1;
- int i;
-
- memset(tempbuff2, 0, CB_HALFFILTERLEN*sizeof(float));
- memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
- lMem*sizeof(float));
- memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
- (CB_HALFFILTERLEN+1)*sizeof(float));
-
- k=2*(index-base_size-(lMem-cbveclen+1))+cbveclen;
- sFilt=lMem-k;
- memInd=sFilt+1-CB_HALFFILTERLEN;
-
- /* do filtering */
- pos=&tmpbuf[sFilt];
- memset(pos, 0, k*sizeof(float));
- for (i=0; i<k; i++) {
- pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];
- pp1=&cbfiltersTbl[0];
- for (j=0;j<CB_FILTERLEN;j++) {
- (*pos)+=(*pp++)*(*pp1++);
- }
- pos++;
- }
-
- ihigh=k/2;
- ilow=ihigh-5;
-
- /* Copy first noninterpolated part */
-
- memcpy(cbvec, tmpbuf+lMem-k/2, ilow*sizeof(float));
-
- /* interpolation */
-
- alfa1=(float)0.2;
- alfa=0.0;
- for (j=ilow; j<ihigh; j++) {
- cbvec[j]=((float)1.0-alfa)*
- tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];
- alfa+=alfa1;
- }
-
- /* Copy second noninterpolated part */
-
- memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,
- (cbveclen-ihigh)*sizeof(float));
- }
- }
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ getCBvec.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include <string.h>
+
+/*----------------------------------------------------------------*
+ * Construct codebook vector for given index.
+ *---------------------------------------------------------------*/
+
+void getCBvec(
+ float *cbvec, /* (o) Constructed codebook vector */
+ float *mem, /* (i) Codebook buffer */
+ int index, /* (i) Codebook index */
+ int lMem, /* (i) Length of codebook buffer */
+ int cbveclen/* (i) Codebook vector length */
+){
+ int j, k, n, memInd, sFilt;
+ float tmpbuf[CB_MEML];
+ int base_size;
+ int ilow, ihigh;
+ float alfa, alfa1;
+
+ /* Determine size of codebook sections */
+
+ base_size=lMem-cbveclen+1;
+
+ if (cbveclen==SUBL) {
+ base_size+=cbveclen/2;
+ }
+
+ /* No filter -> First codebook section */
+
+
+
+ if (index<lMem-cbveclen+1) {
+
+ /* first non-interpolated vectors */
+
+ k=index+cbveclen;
+ /* get vector */
+ memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
+
+ } else if (index < base_size) {
+
+ k=2*(index-(lMem-cbveclen+1))+cbveclen;
+
+ ihigh=k/2;
+ ilow=ihigh-5;
+
+ /* Copy first noninterpolated part */
+
+ memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
+
+ /* interpolation */
+
+ alfa1=(float)0.2;
+ alfa=0.0;
+ for (j=ilow; j<ihigh; j++) {
+ cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+
+ alfa*mem[lMem-k+j];
+ alfa+=alfa1;
+ }
+
+ /* Copy second noninterpolated part */
+
+ memcpy(cbvec+ihigh, mem+lMem-k+ihigh,
+ (cbveclen-ihigh)*sizeof(float));
+
+ }
+
+ /* Higher codebbok section based on filtering */
+
+ else {
+
+ /* first non-interpolated vectors */
+
+ if (index-base_size<lMem-cbveclen+1) {
+ float tempbuff2[CB_MEML+CB_FILTERLEN+1];
+ float *pos;
+ float *pp, *pp1;
+
+ memset(tempbuff2, 0,
+ CB_HALFFILTERLEN*sizeof(float));
+ memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
+ lMem*sizeof(float));
+ memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
+ (CB_HALFFILTERLEN+1)*sizeof(float));
+
+
+
+ k=index-base_size+cbveclen;
+ sFilt=lMem-k;
+ memInd=sFilt+1-CB_HALFFILTERLEN;
+
+ /* do filtering */
+ pos=cbvec;
+ memset(pos, 0, cbveclen*sizeof(float));
+ for (n=0; n<cbveclen; n++) {
+ pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];
+ pp1=&cbfiltersTbl[CB_FILTERLEN-1];
+ for (j=0; j<CB_FILTERLEN; j++) {
+ (*pos)+=(*pp++)*(*pp1--);
+ }
+ pos++;
+ }
+ }
+
+ /* interpolated vectors */
+
+ else {
+ float tempbuff2[CB_MEML+CB_FILTERLEN+1];
+
+ float *pos;
+ float *pp, *pp1;
+ int i;
+
+ memset(tempbuff2, 0,
+ CB_HALFFILTERLEN*sizeof(float));
+ memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
+ lMem*sizeof(float));
+ memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
+ (CB_HALFFILTERLEN+1)*sizeof(float));
+
+ k=2*(index-base_size-
+ (lMem-cbveclen+1))+cbveclen;
+ sFilt=lMem-k;
+ memInd=sFilt+1-CB_HALFFILTERLEN;
+
+ /* do filtering */
+ pos=&tmpbuf[sFilt];
+ memset(pos, 0, k*sizeof(float));
+ for (i=0; i<k; i++) {
+ pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];
+ pp1=&cbfiltersTbl[CB_FILTERLEN-1];
+ for (j=0; j<CB_FILTERLEN; j++) {
+ (*pos)+=(*pp++)*(*pp1--);
+ }
+ pos++;
+ }
+
+ ihigh=k/2;
+ ilow=ihigh-5;
+
+
+
+ /* Copy first noninterpolated part */
+
+ memcpy(cbvec, tmpbuf+lMem-k/2,
+ ilow*sizeof(float));
+
+ /* interpolation */
+
+ alfa1=(float)0.2;
+ alfa=0.0;
+ for (j=ilow; j<ihigh; j++) {
+ cbvec[j]=((float)1.0-alfa)*
+ tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];
+ alfa+=alfa1;
+ }
+
+ /* Copy second noninterpolated part */
+
+ memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,
+ (cbveclen-ihigh)*sizeof(float));
+ }
+ }
+}
+
+
Index: getCBvec.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/getCBvec.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- getCBvec.h 15 Apr 2003 04:36:52 -0000 1.1
+++ getCBvec.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,27 +1,28 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- getCBvec.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_GETCBVEC_H
-#define __iLBC_GETCBVEC_H
-
-void getCBvec(
- float *cbvec, /* (o) Constructed codebook vector */
- float *mem, /* (i) Codebook buffer */
- int index, /* (i) Codebook index */
- int lMem, /* (i) Length of codebook buffer */
- int cbveclen/* (i) Codebook vector length */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ getCBvec.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_GETCBVEC_H
+#define __iLBC_GETCBVEC_H
+
+
+
+void getCBvec(
+ float *cbvec, /* (o) Constructed codebook vector */
+ float *mem, /* (i) Codebook buffer */
+ int index, /* (i) Codebook index */
+ int lMem, /* (i) Length of codebook buffer */
+ int cbveclen/* (i) Codebook vector length */
+);
+
+#endif
+
+
Index: helpfun.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/helpfun.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- helpfun.c 15 Aug 2003 04:38:39 -0000 1.3
+++ helpfun.c 14 Oct 2004 05:15:48 -0000 1.4
@@ -1,294 +1,307 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- helpfun.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-
-#include "iLBC_define.h"
-#include "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 lbc_window(
- float *z, /* (o) the windowed data */
- const float *x, /* (i) the original data vector */
- const float *y, /* (i) the window */
- int N /* (i) length of all vectors */
-){
- int i;
-
- for (i = 0; i < N; i++) {
- z[i] = x[i] * y[i];
- }
-}
-
-/*----------------------------------------------------------------*
- * levinson-durbin solution for lpc coefficients
- *---------------------------------------------------------------*/
-
-void levdurb(
- float *a, /* (o) lpc coefficient vector starting with 1.0
-*/
- float *k, /* (o) reflection coefficients */
- float *r, /* (i) autocorrelation vector */
- int order /* (i) order of lpc filter */
-){
- float sum, alpha;
- int m, m_h, i;
-
- a[0] = 1.0;
-
- if (r[0] < EPS) { /* if r[0] <= 0, set LPC coeff. to zero */
- for (i = 0; i < order; i++) {
- k[i] = 0;
- a[i+1] = 0;
- }
- } else {
- a[1] = k[0] = -r[1]/r[0];
- alpha = r[0] + r[1] * k[0];
- for (m = 1; m < order; m++){
- sum = r[m + 1];
- for (i = 0; i < m; i++){
- sum += a[i+1] * r[m - i];
- }
- k[m] = -sum / alpha;
- alpha += k[m] * sum;
- m_h = (m + 1) >> 1;
- for (i = 0; i < m_h; i++){
- sum = a[i+1] + k[m] * a[m - i];
- a[m - i] += k[m] * a[i+1];
- a[i+1] = sum;
- }
- a[m+1] = k[m];
- }
- }
-}
-
-/*----------------------------------------------------------------*
- * interpolation between vectors
- *---------------------------------------------------------------*/
-
-void interpolate(
- float *out, /* (o) the interpolated vector */
- float *in1, /* (i) the first vector for the interpolation */
- float *in2, /* (i) the second vector for the interpolation */
- float coef, /* (i) interpolation weights */
- int length /* (i) length of all vectors */
-){
- int i;
- float invcoef;
-
- invcoef = (float)1.0 - coef;
- for (i = 0; i < length; i++) {
- out[i] = coef * in1[i] + invcoef * in2[i];
- }
-}
-
-/*----------------------------------------------------------------*
- * lpc bandwidth expansion
- *---------------------------------------------------------------*/
-
-void bwexpand(
- float *out, /* (o) the bandwidth expanded lpc coefficients */
- float *in, /* (i) the lpc coefficients before bandwidth
- expansion */
- float coef, /* (i) the bandwidth expansion factor */
- int length /* (i) the length of lpc coefficient vectors */
-){
- int i;
- float chirp;
-
- chirp = coef;
-
- out[0] = in[0];
- for (i = 1; i < length; i++) {
- out[i] = chirp * in[i];
- chirp *= coef;
- }
-}
-
-/*----------------------------------------------------------------*
- * vector quantization
- *---------------------------------------------------------------*/
-
-void vq(
- float *Xq, /* (o) the quantized vector */
- int *index, /* (o) the quantization index */
- const float *CB,/* (i) the vector quantization codebook */
- float *X, /* (i) the vector to quantize */
- int n_cb, /* (i) the number of vectors in the codebook */
- int dim /* (i) the dimension of all vectors */
-){
- int i, j;
- int pos, minindex;
- float dist, tmp, mindist;
-
- pos = 0;
- mindist = FLOAT_MAX;
- minindex = 0;
- for (j = 0; j < n_cb; j++) {
- dist = X[0] - CB[pos];
- dist *= dist;
- for (i = 1; i < dim; i++) {
- tmp = X[i] - CB[pos + i];
- dist += tmp*tmp;
- }
-
- if (dist < mindist) {
- mindist = dist;
- minindex = j;
- }
- pos += dim;
- }
- for (i = 0; i < dim; i++) {
- Xq[i] = CB[minindex*dim + i];
- }
- *index = minindex;
-}
-
-/*----------------------------------------------------------------*
- * split vector quantization
- *---------------------------------------------------------------*/
-
-void SplitVQ(
- float *qX, /* (o) the quantized vector */
- int *index, /* (o) a vector of indexes for all vector
- codebooks in the split */
- float *X, /* (i) the vector to quantize */
- const float *CB,/* (i) the quantizer codebook */
- int nsplit, /* the number of vector splits */
- const int *dim, /* the dimension of X and qX */
- const int *cbsize /* the number of vectors in the codebook */
-){
- int cb_pos, X_pos, i;
-
- cb_pos = 0;
- X_pos= 0;
- for (i = 0; i < nsplit; i++) {
- vq(qX + X_pos, index + i, CB + cb_pos, X + X_pos,
- cbsize[i], dim[i]);
- X_pos += dim[i];
- cb_pos += dim[i] * cbsize[i];
- }
-}
-
-/*----------------------------------------------------------------*
- * scalar quantization
- *---------------------------------------------------------------*/
-
-void sort_sq(
- float *xq, /* (o) the quantized value */
- int *index, /* (o) the quantization index */
- float x, /* (i) the value to quantize */
- const float *cb,/* (i) the quantization codebook */
- int cb_size /* (i) the size of the quantization codebook */
-){
- int i;
-
- if (x <= cb[0]) {
- *index = 0;
- *xq = cb[0];
- } else {
- i = 0;
- while ((x > cb[i]) && i < cb_size - 1) {
- i++;
- }
-
- if (x > ((cb[i] + cb[i - 1])/2)) {
- *index = i;
- *xq = cb[i];
- } else {
- *index = i - 1;
- *xq = cb[i - 1];
- }
- }
-}
-
-/*----------------------------------------------------------------*
- * check for stability of lsf coefficients
- *---------------------------------------------------------------*/
-
-int LSF_check( /* (o) 1 for stable lsf vectors and 0 for
- nonstable ones */
- float *lsf, /* (i) a table of lsf vectors */
- int dim, /* (i) the dimension of each lsf vector */
- int NoAn /* (i) the number of lsf vectors in the table */
-){
- int k,n,m, Nit=2, change=0,pos;
- float tmp;
- static float eps=(float)0.039; /* 50 Hz */
- static float eps2=(float)0.0195;
- static float maxlsf=(float)3.14; /* 4000 Hz */
- static float minlsf=(float)0.01; /* 0 Hz */
-
- /* LSF separation check*/
-
- for (n=0;n<Nit;n++) { /* Run through a couple of times */
- for (m=0;m<NoAn;m++) { /* Number of analyses per frame */
- for (k=0;k<(dim-1);k++) {
- pos=m*dim+k;
-
- if ((lsf[pos+1]-lsf[pos])<eps) {
-
- if (lsf[pos+1]<lsf[pos]) {
- tmp=lsf[pos+1];
- lsf[pos+1]= lsf[pos]+eps2;
- lsf[pos]= lsf[pos+1]-eps2;
- } else {
- lsf[pos]-=eps2;
- lsf[pos+1]+=eps2;
- }
- change=1;
- }
-
- if (lsf[pos]<minlsf) {
- lsf[pos]=minlsf;
- change=1;
- }
-
- if (lsf[pos]>maxlsf) {
- lsf[pos]=maxlsf;
- change=1;
- }
- }
- }
- }
-
- return change;
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ helpfun.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * calculation of auto correlation
+ *---------------------------------------------------------------*/
+
+void autocorr(
+ float *r, /* (o) autocorrelation vector */
+ const float *x, /* (i) data vector */
+ int N, /* (i) length of data vector */
+ int order /* largest lag for calculated
+ autocorrelations */
+){
+ int lag, n;
+ float sum;
+
+ for (lag = 0; lag <= order; lag++) {
+ sum = 0;
+ for (n = 0; n < N - lag; n++) {
+ sum += x[n] * x[n+lag];
+ }
+ r[lag] = sum;
+ }
+}
+
+
+
+/*----------------------------------------------------------------*
+ * window multiplication
+ *---------------------------------------------------------------*/
+
+void window(
+ float *z, /* (o) the windowed data */
+ const float *x, /* (i) the original data vector */
+ const float *y, /* (i) the window */
+ int N /* (i) length of all vectors */
+){
+ int i;
+
+ for (i = 0; i < N; i++) {
+ z[i] = x[i] * y[i];
+ }
+}
+
+/*----------------------------------------------------------------*
+ * levinson-durbin solution for lpc coefficients
+ *---------------------------------------------------------------*/
+
+void levdurb(
+ float *a, /* (o) lpc coefficient vector starting
+ with 1.0 */
+ float *k, /* (o) reflection coefficients */
+ float *r, /* (i) autocorrelation vector */
+ int order /* (i) order of lpc filter */
+){
+ float sum, alpha;
+ int m, m_h, i;
+
+ a[0] = 1.0;
+
+ if (r[0] < EPS) { /* if r[0] <= 0, set LPC coeff. to zero */
+ for (i = 0; i < order; i++) {
+ k[i] = 0;
+ a[i+1] = 0;
+ }
+ } else {
+ a[1] = k[0] = -r[1]/r[0];
+ alpha = r[0] + r[1] * k[0];
+ for (m = 1; m < order; m++){
+ sum = r[m + 1];
+ for (i = 0; i < m; i++){
+ sum += a[i+1] * r[m - i];
+ }
+ k[m] = -sum / alpha;
+ alpha += k[m] * sum;
+ m_h = (m + 1) >> 1;
+ for (i = 0; i < m_h; i++){
+ sum = a[i+1] + k[m] * a[m - i];
+ a[m - i] += k[m] * a[i+1];
+ a[i+1] = sum;
+
+
+ }
+ a[m+1] = k[m];
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * interpolation between vectors
+ *---------------------------------------------------------------*/
+
+void interpolate(
+ float *out, /* (o) the interpolated vector */
+ float *in1, /* (i) the first vector for the
+ interpolation */
+ float *in2, /* (i) the second vector for the
+ interpolation */
+ float coef, /* (i) interpolation weights */
+ int length /* (i) length of all vectors */
+){
+ int i;
+ float invcoef;
+
+ invcoef = (float)1.0 - coef;
+ for (i = 0; i < length; i++) {
+ out[i] = coef * in1[i] + invcoef * in2[i];
+ }
+}
+
+/*----------------------------------------------------------------*
+ * lpc bandwidth expansion
+ *---------------------------------------------------------------*/
+
+void bwexpand(
+ float *out, /* (o) the bandwidth expanded lpc
+ coefficients */
+ float *in, /* (i) the lpc coefficients before bandwidth
+ expansion */
+ float coef, /* (i) the bandwidth expansion factor */
+ int length /* (i) the length of lpc coefficient vectors */
+){
+ int i;
+ float chirp;
+
+ chirp = coef;
+
+ out[0] = in[0];
+ for (i = 1; i < length; i++) {
+ out[i] = chirp * in[i];
+ chirp *= coef;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * vector quantization
+
+
+ *---------------------------------------------------------------*/
+
+void vq(
+ float *Xq, /* (o) the quantized vector */
+ int *index, /* (o) the quantization index */
+ const float *CB,/* (i) the vector quantization codebook */
+ float *X, /* (i) the vector to quantize */
+ int n_cb, /* (i) the number of vectors in the codebook */
+ int dim /* (i) the dimension of all vectors */
+){
+ int i, j;
+ int pos, minindex;
+ float dist, tmp, mindist;
+
+ pos = 0;
+ mindist = FLOAT_MAX;
+ minindex = 0;
+ for (j = 0; j < n_cb; j++) {
+ dist = X[0] - CB[pos];
+ dist *= dist;
+ for (i = 1; i < dim; i++) {
+ tmp = X[i] - CB[pos + i];
+ dist += tmp*tmp;
+ }
+
+ if (dist < mindist) {
+ mindist = dist;
+ minindex = j;
+ }
+ pos += dim;
+ }
+ for (i = 0; i < dim; i++) {
+ Xq[i] = CB[minindex*dim + i];
+ }
+ *index = minindex;
+}
+
+/*----------------------------------------------------------------*
+ * split vector quantization
+ *---------------------------------------------------------------*/
+
+void SplitVQ(
+ float *qX, /* (o) the quantized vector */
+ int *index, /* (o) a vector of indexes for all vector
+ codebooks in the split */
+ float *X, /* (i) the vector to quantize */
+ const float *CB,/* (i) the quantizer codebook */
+ int nsplit, /* the number of vector splits */
+ const int *dim, /* the dimension of X and qX */
+ const int *cbsize /* the number of vectors in the codebook */
+){
+ int cb_pos, X_pos, i;
+
+ cb_pos = 0;
+
+
+ X_pos= 0;
+ for (i = 0; i < nsplit; i++) {
+ vq(qX + X_pos, index + i, CB + cb_pos, X + X_pos,
+ cbsize[i], dim[i]);
+ X_pos += dim[i];
+ cb_pos += dim[i] * cbsize[i];
+ }
+}
+
+/*----------------------------------------------------------------*
+ * scalar quantization
+ *---------------------------------------------------------------*/
+
+void sort_sq(
+ float *xq, /* (o) the quantized value */
+ int *index, /* (o) the quantization index */
+ float x, /* (i) the value to quantize */
+ const float *cb,/* (i) the quantization codebook */
+ int cb_size /* (i) the size of the quantization codebook */
+){
+ int i;
+
+ if (x <= cb[0]) {
+ *index = 0;
+ *xq = cb[0];
+ } else {
+ i = 0;
+ while ((x > cb[i]) && i < cb_size - 1) {
+ i++;
+ }
+
+ if (x > ((cb[i] + cb[i - 1])/2)) {
+ *index = i;
+ *xq = cb[i];
+ } else {
+ *index = i - 1;
+ *xq = cb[i - 1];
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * check for stability of lsf coefficients
+ *---------------------------------------------------------------*/
+
+int LSF_check( /* (o) 1 for stable lsf vectors and 0 for
+ nonstable ones */
+ float *lsf, /* (i) a table of lsf vectors */
+ int dim, /* (i) the dimension of each lsf vector */
+ int NoAn /* (i) the number of lsf vectors in the
+ table */
+){
+ int k,n,m, Nit=2, change=0,pos;
+ float tmp;
+
+
+ static float eps=(float)0.039; /* 50 Hz */
+ static float eps2=(float)0.0195;
+ static float maxlsf=(float)3.14; /* 4000 Hz */
+ static float minlsf=(float)0.01; /* 0 Hz */
+
+ /* LSF separation check*/
+
+ for (n=0; n<Nit; n++) { /* Run through a couple of times */
+ for (m=0; m<NoAn; m++) { /* Number of analyses per frame */
+ for (k=0; k<(dim-1); k++) {
+ pos=m*dim+k;
+
+ if ((lsf[pos+1]-lsf[pos])<eps) {
+
+ if (lsf[pos+1]<lsf[pos]) {
+ tmp=lsf[pos+1];
+ lsf[pos+1]= lsf[pos]+eps2;
+ lsf[pos]= lsf[pos+1]-eps2;
+ } else {
+ lsf[pos]-=eps2;
+ lsf[pos+1]+=eps2;
+ }
+ change=1;
+ }
+
+ if (lsf[pos]<minlsf) {
+ lsf[pos]=minlsf;
+ change=1;
+ }
+
+ if (lsf[pos]>maxlsf) {
+ lsf[pos]=maxlsf;
+ change=1;
+ }
+ }
+ }
+ }
+
+ return change;
+}
+
+
Index: helpfun.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/helpfun.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- helpfun.h 23 Apr 2003 16:23:12 -0000 1.2
+++ helpfun.h 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,93 +1,101 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- helpfun.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_HELPFUN_H
-#define __iLBC_HELPFUN_H
-
-void autocorr(
- float *r, /* (o) autocorrelation vector */
- const float *x, /* (i) data vector */
- int N, /* (i) length of data vector */
- int order /* largest lag for calculated autocorrelations */
-);
-
-void lbc_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
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: hpInput.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/hpInput.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- hpInput.c 15 Aug 2003 04:38:39 -0000 1.2
+++ hpInput.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,59 +1,59 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- hpInput.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- 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<len; i++) {
- *po = hpi_zero_coefsTbl[0] * (*pi);
- *po += hpi_zero_coefsTbl[1] * mem[0];
- *po += hpi_zero_coefsTbl[2] * mem[1];
-
- mem[1] = mem[0];
- mem[0] = *pi;
- po++;
- pi++;
-
- }
-
- /* all-pole section*/
-
- po = &Out[0];
- for (i=0; i<len; i++) {
- *po -= hpi_pole_coefsTbl[1] * mem[2];
- *po -= hpi_pole_coefsTbl[2] * mem[3];
-
- mem[3] = mem[2];
- mem[2] = *po;
- po++;
- }
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpInput.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * Input high-pass filter
+ *---------------------------------------------------------------*/
+
+void hpInput(
+ float *In, /* (i) vector to filter */
+ int len, /* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+){
+ int i;
+ float *pi, *po;
+
+ /* all-zero section*/
+
+ pi = &In[0];
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po = hpi_zero_coefsTbl[0] * (*pi);
+ *po += hpi_zero_coefsTbl[1] * mem[0];
+ *po += hpi_zero_coefsTbl[2] * mem[1];
+
+ mem[1] = mem[0];
+ mem[0] = *pi;
+ po++;
+
+
+ pi++;
+
+ }
+
+ /* all-pole section*/
+
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po -= hpi_pole_coefsTbl[1] * mem[2];
+ *po -= hpi_pole_coefsTbl[2] * mem[3];
+
+ mem[3] = mem[2];
+ mem[2] = *po;
+ po++;
+ }
+}
+
+
Index: hpInput.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/hpInput.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- hpInput.h 15 Apr 2003 04:36:52 -0000 1.1
+++ hpInput.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,26 +1,27 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- hpInput.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_HPINPUT_H
-#define __iLBC_HPINPUT_H
-
-void hpInput(
- float *In, /* (i) vector to filter */
- int len, /* (i) length of vector to filter */
- float *Out, /* (o) the resulting filtered vector */
- float *mem /* (i/o) the filter state */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpInput.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+
+
+#ifndef __iLBC_HPINPUT_H
+#define __iLBC_HPINPUT_H
+
+void hpInput(
+ float *In, /* (i) vector to filter */
+ int len, /* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+);
+
+#endif
+
+
Index: hpOutput.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/hpOutput.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- hpOutput.c 15 Aug 2003 04:38:39 -0000 1.2
+++ hpOutput.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,59 +1,59 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- hpOutput.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include "constants.h"
-#include "hpOutput.h"
-
-/*----------------------------------------------------------------*
- * Output high-pass filter
- *---------------------------------------------------------------*/
-
-void hpOutput(
- float *In, /* (i) vector to filter */
- int len,/* (i) length of vector to filter */
- float *Out, /* (o) the resulting filtered vector */
- float *mem /* (i/o) the filter state */
-){
- int i;
- float *pi, *po;
-
- /* all-zero section*/
-
- pi = &In[0];
- po = &Out[0];
- for (i=0; i<len; i++) {
- *po = hpo_zero_coefsTbl[0] * (*pi);
- *po += hpo_zero_coefsTbl[1] * mem[0];
- *po += hpo_zero_coefsTbl[2] * mem[1];
-
- mem[1] = mem[0];
- mem[0] = *pi;
- po++;
- pi++;
-
- }
-
- /* all-pole section*/
-
- po = &Out[0];
- for (i=0; i<len; i++) {
- *po -= hpo_pole_coefsTbl[1] * mem[2];
- *po -= hpo_pole_coefsTbl[2] * mem[3];
-
- mem[3] = mem[2];
- mem[2] = *po;
- po++;
- }
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpOutput.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+
+
+******************************************************************/
+
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * Output high-pass filter
+ *---------------------------------------------------------------*/
+
+void hpOutput(
+ float *In, /* (i) vector to filter */
+ int len,/* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+){
+ int i;
+ float *pi, *po;
+
+ /* all-zero section*/
+
+ pi = &In[0];
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po = hpo_zero_coefsTbl[0] * (*pi);
+ *po += hpo_zero_coefsTbl[1] * mem[0];
+ *po += hpo_zero_coefsTbl[2] * mem[1];
+
+ mem[1] = mem[0];
+ mem[0] = *pi;
+ po++;
+ pi++;
+
+ }
+
+ /* all-pole section*/
+
+ po = &Out[0];
+ for (i=0; i<len; i++) {
+ *po -= hpo_pole_coefsTbl[1] * mem[2];
+ *po -= hpo_pole_coefsTbl[2] * mem[3];
+
+ mem[3] = mem[2];
+ mem[2] = *po;
+ po++;
+ }
+}
+
+
Index: hpOutput.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/hpOutput.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- hpOutput.h 15 Apr 2003 04:36:52 -0000 1.1
+++ hpOutput.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,26 +1,25 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- hpOutput.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_HPOUTPUT_H
-#define __iLBC_HPOUTPUT_H
-
-void hpOutput(
- float *In, /* (i) vector to filter */
- int len,/* (i) length of vector to filter */
- float *Out, /* (o) the resulting filtered vector */
- float *mem /* (i/o) the filter state */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ hpOutput.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_HPOUTPUT_H
+#define __iLBC_HPOUTPUT_H
+
+void hpOutput(
+ float *In, /* (i) vector to filter */
+ int len,/* (i) length of vector to filter */
+ float *Out, /* (o) the resulting filtered vector */
+ float *mem /* (i/o) the filter state */
+);
+
+#endif
+
+
Index: iCBConstruct.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iCBConstruct.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- iCBConstruct.c 15 Aug 2003 04:38:39 -0000 1.2
+++ iCBConstruct.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,105 +1,107 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iCBConstruct.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-
-#include "iLBC_define.h"
-#include "gainquant.h"
-#include "getCBvec.h"
-#include "iCBConstruct.h"
-
-/*----------------------------------------------------------------*
- * Convert the codebook indexes to make the search easier
- *---------------------------------------------------------------*/
-
-void index_conv_enc(
- int *index /* (i/o) Codebook indexes */
-){
- int k;
-
- for (k=1;k<CB_NSTAGES;k++) {
-
- if ((index[k]>=108)&&(index[k]<172)) {
- index[k]-=64;
- } else if (index[k]>=236) {
- index[k]-=128;
- } else {
- /* ERROR */
- }
- }
-}
-
-void index_conv_dec(
- int *index /* (i/o) Codebook indexes */
-){
- int k;
-
- for (k=1;k<CB_NSTAGES;k++) {
-
- if ((index[k]>=44)&&(index[k]<108)) {
- index[k]+=64;
- } else if ((index[k]>=108)&&(index[k]<128)) {
- index[k]+=128;
- } else {
- /* ERROR */
- }
- }
-}
-
-/*----------------------------------------------------------------*
- * Construct decoded vector from codebook and gains.
- *---------------------------------------------------------------*/
-
-void iCBConstruct(
- float *decvector, /* (o) Decoded vector */
- int *index, /* (i) Codebook indices */
- int *gain_index,/* (i) Gain quantization indices */
- float *mem, /* (i) Buffer for codevector construction */
- int lMem, /* (i) Length of buffer */
- int veclen, /* (i) Length of vector */
- int nStages /* (i) Number of codebook stages */
-){
- int j,k;
- float gain[CB_NSTAGES];
- float cbvec[SUBL];
-
- /* gain de-quantization */
-
- gain[0] = gaindequant(gain_index[0], 1.0, 32);
- if (nStages > 1) {
- gain[1] = gaindequant(gain_index[1],
- (float)fabs(gain[0]), 16);
- }
- if (nStages > 2) {
- gain[2] = gaindequant(gain_index[2],
- (float)fabs(gain[1]), 8);
- }
-
- /* codebook vector construction and construction of
- total vector */
-
- getCBvec(cbvec, mem, index[0], lMem, veclen);
- for (j=0;j<veclen;j++){
- decvector[j] = gain[0]*cbvec[j];
- }
- if (nStages > 1) {
- for (k=1; k<nStages; k++) {
- getCBvec(cbvec, mem, index[k], lMem, veclen);
- for (j=0;j<veclen;j++) {
- decvector[j] += gain[k]*cbvec[j];
- }
- }
- }
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBConstruct.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+
+#include "iLBC_define.h"
+#include "gainquant.h"
+#include "getCBvec.h"
+
+/*----------------------------------------------------------------*
+ * Convert the codebook indexes to make the search easier
+ *---------------------------------------------------------------*/
+
+
+
+void index_conv_enc(
+ int *index /* (i/o) Codebook indexes */
+){
+ int k;
+
+ for (k=1; k<CB_NSTAGES; k++) {
+
+ if ((index[k]>=108)&&(index[k]<172)) {
+ index[k]-=64;
+ } else if (index[k]>=236) {
+ index[k]-=128;
+ } else {
+ /* ERROR */
+ }
+ }
+}
+
+void index_conv_dec(
+ int *index /* (i/o) Codebook indexes */
+){
+ int k;
+
+ for (k=1; k<CB_NSTAGES; k++) {
+
+ if ((index[k]>=44)&&(index[k]<108)) {
+ index[k]+=64;
+ } else if ((index[k]>=108)&&(index[k]<128)) {
+ index[k]+=128;
+ } else {
+ /* ERROR */
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * Construct decoded vector from codebook and gains.
+ *---------------------------------------------------------------*/
+
+void iCBConstruct(
+ float *decvector, /* (o) Decoded vector */
+ int *index, /* (i) Codebook indices */
+ int *gain_index,/* (i) Gain quantization indices */
+ float *mem, /* (i) Buffer for codevector construction */
+ int lMem, /* (i) Length of buffer */
+ int veclen, /* (i) Length of vector */
+ int nStages /* (i) Number of codebook stages */
+){
+ int j,k;
+ float gain[CB_NSTAGES];
+ float cbvec[SUBL];
+
+ /* gain de-quantization */
+
+ gain[0] = gaindequant(gain_index[0], 1.0, 32);
+
+
+ if (nStages > 1) {
+ gain[1] = gaindequant(gain_index[1],
+ (float)fabs(gain[0]), 16);
+ }
+ if (nStages > 2) {
+ gain[2] = gaindequant(gain_index[2],
+ (float)fabs(gain[1]), 8);
+ }
+
+ /* codebook vector construction and construction of
+ total vector */
+
+ getCBvec(cbvec, mem, index[0], lMem, veclen);
+ for (j=0;j<veclen;j++){
+ decvector[j] = gain[0]*cbvec[j];
+ }
+ if (nStages > 1) {
+ for (k=1; k<nStages; k++) {
+ getCBvec(cbvec, mem, index[k], lMem, veclen);
+ for (j=0;j<veclen;j++) {
+ decvector[j] += gain[k]*cbvec[j];
+ }
+ }
+ }
+}
+
+
Index: iCBConstruct.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iCBConstruct.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- iCBConstruct.h 15 Apr 2003 04:36:52 -0000 1.1
+++ iCBConstruct.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,37 +1,38 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iCBConstruct.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_ICBCONSTRUCT_H
-#define __iLBC_ICBCONSTRUCT_H
-
-void index_conv_enc(
- int *index /* (i/o) Codebook indexes */
-);
-
-void index_conv_dec(
- int *index /* (i/o) Codebook indexes */
-);
-
-void iCBConstruct(
- float *decvector, /* (o) Decoded vector */
- int *index, /* (i) Codebook indices */
- int *gain_index,/* (i) Gain quantization indices */
- float *mem, /* (i) Buffer for codevector construction */
- int lMem, /* (i) Length of buffer */
- int veclen, /* (i) Length of vector */
- int nStages /* (i) Number of codebook stages */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+
+
+ iCBConstruct.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ICBCONSTRUCT_H
+#define __iLBC_ICBCONSTRUCT_H
+
+void index_conv_enc(
+ int *index /* (i/o) Codebook indexes */
+);
+
+void index_conv_dec(
+ int *index /* (i/o) Codebook indexes */
+);
+
+void iCBConstruct(
+ float *decvector, /* (o) Decoded vector */
+ int *index, /* (i) Codebook indices */
+ int *gain_index,/* (i) Gain quantization indices */
+ float *mem, /* (i) Buffer for codevector construction */
+ int lMem, /* (i) Length of buffer */
+ int veclen, /* (i) Length of vector */
+ int nStages /* (i) Number of codebook stages */
+);
+
+#endif
+
+
Index: iCBSearch.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iCBSearch.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- iCBSearch.c 27 Sep 2003 02:18:53 -0000 1.4
+++ iCBSearch.c 14 Oct 2004 05:15:48 -0000 1.5
@@ -1,464 +1,477 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iCBSearch.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <string.h>
-
-#include "iLBC_define.h"
-#include "iCBSearch.h"
-#include "gainquant.h"
-#include "createCB.h"
-#include "filter.h"
-#include "constants.h"
-
-/*----------------------------------------------------------------*
- * Search routine for codebook encoding and gain quantization.
- *---------------------------------------------------------------*/
-
-void iCBSearch(
- int *index, /* (o) Codebook indices */
- int *gain_index,/* (o) Gain quantization indices */
- float *intarget,/* (i) Target vector for encoding */
- float *mem, /* (i) Buffer for codebook construction */
- int lMem, /* (i) Length of buffer */
- int lTarget, /* (i) Length of vector */
- int nStages, /* (i) Number of codebook stages */
- float *weightDenum, /* (i) weighting filter coefficients */
- float *weightState, /* (i) weighting filter state */
- int block /* (i) the subblock number */
-){
- int i, j, icount, stage, best_index, range, counter;
- float max_measure, gain, measure, crossDot, ftmp;
- float gains[CB_NSTAGES];
- float target[SUBL];
- int base_index, sInd, eInd, base_size;
- int sIndAug=0, eIndAug=0;
- float buf[CB_MEML+SUBL+2*LPC_FILTERORDER];
- float invenergy[CB_EXPAND*128], energy[CB_EXPAND*128];
- float *pp, *ppi=0, *ppo=0, *ppe=0;
- float cbvectors[CB_MEML];
- float tene, cene, cvec[SUBL];
- float aug_vec[SUBL];
-
- memset(cvec,0,SUBL*sizeof(float));
-
- /* Determine size of codebook sections */
-
- base_size=lMem-lTarget+1;
-
- if (lTarget==SUBL) {
- base_size=lMem-lTarget+1+lTarget/2;
- }
-
- /* setup buffer for weighting */
-
- memcpy(buf,weightState,sizeof(float)*LPC_FILTERORDER);
- memcpy(buf+LPC_FILTERORDER,mem,lMem*sizeof(float));
- memcpy(buf+LPC_FILTERORDER+lMem,intarget,lTarget*sizeof(float));
-
- /* weighting */
-
- AllPoleFilter(buf+LPC_FILTERORDER, weightDenum,
- lMem+lTarget, LPC_FILTERORDER);
-
- /* Construct the codebook and target needed */
-
- memcpy(target, buf+LPC_FILTERORDER+lMem, lTarget*sizeof(float));
-
- tene=0.0;
- for (i=0;i<lTarget;i++) {
- tene+=target[i]*target[i];
- }
-
- /* Prepare search over one more codebook section. This section
- is created by filtering the original buffer with a filter. */
-
- filteredCBvecs(cbvectors, buf+LPC_FILTERORDER, lMem);
-
- /* The Main Loop over stages */
-
- for (stage=0;stage<nStages; stage++) {
-
- range = search_rangeTbl[block][stage];
-
- /* initialize search measure */
-
- max_measure = (float)-10000000.0;
- gain = (float)0.0;
- best_index = 0;
-
- /* Compute cross dot product between the target
- and the CB memory */
-
- crossDot=0.0;
- pp=buf+LPC_FILTERORDER+lMem-lTarget;
- for (j=0; j<lTarget; j++) {
- crossDot += target[j]*(*pp++);
- }
-
- if (stage==0) {
-
- /* Calculate energy in the first block of
- 'lTarget' sampels. */
- ppe = energy;
- ppi = buf+LPC_FILTERORDER+lMem-lTarget-1;
- ppo = buf+LPC_FILTERORDER+lMem-1;
-
- *ppe=0.0;
- pp=buf+LPC_FILTERORDER+lMem-lTarget;
- for (j=0; j<lTarget; j++) {
- *ppe+=(*pp)*(*pp);
- pp++;
- }
-
- if(*ppe>0.0) {
- invenergy[0] = (float) 1.0 / (*ppe + EPS);
- } else {
- invenergy[0] = (float) 0.0;
- }
- ppe++;
-
- measure=(float)-10000000.0;
-
- if (crossDot > 0.0) {
- measure = crossDot*crossDot*invenergy[0];
- }
- }
- else {
- measure = crossDot*crossDot*invenergy[0];
- }
-
- /* check if measure is better */
- ftmp = crossDot*invenergy[0];
-
- if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
- best_index = 0;
- max_measure = measure;
- gain = ftmp;
- }
-
- /* loop over lags 40+ in the first codebook section,
- full search */
-
- for (icount=1; icount<range; icount++) {
-
- /* calculate measure */
-
- crossDot=0.0;
- pp = buf+LPC_FILTERORDER+lMem-lTarget-icount;
-
- for (j=0;j<lTarget;j++) {
- crossDot += target[j]*(*pp++);
- }
-
- if (stage==0) {
- *ppe++ = energy[icount-1] + (*ppi)*(*ppi) -
- (*ppo)*(*ppo);
- ppo--;
- ppi--;
-
- if(energy[icount]>0.0) {
- invenergy[icount] =
- (float)1.0/(energy[icount]+EPS);
- } else {
- invenergy[icount] = (float) 0.0;
- }
-
- measure=(float)-10000000.0;
-
- if (crossDot > 0.0) {
- measure = crossDot*crossDot*invenergy[icount];
- }
- }
- else {
- measure = crossDot*crossDot*invenergy[icount];
- }
-
- /* check if measure is better */
- ftmp = crossDot*invenergy[icount];
-
-
- if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)){
- best_index = icount;
- max_measure = measure;
- gain = ftmp;
- }
- }
-
- /* Loop over lags 20-39 in the first codebook section,
- * full search.
- * The vectors are interpolated.
- */
-
- if(lTarget==SUBL) {
-
- /* Search for best possible lag and compute
- the CB-vectors' energy. */
-
- searchAugmentedCB(20, 39, stage, base_size-lTarget/2,
- target, buf+LPC_FILTERORDER+lMem,
- &max_measure, &best_index, &gain, energy, invenergy);
-
- }
-
- /* set search range for following codebook sections */
-
- base_index=best_index;
-
- /* unrestricted search */
-
- if (CB_RESRANGE == -1) {
- sInd=0;
- eInd=range-1;
- sIndAug=20;
- eIndAug=39;
- }
-
- /* restriced search around best index from first
- codebook section */
-
- else {
- /* Initialize search indices */
- sIndAug=0;
- eIndAug=0;
- sInd=base_index-CB_RESRANGE/2;
- eInd=sInd+CB_RESRANGE;
-
- if(lTarget==SUBL) {
-
- if (sInd<0) {
-
- sIndAug = 40 + sInd;
- eIndAug = 39;
- sInd=0;
-
- } else if( base_index < (base_size-20) ) {
-
- if(eInd > range) {
- sInd -= (eInd-range);
- eInd = range;
- }
- } else { /* base_index >= (base_size-20) */
-
- if(sInd < (base_size-20)) {
- sIndAug = 20;
- sInd = 0;
- eInd = 0;
- eIndAug = 19 + CB_RESRANGE;
-
- if(eIndAug > 39) {
- eInd = eIndAug-39;
- eIndAug = 39;
- }
- } else {
- sIndAug = 20 + sInd - (base_size-20);
- eIndAug = 39;
- sInd = 0;
- eInd = CB_RESRANGE - (eIndAug-sIndAug+1);
- }
- }
-
- } else { /* lTarget = 22 */
-
- if (sInd < 0) {
- eInd -= sInd;
- sInd = 0;
- }
-
- if(eInd > range) {
- sInd -= (eInd - range);
- eInd = range;
- }
- }
- }
-
- /* search of higher codebook section */
-
- /* index search range */
- counter = sInd;
- sInd += base_size;
- eInd += base_size;
-
-
- if(stage==0) {
- ppe = energy+base_size;
- *ppe=0.0;
-
- pp=cbvectors+lMem-lTarget;
- for (j=0; j<lTarget; j++) {
- *ppe+=(*pp)*(*pp);
- pp++;
- }
-
- ppi = cbvectors + lMem - 1 - lTarget;
- ppo = cbvectors + lMem - 1;
-
- for(j=0;j<(range-1);j++) {
- *(ppe+1) = *ppe + (*ppi)*(*ppi) - (*ppo)*(*ppo);
- ppo--;
- ppi--;
- ppe++;
- }
- }
-
- /* loop over search range */
-
- for (icount=sInd; icount<eInd; icount++) {
-
- /* calculate measure */
-
- crossDot=0.0;
- pp=cbvectors + lMem - (counter++) - lTarget;
-
- for (j=0;j<lTarget;j++) {
- crossDot += target[j]*(*pp++);
- }
-
- if(energy[icount]>0.0) {
- invenergy[icount] = (float) 1.0/(energy[icount]+EPS);
- } else {
- invenergy[icount] = (float) 0.0;
- }
-
- if (stage==0) {
-
- measure=(float)-10000000.0;
-
- if (crossDot > 0.0) {
- measure = crossDot*crossDot*
- invenergy[icount];
- }
- }
- else {
- measure = crossDot*crossDot*invenergy[icount];
- }
-
- /* check if measure is better */
- ftmp = crossDot*invenergy[icount];
-
- if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)){
- best_index = icount;
- max_measure = measure;
- gain = ftmp;
- }
- }
-
- /* Search the augmented CB inside the limited range. */
-
- if ((lTarget==SUBL)&&(sIndAug!=0)) {
-
- searchAugmentedCB(sIndAug, eIndAug, stage,
- 2*base_size-20, target, cbvectors+lMem,
- &max_measure, &best_index, &gain, energy, invenergy);
-
- }
-
- /* record best index */
-
- index[stage] = best_index;
-
- /* gain quantization */
-
- if (stage==0){
-
- if (gain<0.0){
- gain = 0.0;
- }
-
- if (gain>CB_MAXGAIN) {
- gain = (float)CB_MAXGAIN;
- }
- gain = gainquant(gain, 1.0, 32, &gain_index[stage]);
- }
- else {
- if (stage==1) {
- gain = gainquant(gain, (float)fabs(gains[stage-1]),
- 16, &gain_index[stage]);
- } else {
- gain = gainquant(gain, (float)fabs(gains[stage-1]),
- 8, &gain_index[stage]);
- }
- }
-
- /* Extract the best (according to measure) codebook vector */
-
- if(lTarget==(STATE_LEN-STATE_SHORT_LEN)) {
-
- if(index[stage]<base_size) {
- pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage];
- } else {
- pp=cbvectors+lMem-lTarget-
- index[stage]+base_size;
- }
- } else {
-
- if (index[stage]<base_size) {
- if (index[stage]<(base_size-20)) {
- pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage];
- } else {
- createAugmentedVec(index[stage]-base_size+40,
- buf+LPC_FILTERORDER+lMem,aug_vec);
- pp=aug_vec;
- }
- } else {
- int filterno, lag_val;
-
- filterno=index[stage]/base_size;
- lag_val=index[stage]-filterno*base_size;
-
-
- if (lag_val<(base_size-20)) {
- pp=cbvectors+filterno*lMem-lTarget-
- index[stage]+filterno*base_size;
- } else {
- createAugmentedVec(
- index[stage]-(filterno+1)*base_size+40,
- cbvectors+filterno*lMem,aug_vec);
- pp=aug_vec;
- }
- }
- }
-
- /* Subtract the best codebook vector, according
- to measure, from the target vector */
-
- for(j=0;j<lTarget;j++){
- cvec[j] += gain*(*pp);
- target[j] -= gain*(*pp++);
- }
-
- /* record quantized gain */
-
- gains[stage]=gain;
-
- }/* end of Main Loop. for (stage=0;... */
-
- /* Gain adjustment for energy matching */
- cene=0.0;
- for (i=0;i<lTarget;i++) {
- cene+=cvec[i]*cvec[i];
- }
- j=gain_index[0];
-
- for (i=gain_index[0];i<32;i++) {
- ftmp=cene*gain_sq5Tbl[i]*gain_sq5Tbl[i];
-
- if ((ftmp<(tene*gains[0]*gains[0])) &&
- (gain_sq5Tbl[j]<(2.0*gains[0]))) {
- j=i;
- }
- }
- gain_index[0]=j;
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBSearch.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "gainquant.h"
+#include "createCB.h"
+#include "filter.h"
+#include "constants.h"
+
+/*----------------------------------------------------------------*
+ * Search routine for codebook encoding and gain quantization.
+ *---------------------------------------------------------------*/
+
+void iCBSearch(
+ 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; i<lTarget; i++) {
+ tene+=target[i]*target[i];
+ }
+
+ /* Prepare search over one more codebook section. This section
+ is created by filtering the original buffer with a filter. */
+
+ filteredCBvecs(cbvectors, buf+LPC_FILTERORDER, lMem);
+
+ /* The Main Loop over stages */
+
+ for (stage=0; stage<nStages; stage++) {
+
+ range = search_rangeTbl[block][stage];
+
+ /* initialize search measure */
+
+ max_measure = (float)-10000000.0;
+ gain = (float)0.0;
+ best_index = 0;
+
+ /* Compute cross dot product between the target
+
+
+ and the CB memory */
+
+ crossDot=0.0;
+ pp=buf+LPC_FILTERORDER+lMem-lTarget;
+ for (j=0; j<lTarget; j++) {
+ crossDot += target[j]*(*pp++);
+ }
+
+ if (stage==0) {
+
+ /* Calculate energy in the first block of
+ 'lTarget' sampels. */
+ ppe = energy;
+ ppi = buf+LPC_FILTERORDER+lMem-lTarget-1;
+ ppo = buf+LPC_FILTERORDER+lMem-1;
+
+ *ppe=0.0;
+ pp=buf+LPC_FILTERORDER+lMem-lTarget;
+ for (j=0; j<lTarget; j++) {
+ *ppe+=(*pp)*(*pp++);
+ }
+
+ if (*ppe>0.0) {
+ invenergy[0] = (float) 1.0 / (*ppe + EPS);
+ } else {
+ invenergy[0] = (float) 0.0;
+ }
+ ppe++;
+
+ measure=(float)-10000000.0;
+
+ if (crossDot > 0.0) {
+ measure = crossDot*crossDot*invenergy[0];
+ }
+ }
+ else {
+ measure = crossDot*crossDot*invenergy[0];
+ }
+
+ /* check if measure is better */
+ ftmp = crossDot*invenergy[0];
+
+ if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
+ best_index = 0;
+ max_measure = measure;
+ gain = ftmp;
+ }
+
+ /* loop over the main first codebook section,
+ full search */
+
+ for (icount=1; icount<range; icount++) {
+
+ /* calculate measure */
+
+
+
+ crossDot=0.0;
+ pp = buf+LPC_FILTERORDER+lMem-lTarget-icount;
+
+ for (j=0; j<lTarget; j++) {
+ crossDot += target[j]*(*pp++);
+ }
+
+ if (stage==0) {
+ *ppe++ = energy[icount-1] + (*ppi)*(*ppi) -
+ (*ppo)*(*ppo);
+ ppo--;
+ ppi--;
+
+ if (energy[icount]>0.0) {
+ invenergy[icount] =
+ (float)1.0/(energy[icount]+EPS);
+ } else {
+ invenergy[icount] = (float) 0.0;
+ }
+
+ measure=(float)-10000000.0;
+
+ if (crossDot > 0.0) {
+ measure = crossDot*crossDot*invenergy[icount];
+ }
+ }
+ else {
+ measure = crossDot*crossDot*invenergy[icount];
+ }
+
+ /* check if measure is better */
+ ftmp = crossDot*invenergy[icount];
+
+ if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
+ best_index = icount;
+ max_measure = measure;
+ gain = ftmp;
+ }
+ }
+
+ /* Loop over augmented part in the first codebook
+ * section, full search.
+ * The vectors are interpolated.
+ */
+
+ if (lTarget==SUBL) {
+
+ /* Search for best possible cb vector and
+ compute the CB-vectors' energy. */
+ searchAugmentedCB(20, 39, stage, base_size-lTarget/2,
+ target, buf+LPC_FILTERORDER+lMem,
+ &max_measure, &best_index, &gain, energy,
+ invenergy);
+
+
+ }
+
+ /* set search range for following codebook sections */
+
+ base_index=best_index;
+
+ /* unrestricted search */
+
+ if (CB_RESRANGE == -1) {
+ sInd=0;
+ eInd=range-1;
+ sIndAug=20;
+ eIndAug=39;
+ }
+
+ /* restriced search around best index from first
+ codebook section */
+
+ else {
+ /* Initialize search indices */
+ sIndAug=0;
+ eIndAug=0;
+ sInd=base_index-CB_RESRANGE/2;
+ eInd=sInd+CB_RESRANGE;
+
+ if (lTarget==SUBL) {
+
+ if (sInd<0) {
+
+ sIndAug = 40 + sInd;
+ eIndAug = 39;
+ sInd=0;
+
+ } else if ( base_index < (base_size-20) ) {
+
+ if (eInd > range) {
+ sInd -= (eInd-range);
+ eInd = range;
+ }
+ } else { /* base_index >= (base_size-20) */
+
+ if (sInd < (base_size-20)) {
+ sIndAug = 20;
+ sInd = 0;
+ eInd = 0;
+ eIndAug = 19 + CB_RESRANGE;
+
+ if(eIndAug > 39) {
+ eInd = eIndAug-39;
+ eIndAug = 39;
+ }
+ } else {
+ sIndAug = 20 + sInd - (base_size-20);
+ eIndAug = 39;
+
+
+ sInd = 0;
+ eInd = CB_RESRANGE - (eIndAug-sIndAug+1);
+ }
+ }
+
+ } else { /* lTarget = 22 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; j<lTarget; j++) {
+ *ppe+=(*pp)*(*pp++);
+ }
+
+ ppi = cbvectors + lMem - 1 - lTarget;
+ ppo = cbvectors + lMem - 1;
+
+ for (j=0; j<(range-1); j++) {
+ *(ppe+1) = *ppe + (*ppi)*(*ppi) - (*ppo)*(*ppo);
+ ppo--;
+ ppi--;
+ ppe++;
+ }
+ }
+
+ /* loop over search range */
+
+ for (icount=sInd; icount<eInd; icount++) {
+
+ /* calculate measure */
+
+ crossDot=0.0;
+
+
+ pp=cbvectors + lMem - (counter++) - lTarget;
+
+ for (j=0;j<lTarget;j++) {
+ crossDot += target[j]*(*pp++);
+ }
+
+ if (energy[icount]>0.0) {
+ invenergy[icount] =(float)1.0/(energy[icount]+EPS);
+ } else {
+ invenergy[icount] =(float)0.0;
+ }
+
+ if (stage==0) {
+
+ measure=(float)-10000000.0;
+
+ if (crossDot > 0.0) {
+ measure = crossDot*crossDot*
+ invenergy[icount];
+ }
+ }
+ else {
+ measure = crossDot*crossDot*invenergy[icount];
+ }
+
+ /* check if measure is better */
+ ftmp = crossDot*invenergy[icount];
+
+ if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
+ best_index = icount;
+ max_measure = measure;
+ gain = ftmp;
+ }
+ }
+
+ /* Search the augmented CB inside the limited range. */
+
+ if ((lTarget==SUBL)&&(sIndAug!=0)) {
+ searchAugmentedCB(sIndAug, eIndAug, stage,
+ 2*base_size-20, target, cbvectors+lMem,
+ &max_measure, &best_index, &gain, energy,
+ invenergy);
+ }
+
+ /* record best index */
+
+ index[stage] = best_index;
+
+ /* gain quantization */
+
+ if (stage==0){
+
+ if (gain<0.0){
+ gain = 0.0;
+
+
+ }
+
+ if (gain>CB_MAXGAIN) {
+ gain = (float)CB_MAXGAIN;
+ }
+ gain = gainquant(gain, 1.0, 32, &gain_index[stage]);
+ }
+ else {
+ if (stage==1) {
+ gain = gainquant(gain, (float)fabs(gains[stage-1]),
+ 16, &gain_index[stage]);
+ } else {
+ gain = gainquant(gain, (float)fabs(gains[stage-1]),
+ 8, &gain_index[stage]);
+ }
+ }
+
+ /* Extract the best (according to measure)
+ codebook vector */
+
+ if (lTarget==(STATE_LEN-iLBCenc_inst->state_short_len)) {
+
+ if (index[stage]<base_size) {
+ pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage];
+ } else {
+ pp=cbvectors+lMem-lTarget-
+ index[stage]+base_size;
+ }
+ } else {
+
+ if (index[stage]<base_size) {
+ if (index[stage]<(base_size-20)) {
+ pp=buf+LPC_FILTERORDER+lMem-
+ lTarget-index[stage];
+ } else {
+ createAugmentedVec(index[stage]-base_size+40,
+ buf+LPC_FILTERORDER+lMem,aug_vec);
+ pp=aug_vec;
+ }
+ } else {
+ int filterno, position;
+
+ filterno=index[stage]/base_size;
+ position=index[stage]-filterno*base_size;
+
+
+ if (position<(base_size-20)) {
+ pp=cbvectors+filterno*lMem-lTarget-
+ index[stage]+filterno*base_size;
+ } else {
+ createAugmentedVec(
+ index[stage]-(filterno+1)*base_size+40,
+ cbvectors+filterno*lMem,aug_vec);
+ pp=aug_vec;
+
+
+ }
+ }
+ }
+
+ /* Subtract the best codebook vector, according
+ to measure, from the target vector */
+
+ for (j=0;j<lTarget;j++) {
+ cvec[j] += gain*(*pp);
+ target[j] -= gain*(*pp++);
+ }
+
+ /* record quantized gain */
+
+ gains[stage]=gain;
+
+ }/* end of Main Loop. for (stage=0;... */
+
+ /* Gain adjustment for energy matching */
+ cene=0.0;
+ for (i=0; i<lTarget; i++) {
+ cene+=cvec[i]*cvec[i];
+ }
+ j=gain_index[0];
+
+ for (i=gain_index[0]; i<32; i++) {
+ ftmp=cene*gain_sq5Tbl[i]*gain_sq5Tbl[i];
+
+ if ((ftmp<(tene*gains[0]*gains[0])) &&
+ (gain_sq5Tbl[j]<(2.0*gains[0]))) {
+ j=i;
+ }
+ }
+ gain_index[0]=j;
+}
+
+
Index: iCBSearch.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iCBSearch.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- iCBSearch.h 15 Apr 2003 04:36:52 -0000 1.1
+++ iCBSearch.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,32 +1,35 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iCBSearch.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_ICBSEARCH_H
-#define __iLBC_ICBSEARCH_H
-
-void iCBSearch(
- int *index, /* (o) Codebook indices */
- int *gain_index,/* (o) Gain quantization indices */
- float *intarget,/* (i) Target vector for encoding */
- float *mem, /* (i) Buffer for codebook construction */
- int lMem, /* (i) Length of buffer */
- int lTarget, /* (i) Length of vector */
- int nStages, /* (i) Number of codebook stages */
- float *weightDenum, /* (i) weighting filter coefficients */
- float *weightState, /* (i) weighting filter state */
- int block /* (i) the subblock number */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iCBSearch.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_ICBSEARCH_H
+#define __iLBC_ICBSEARCH_H
+
+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 */
+);
+
+#endif
+
+
Index: iLBC_decode.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iLBC_decode.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- iLBC_decode.c 15 Aug 2003 04:38:39 -0000 1.2
+++ iLBC_decode.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,520 +1,618 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iLBC_decode.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
[...1102 lines suppressed...]
+
+ 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;
+ }
+}
+
+
Index: iLBC_decode.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iLBC_decode.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- iLBC_decode.h 15 Apr 2003 04:36:52 -0000 1.1
+++ iLBC_decode.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,38 +1,40 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iLBC_decode.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_ILBCDECODE_H
-#define __iLBC_ILBCDECODE_H
-
-#include "iLBC_define.h"
-
-short initDecode( /* (o) Number of decoded
- samples */
- iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) Decoder instance */
- int use_enhancer /* (i) 1 to use enhancer
- 0 to run without
- enhancer */
-);
-
-void iLBC_decode(
- float *decblock, /* (o) decoded signal block */
- unsigned char *bytes, /* (i) encoded signal bits */
- iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state
- structure */
- int mode /* (i) 0: bad packet, PLC,
- 1: normal */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: iLBC_define.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iLBC_define.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- iLBC_define.h 15 Apr 2003 04:36:52 -0000 1.1
+++ iLBC_define.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,157 +1,201 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iLBC_define.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-#include <string.h>
-
-#ifndef __iLBC_ILBCDEFINE_H
-#define __iLBC_ILBCDEFINE_H
-
-/* general codec settings */
-
-#define FS (float)8000.0
-#define BLOCKL 240
-#define NSUB 6
-#define NASUB 4
-#define SUBL 40
-#define STATE_LEN 80
-#define STATE_SHORT_LEN 58
-
-/* LPC settings */
-
-#define LPC_FILTERORDER 10
-#define LPC_CHIRP_SYNTDENUM (float)0.9025
-#define LPC_CHIRP_WEIGHTDENUM (float)0.4222
-#define LPC_LOOKBACK 60
-#define LPC_N 2
-#define LPC_ASYMDIFF 20
-#define LPC_BW (float)60.0
-#define LPC_WN (float)1.0001
-#define LSF_NSPLIT 3
-#define LSF_NUMBER_OF_STEPS 4
-#define LPC_HALFORDER LPC_FILTERORDER/2
-
-/* cb settings */
-
-#define CB_NSTAGES 3
-#define CB_EXPAND 2
-#define CB_MEML 147
-#define CB_FILTERLEN 2*4
-#define CB_HALFFILTERLEN 4
-#define CB_RESRANGE 34
-#define CB_MAXGAIN (float) 1.3
-
-/* enhancer */
-
-#define ENH_BLOCKL 80 /* block length */
-#define ENH_BLOCKL_HALF (ENH_BLOCKL/2)
-#define ENH_HL 3 /* 2*ENH_HL+1 is number blocks
- in said second sequence */
-#define ENH_SLOP 2 /* max difference estimated and
- correct pitch period */
-#define ENH_PLOCSL 20 /* pitch-estimates and
- pitch-locations buffer length */
-#define ENH_OVERHANG 2
-#define ENH_UPS0 4 /* upsampling rate */
-#define ENH_FL0 3 /* 2*FLO+1 is the length of each filter */
-#define ENH_VECTL (ENH_BLOCKL+2*ENH_FL0)
-#define ENH_CORRDIM (2*ENH_SLOP+1)
-#define ENH_NBLOCKS (BLOCKL/ENH_BLOCKL)
-#define ENH_NBLOCKS_EXTRA 5
-#define ENH_NBLOCKS_TOT 8 /* ENH_NBLOCKS+ENH_NBLOCKS_EXTRA */
-#define ENH_BUFL (ENH_NBLOCKS_TOT)*ENH_BLOCKL
-#define ENH_ALPHA0 (float)0.05
-
-/* PLC */
-
-#define PLC_BFIATTENUATE (float)0.9
-#define PLC_GAINTHRESHOLD (float)0.5
-#define PLC_BWEXPAND (float)0.99
-#define PLC_XT_MIX (float)1.0
-#define PLC_XB_MIX (float)0.0
-#define PLC_YT_MIX (float)0.95
-#define PLC_YB_MIX (float)0.0
-
-/* Down sampling */
-
-#define FILTERORDER_DS 7
-#define DELAY_DS 3
-#define FACTOR_DS 2
-
-/* bit stream defs */
-
-#define NO_OF_BYTES 50
-#define STATE_BITS 3
-#define BYTE_LEN 8
-#define ULP_CLASSES 3
-
-/* help parameters */
-
-#define FLOAT_MAX (float)1.0e37
-#define EPS (float)2.220446049250313e-016
-#define PI (float)3.14159265358979323846
-#define MIN_SAMPLE -32768
-#define MAX_SAMPLE 32767
-#define TWO_PI (float)6.283185307
-#define PI2 (float)0.159154943
-
-/* type definition encoder instance */
-typedef struct iLBC_Enc_Inst_t_ {
-
- /* analysis filter state */
- float anaMem[LPC_FILTERORDER];
-
- /* old lsf parameters for interpolation */
- float lsfold[LPC_FILTERORDER];
- float lsfdeqold[LPC_FILTERORDER];
-
- /* signal buffer for LP analysis */
- float lpc_buffer[LPC_LOOKBACK + BLOCKL];
-
- /* state of input HP filter */
- float hpimem[4];
-
-} iLBC_Enc_Inst_t;
-
-/* type definition decoder instance */
-typedef struct iLBC_Dec_Inst_t_ {
- /* synthesis filter state */
- float syntMem[LPC_FILTERORDER];
-
- /* old LSF for interpolation */
- float lsfdeqold[LPC_FILTERORDER];
-
- /* pitch lag estimated in enhancer and used in PLC */
- int last_lag;
-
- /* PLC state information */
- int prevLag, consPLICount, prevPLI, prev_enh_pl;
- float prevGain, prevLpc[LPC_FILTERORDER+1];
- float prevResidual[NSUB*SUBL];
- float energy;
- unsigned long seed;
-
- /* previous synthesis filter parameters */
- float old_syntdenum[(LPC_FILTERORDER + 1)*NSUB];
-
- /* state of output HP filter */
- float hpomem[4];
-
- /* enhancer state information */
- int use_enhancer;
- float enh_buf[ENH_BUFL];
- float enh_period[ENH_NBLOCKS_TOT];
-
-} iLBC_Dec_Inst_t;
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_define.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+#include <string.h>
+
+#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
+
+
Index: iLBC_encode.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iLBC_encode.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- iLBC_encode.c 15 Aug 2003 04:38:39 -0000 1.2
+++ iLBC_encode.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,447 +1,513 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iLBC_encode.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <string.h>
-
-#include "iLBC_define.h"
-#include "LPCencode.h"
-#include "FrameClassify.h"
-#include "StateSearchW.h"
-#include "StateConstructW.h"
-#include "helpfun.h"
-#include "constants.h"
-#include "packing.h"
-#include "iLBC_encode.h"
-#include "iCBSearch.h"
-#include "iCBConstruct.h"
-#include "hpInput.h"
-#include "anaFilter.h"
-#include "syntFilter.h"
-
-/*----------------------------------------------------------------*
- * Initiation of encoder instance.
- *---------------------------------------------------------------*/
-
-short initEncode( /* (o) Number of bytes encoded */
- iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) Encoder instance */
-){
- memset((*iLBCenc_inst).anaMem, 0,
- LPC_FILTERORDER*sizeof(float));
- memcpy((*iLBCenc_inst).lsfold, lsfmeanTbl,
- LPC_FILTERORDER*sizeof(float));
- memcpy((*iLBCenc_inst).lsfdeqold, lsfmeanTbl,
- LPC_FILTERORDER*sizeof(float));
- memset((*iLBCenc_inst).lpc_buffer, 0,
- LPC_LOOKBACK*sizeof(float));
- memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float));
-
- return (NO_OF_BYTES);
-}
-
-/*----------------------------------------------------------------*
- * main encoder function
- *---------------------------------------------------------------*/
-
-void iLBC_encode(
- unsigned char *bytes, /* (o) encoded data bits iLBC */
- float *block, /* (o) speech vector to encode */
- iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder
- state */
-){
-
- float data[BLOCKL];
- float residual[BLOCKL], reverseResidual[BLOCKL];
-
- int start, idxForMax, idxVec[STATE_LEN];
- float reverseDecresidual[BLOCKL], mem[CB_MEML];
- int n, k, meml_gotten, Nfor, Nback, i, pos;
- int gain_index[CB_NSTAGES*NASUB], extra_gain_index[CB_NSTAGES];
- int cb_index[CB_NSTAGES*NASUB],extra_cb_index[CB_NSTAGES];
- int lsf_i[LSF_NSPLIT*LPC_N];
- unsigned char *pbytes;
- int diff, start_pos, state_first;
- float en1, en2;
- int index, ulp, firstpart;
- int subcount, subframe;
- float weightState[LPC_FILTERORDER];
- float syntdenum[NSUB*(LPC_FILTERORDER+1)];
- float weightdenum[NSUB*(LPC_FILTERORDER+1)];
- float decresidual[BLOCKL];
-
- /* high pass filtering of input signal if such is not done
- prior to calling this function */
-
- /*hpInput(block, BLOCKL, data, (*iLBCenc_inst).hpimem);*/
-
- /* otherwise simply copy */
-
- memcpy(data,block,BLOCKL*sizeof(float));
-
- /* LPC of hp filtered input data */
-
- LPCencode(syntdenum, weightdenum, lsf_i, data,
- iLBCenc_inst);
-
- /* inverse filter to get residual */
-
- for (n=0; n<NSUB; n++ ) {
- anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)],
- SUBL, &residual[n*SUBL], (*iLBCenc_inst).anaMem);
- }
-
- /* find state location */
-
- start = FrameClassify(residual);
-
- /* check if state should be in first or last part of the
- two subframes */
-
- diff = STATE_LEN - STATE_SHORT_LEN;
- en1 = 0;
- index = (start-1)*SUBL;
- for (i = 0; i < STATE_SHORT_LEN; i++) {
- en1 += residual[index+i]*residual[index+i];
- }
- en2 = 0;
- index = (start-1)*SUBL+diff;
- for (i = 0; i < STATE_SHORT_LEN; i++) {
- en2 += residual[index+i]*residual[index+i];
- }
-
-
- if (en1 > en2) {
- state_first = 1;
- start_pos = (start-1)*SUBL;
- } else {
- state_first = 0;
- start_pos = (start-1)*SUBL + diff;
- }
-
- /* scalar quantization of state */
-
- StateSearchW(&residual[start_pos],
- &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
- &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax,
- idxVec, STATE_SHORT_LEN, state_first);
-
- StateConstructW(idxForMax, idxVec,
- &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
- &decresidual[start_pos], STATE_SHORT_LEN);
-
- /* predictive quantization in state */
-
- if (state_first) { /* put adaptive part in the end */
-
- /* setup memory */
-
- memset(mem, 0, (CB_MEML-STATE_SHORT_LEN)*sizeof(float));
- memcpy(mem+CB_MEML-STATE_SHORT_LEN, decresidual+start_pos,
- STATE_SHORT_LEN*sizeof(float));
- memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
-
- /* encode subframes */
-
- iCBSearch(extra_cb_index, extra_gain_index,
- &residual[start_pos+STATE_SHORT_LEN],
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ iLBC_encode.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "iLBC_define.h"
+#include "LPCencode.h"
+#include "FrameClassify.h"
+#include "StateSearchW.h"
+#include "StateConstructW.h"
+#include "helpfun.h"
+#include "constants.h"
+#include "packing.h"
+#include "iCBSearch.h"
+#include "iCBConstruct.h"
+#include "hpInput.h"
+#include "anaFilter.h"
+#include "syntFilter.h"
+
+/*----------------------------------------------------------------*
+ * Initiation of encoder instance.
+ *---------------------------------------------------------------*/
+
+short initEncode( /* (o) Number of bytes
+ encoded */
+ iLBC_Enc_Inst_t *iLBCenc_inst, /* (i/o) Encoder instance */
+ 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; n<iLBCenc_inst->nsub; 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,
- &weightdenum[start*(LPC_FILTERORDER+1)], weightState, 0);
-
- /* construct decoded vector */
-
- iCBConstruct(&decresidual[start_pos+STATE_SHORT_LEN],
- extra_cb_index, extra_gain_index, mem+CB_MEML-stMemLTbl,
- stMemLTbl, diff, CB_NSTAGES);
-
- }
- else { /* put adaptive part in the beginning */
-
- /* create reversed vectors for prediction */
-
- for(k=0; k<diff; k++ ){
- reverseResidual[k] = residual[(start+1)*SUBL -1
- -(k+STATE_SHORT_LEN)];
- }
-
- /* setup memory */
-
- meml_gotten = STATE_SHORT_LEN;
- for( k=0; k<meml_gotten; k++){
- mem[CB_MEML-1-k] = decresidual[start_pos + k];
- }
- memset(mem, 0, (CB_MEML-k)*sizeof(float));
- memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
-
- /* encode subframes */
-
- iCBSearch(extra_cb_index, extra_gain_index,
- reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl, diff,
- CB_NSTAGES, &weightdenum[(start-1)*(LPC_FILTERORDER+1)],
- weightState, 0);
-
- /* construct decoded vector */
-
- iCBConstruct(reverseDecresidual, extra_cb_index,
- extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl, diff,
- CB_NSTAGES);
-
- /* get decoded residual from reversed vector */
-
- for( k=0; k<diff; k++ ){
- decresidual[start_pos-1-k] = reverseDecresidual[k];
- }
- }
-
- /* counter for predicted subframes */
-
- subcount=0;
-
- /* forward prediction of subframes */
-
- Nfor = NSUB-start-1;
-
-
- if( Nfor > 0 ){
-
- /* setup memory */
-
- memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
- memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
- STATE_LEN*sizeof(float));
- memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
-
- /* loop over subframes to encode */
-
- for (subframe=0; subframe<Nfor; subframe++) {
-
- /* encode subframe */
-
- iCBSearch(cb_index+subcount*CB_NSTAGES,
- gain_index+subcount*CB_NSTAGES,
- &residual[(start+1+subframe)*SUBL],
- mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
- SUBL, CB_NSTAGES,
- &weightdenum[(start+1+subframe)*(LPC_FILTERORDER+1)],
- weightState, subcount+1);
-
- /* construct decoded vector */
-
- iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
- cb_index+subcount*CB_NSTAGES,
- gain_index+subcount*CB_NSTAGES,
- mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
- SUBL, CB_NSTAGES);
-
- /* update memory */
-
- memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
- memcpy(mem+CB_MEML-SUBL,
- &decresidual[(start+1+subframe)*SUBL],
- SUBL*sizeof(float));
- memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
-
- subcount++;
- }
- }
-
-
- /* backward prediction of subframes */
-
- Nback = start-1;
-
-
- if( Nback > 0 ){
-
- /* create reverse order vectors */
-
- for( n=0; n<Nback; n++ ){
- for( k=0; k<SUBL; k++ ){
- reverseResidual[n*SUBL+k] =
- residual[(start-1)*SUBL-1-n*SUBL-k];
- reverseDecresidual[n*SUBL+k] =
- decresidual[(start-1)*SUBL-1-n*SUBL-k];
- }
- }
-
- /* setup memory */
-
- meml_gotten = SUBL*(NSUB+1-start);
-
-
- if( meml_gotten > CB_MEML ) {
- meml_gotten=CB_MEML;
- }
- for( k=0; k<meml_gotten; k++) {
- mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
- }
- memset(mem, 0, (CB_MEML-k)*sizeof(float));
- memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
-
- /* loop over subframes to encode */
-
- for (subframe=0; subframe<Nback; subframe++) {
-
- /* encode subframe */
-
- iCBSearch(cb_index+subcount*CB_NSTAGES,
- gain_index+subcount*CB_NSTAGES,
- &reverseResidual[subframe*SUBL],
- mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
- SUBL, CB_NSTAGES,
- &weightdenum[(start-2-subframe)*(LPC_FILTERORDER+1)],
- weightState, subcount+1);
-
- /* construct decoded vector */
-
- iCBConstruct(&reverseDecresidual[subframe*SUBL],
- cb_index+subcount*CB_NSTAGES,
- gain_index+subcount*CB_NSTAGES,
- mem+CB_MEML-memLfTbl[subcount],
- memLfTbl[subcount], SUBL, CB_NSTAGES);
-
- /* update memory */
-
- memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
- memcpy(mem+CB_MEML-SUBL,
- &reverseDecresidual[subframe*SUBL],
- SUBL*sizeof(float));
- memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
-
- subcount++;
-
- }
-
- /* get decoded residual from reversed vector */
-
- for (i = 0; i < SUBL*Nback; i++) {
- decresidual[SUBL*Nback - i - 1] =
- reverseDecresidual[i];
- }
+ stMemLTbl, diff, CB_NSTAGES);
+
}
- /* end encoding part */
-
- /* adjust index */
- index_conv_enc(cb_index);
-
- /* pack bytes */
-
- pbytes=bytes;
- pos=0;
-
- /* loop over the 3 ULP classes */
-
- for (ulp=0; ulp<3; ulp++) {
-
- /* LSF */
- for (k=0;k<6;k++) {
- packsplit(&lsf_i[k], &firstpart, &lsf_i[k],
- ulp_lsf_bitsTbl[k][ulp],
- ulp_lsf_bitsTbl[k][ulp]+
- ulp_lsf_bitsTbl[k][ulp+1]+
- ulp_lsf_bitsTbl[k][ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_lsf_bitsTbl[k][ulp], &pos);
- }
-
- /* Start block info */
-
- packsplit(&start, &firstpart, &start,
- ulp_start_bitsTbl[ulp],
- ulp_start_bitsTbl[ulp]+
- ulp_start_bitsTbl[ulp+1]+
- ulp_start_bitsTbl[ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_start_bitsTbl[ulp], &pos);
-
- packsplit(&state_first, &firstpart, &state_first,
- ulp_startfirst_bitsTbl[ulp],
- ulp_startfirst_bitsTbl[ulp]+
- ulp_startfirst_bitsTbl[ulp+1]+
- ulp_startfirst_bitsTbl[ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_startfirst_bitsTbl[ulp], &pos);
-
- packsplit(&idxForMax, &firstpart, &idxForMax,
- ulp_scale_bitsTbl[ulp], ulp_scale_bitsTbl[ulp]+
- ulp_scale_bitsTbl[ulp+1]+ulp_scale_bitsTbl[ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_scale_bitsTbl[ulp], &pos);
-
- for (k=0; k<STATE_SHORT_LEN; k++) {
- packsplit(idxVec+k, &firstpart, idxVec+k,
- ulp_state_bitsTbl[ulp],
- ulp_state_bitsTbl[ulp]+
- ulp_state_bitsTbl[ulp+1]+
- ulp_state_bitsTbl[ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_state_bitsTbl[ulp], &pos);
- }
-
- /* 22 sample block */
-
- for (k=0;k<CB_NSTAGES;k++) {
- packsplit(extra_cb_index+k, &firstpart,
- extra_cb_index+k,
- ulp_extra_cb_indexTbl[k][ulp],
- ulp_extra_cb_indexTbl[k][ulp]+
- ulp_extra_cb_indexTbl[k][ulp+1]+
- ulp_extra_cb_indexTbl[k][ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_extra_cb_indexTbl[k][ulp], &pos);
- }
- for (k=0;k<CB_NSTAGES;k++) {
- packsplit(extra_gain_index+k, &firstpart,
- extra_gain_index+k,
- ulp_extra_cb_gainTbl[k][ulp],
- ulp_extra_cb_gainTbl[k][ulp]+
- ulp_extra_cb_gainTbl[k][ulp+1]+
- ulp_extra_cb_gainTbl[k][ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_extra_cb_gainTbl[k][ulp], &pos);
- }
-
- /* The four 40 sample sub blocks */
-
- for (i=0; i<NASUB; i++) {
- for (k=0; k<CB_NSTAGES; k++) {
- packsplit(cb_index+i*CB_NSTAGES+k, &firstpart,
- cb_index+i*CB_NSTAGES+k,
- ulp_cb_indexTbl[i][k][ulp],
- ulp_cb_indexTbl[i][k][ulp]+
- ulp_cb_indexTbl[i][k][ulp+1]+
- ulp_cb_indexTbl[i][k][ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_cb_indexTbl[i][k][ulp], &pos);
- }
+ else { /* put adaptive part in the beginning */
+
+
+
+ /* create reversed vectors for prediction */
+
+ for (k=0; k<diff; k++) {
+ reverseResidual[k] = residual[(start+1)*SUBL-1
+ -(k+iLBCenc_inst->state_short_len)];
+ }
+
+ /* setup memory */
+
+ meml_gotten = iLBCenc_inst->state_short_len;
+ for (k=0; k<meml_gotten; k++) {
+ mem[CB_MEML-1-k] = decresidual[start_pos + k];
}
-
- for (i=0; i<NASUB; i++) {
- for (k=0; k<CB_NSTAGES; k++) {
- packsplit(gain_index+i*CB_NSTAGES+k, &firstpart,
- gain_index+i*CB_NSTAGES+k,
- ulp_cb_gainTbl[i][k][ulp],
- ulp_cb_gainTbl[i][k][ulp]+
- ulp_cb_gainTbl[i][k][ulp+1]+
- ulp_cb_gainTbl[i][k][ulp+2]);
- dopack( &pbytes, firstpart,
- ulp_cb_gainTbl[i][k][ulp], &pos);
- }
+ memset(mem, 0, (CB_MEML-k)*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ /* encode sub-frames */
+
+ iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index,
+ reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl,
+ diff, CB_NSTAGES,
+ &weightdenum[(start-1)*(LPC_FILTERORDER+1)],
+ weightState, 0);
+
+ /* construct decoded vector */
+
+ iCBConstruct(reverseDecresidual, extra_cb_index,
+ extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl,
+ diff, CB_NSTAGES);
+
+ /* get decoded residual from reversed vector */
+
+ for (k=0; k<diff; k++) {
+ decresidual[start_pos-1-k] = reverseDecresidual[k];
+ }
+ }
+
+ /* counter for predicted sub-frames */
+
+ subcount=0;
+
+ /* forward prediction of sub-frames */
+
+ Nfor = iLBCenc_inst->nsub-start-1;
+
+
+ if ( Nfor > 0 ) {
+
+ /* setup memory */
+
+ memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
+ memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
+ STATE_LEN*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+
+
+ /* loop over sub-frames to encode */
+
+ for (subframe=0; subframe<Nfor; subframe++) {
+
+ /* encode sub-frame */
+
+ iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ &residual[(start+1+subframe)*SUBL],
+ mem+CB_MEML-memLfTbl[subcount],
+ memLfTbl[subcount], SUBL, CB_NSTAGES,
+ &weightdenum[(start+1+subframe)*
+ (LPC_FILTERORDER+1)],
+ weightState, subcount+1);
+
+ /* construct decoded vector */
+
+ iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
+ cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ mem+CB_MEML-memLfTbl[subcount],
+ memLfTbl[subcount], SUBL, CB_NSTAGES);
+
+ /* update memory */
+
+ memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
+ memcpy(mem+CB_MEML-SUBL,
+ &decresidual[(start+1+subframe)*SUBL],
+ SUBL*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ subcount++;
+ }
+ }
+
+
+ /* backward prediction of sub-frames */
+
+ Nback = start-1;
+
+
+ if ( Nback > 0 ) {
+
+ /* create reverse order vectors */
+
+ for (n=0; n<Nback; n++) {
+ for (k=0; k<SUBL; k++) {
+ reverseResidual[n*SUBL+k] =
+ residual[(start-1)*SUBL-1-n*SUBL-k];
+ reverseDecresidual[n*SUBL+k] =
+ decresidual[(start-1)*SUBL-1-n*SUBL-k];
+ }
+ }
+
+
+
+ /* setup memory */
+
+ meml_gotten = SUBL*(iLBCenc_inst->nsub+1-start);
+
+
+ if ( meml_gotten > CB_MEML ) {
+ meml_gotten=CB_MEML;
+ }
+ for (k=0; k<meml_gotten; k++) {
+ mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
}
- }
-
- /* set the last unused bit to zero */
- dopack( &pbytes, 0, 1, &pos);
-}
-
-
+ memset(mem, 0, (CB_MEML-k)*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ /* loop over sub-frames to encode */
+
+ for (subframe=0; subframe<Nback; subframe++) {
+
+ /* encode sub-frame */
+
+ iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ &reverseResidual[subframe*SUBL],
+ mem+CB_MEML-memLfTbl[subcount],
+ memLfTbl[subcount], SUBL, CB_NSTAGES,
+ &weightdenum[(start-2-subframe)*
+ (LPC_FILTERORDER+1)],
+ weightState, subcount+1);
+
+ /* construct decoded vector */
+
+ iCBConstruct(&reverseDecresidual[subframe*SUBL],
+ cb_index+subcount*CB_NSTAGES,
+ gain_index+subcount*CB_NSTAGES,
+ mem+CB_MEML-memLfTbl[subcount],
+ memLfTbl[subcount], SUBL, CB_NSTAGES);
+
+ /* update memory */
+
+ memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
+ memcpy(mem+CB_MEML-SUBL,
+ &reverseDecresidual[subframe*SUBL],
+ SUBL*sizeof(float));
+ memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
+
+ subcount++;
+
+ }
+
+ /* get decoded residual from reversed vector */
+
+ for (i=0; i<SUBL*Nback; i++) {
+ decresidual[SUBL*Nback - i - 1] =
+
+
+ reverseDecresidual[i];
+ }
+ }
+ /* end encoding part */
+
+ /* adjust index */
+ index_conv_enc(cb_index);
+
+ /* pack bytes */
+
+ pbytes=bytes;
+ pos=0;
+
+ /* loop over the 3 ULP classes */
+
+ for (ulp=0; ulp<3; ulp++) {
+
+ /* LSF */
+ for (k=0; k<LSF_NSPLIT*iLBCenc_inst->lpc_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; k<iLBCenc_inst->state_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;k<CB_NSTAGES;k++) {
+ packsplit(extra_cb_index+k, &firstpart,
+ extra_cb_index+k,
+ iLBCenc_inst->ULP_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;k<CB_NSTAGES;k++) {
+ packsplit(extra_gain_index+k, &firstpart,
+ extra_gain_index+k,
+ iLBCenc_inst->ULP_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; i<iLBCenc_inst->nasub; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+ packsplit(cb_index+i*CB_NSTAGES+k, &firstpart,
+ cb_index+i*CB_NSTAGES+k,
+ iLBCenc_inst->ULP_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; i<iLBCenc_inst->nasub; i++) {
+ for (k=0; k<CB_NSTAGES; k++) {
+
+
+ packsplit(gain_index+i*CB_NSTAGES+k, &firstpart,
+ gain_index+i*CB_NSTAGES+k,
+ iLBCenc_inst->ULP_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);
+}
+
+
+
Index: iLBC_encode.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/iLBC_encode.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- iLBC_encode.h 15 Apr 2003 04:36:52 -0000 1.1
+++ iLBC_encode.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,32 +1,37 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- iLBC_encode.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_ILBCENCODE_H
-#define __iLBC_ILBCENCODE_H
-
-#include "iLBC_define.h"
-
-short initEncode( /* (o) Number of bytes encoded */
- iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) Encoder instance */
-);
-
-void iLBC_encode(
- unsigned char *bytes, /* (o) encoded data bits iLBC */
- float *block, /* (o) speech vector to encode */
- iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder
- state */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
+
Index: lsf.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/lsf.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- lsf.c 15 Aug 2003 04:38:39 -0000 1.2
+++ lsf.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,253 +1,263 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- lsf.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <string.h>
-#include <math.h>
-
-#include "iLBC_define.h"
-#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 < LPC_HALFORDER; i++){
- p[i] = (float)-1.0 * (a[i + 1] + a[LPC_FILTERORDER - i]);
- q[i] = a[LPC_FILTERORDER - i] - a[i + 1];
- }
-
- p_pre[0] = (float)-1.0 - p[0];
- p_pre[1] = - p_pre[0] - p[1];
- p_pre[2] = - p_pre[1] - p[2];
- p_pre[3] = - p_pre[2] - p[3];
- p_pre[4] = - p_pre[3] - p[4];
- p_pre[4] = p_pre[4] / 2;
-
- q_pre[0] = (float)1.0 - q[0];
- q_pre[1] = q_pre[0] - q[1];
- q_pre[2] = q_pre[1] - q[2];
- q_pre[3] = q_pre[2] - q[3];
- q_pre[4] = q_pre[3] - q[4];
- q_pre[4] = q_pre[4] / 2;
-
- omega = 0.0;
- old_omega = 0.0;
-
- old_p = FLOAT_MAX;
- old_q = FLOAT_MAX;
-
- /* Here we loop through lsp_index to find all the
- LPC_FILTERORDER roots for omega. */
-
- for (lsp_index = 0; lsp_index < LPC_FILTERORDER; lsp_index++){
-
- /* Depending on lsp_index being even or odd, we
- alternatively solve the roots for the two LSP equations. */
-
-
- if ((lsp_index & 0x1) == 0) {
- pq_coef = p_pre;
- old = &old_p;
- } else {
- pq_coef = q_pre;
- old = &old_q;
- }
-
- /* Start with low resolution grid */
-
- for (step_idx = 0, step = steps[step_idx];
- step_idx < LSF_NUMBER_OF_STEPS;){
-
- /* cos(10piw) + pq(0)cos(8piw) + pq(1)cos(6piw) +
- pq(2)cos(4piw) + pq(3)cod(2piw) + pq(4) */
-
- hlp = (float)cos(omega * TWO_PI);
- hlp1 = (float)2.0 * hlp + pq_coef[0];
- hlp2 = (float)2.0 * hlp * hlp1 - (float)1.0 +
- pq_coef[1];
- hlp3 = (float)2.0 * hlp * hlp2 - hlp1 + pq_coef[2];
- hlp4 = (float)2.0 * hlp * hlp3 - hlp2 + pq_coef[3];
- hlp5 = hlp * hlp4 - hlp3 + pq_coef[4];
-
-
- if (((hlp5 * (*old)) <= 0.0) || (omega >= 0.5)){
-
- if (step_idx == (LSF_NUMBER_OF_STEPS - 1)){
-
- if (fabs(hlp5) >= fabs(*old)) {
- freq[lsp_index] = omega - step;
- } else {
- freq[lsp_index] = omega;
- }
-
-
- if ((*old) >= 0.0){
- *old = (float)-1.0 * FLOAT_MAX;
- } else {
- *old = FLOAT_MAX;
- }
-
- omega = old_omega;
- step_idx = 0;
-
- step_idx = LSF_NUMBER_OF_STEPS;
- } else {
-
- if (step_idx == 0) {
- old_omega = omega;
- }
-
- step_idx++;
- omega -= steps[step_idx];
-
- /* Go back one grid step */
-
- step = steps[step_idx];
- }
- } else {
-
- /* increment omega until they are of different sign,
- and we know there is at least one root between omega
- and old_omega */
- *old = hlp5;
- omega += step;
- }
- }
- }
-
- for (i = 0; i < LPC_FILTERORDER; i++) {
- freq[i] = freq[i] * TWO_PI;
- }
-}
-
-/*----------------------------------------------------------------*
- * conversion from lsf coefficients to lpc coefficients
- *---------------------------------------------------------------*/
-
-void lsf2a(
- float *a_coef, /* (o) lpc coefficients */
- float *freq /* (i) lsf coefficients */
-){
- int i, j;
- float hlp;
- float p[LPC_HALFORDER], q[LPC_HALFORDER];
- float a[LPC_HALFORDER + 1], a1[LPC_HALFORDER], a2[LPC_HALFORDER];
- float b[LPC_HALFORDER + 1], b1[LPC_HALFORDER], b2[LPC_HALFORDER];
-
- for (i = 0; i < LPC_FILTERORDER; i++) {
- freq[i] = freq[i] * PI2;
- }
-
- /* Check input for ill-conditioned cases. This part is not
- found in the TIA standard. It involves the following 2 IF
- blocks. If "freq" is judged ill-conditioned, then we first
- modify freq[0] and freq[LPC_HALFORDER-1] (normally
- LPC_HALFORDER = 10 for LPC applications), then we adjust
- the other "freq" values slightly */
-
-
- if ((freq[0] <= 0.0) || (freq[LPC_FILTERORDER - 1] >= 0.5)){
-
-
- if (freq[0] <= 0.0) {
- freq[0] = (float)0.022;
- }
-
-
- if (freq[LPC_FILTERORDER - 1] >= 0.5) {
- freq[LPC_FILTERORDER - 1] = (float)0.499;
- }
-
- hlp = (freq[LPC_FILTERORDER - 1] - freq[0]) /
- (float) (LPC_FILTERORDER - 1);
-
- for (i = 1; i < LPC_FILTERORDER; i++) {
- freq[i] = freq[i - 1] + hlp;
- }
- }
-
- memset(a1, 0, LPC_HALFORDER*sizeof(float));
- memset(a2, 0, LPC_HALFORDER*sizeof(float));
- memset(b1, 0, LPC_HALFORDER*sizeof(float));
- memset(b2, 0, LPC_HALFORDER*sizeof(float));
- memset(a, 0, (LPC_HALFORDER+1)*sizeof(float));
- memset(b, 0, (LPC_HALFORDER+1)*sizeof(float));
-
- /* p[i] and q[i] compute cos(2*pi*omega_{2j}) and
- cos(2*pi*omega_{2j-1} in eqs. 4.2.2.2-1 and 4.2.2.2-2.
- Note that for this code p[i] specifies the coefficients
- used in .Q_A(z) while q[i] specifies the coefficients used
- in .P_A(z) */
-
- for (i = 0; i < LPC_HALFORDER; i++){
- p[i] = (float)cos(TWO_PI * freq[2 * i]);
- q[i] = (float)cos(TWO_PI * freq[2 * i + 1]);
- }
-
- a[0] = 0.25;
- b[0] = 0.25;
-
- for (i = 0; i < LPC_HALFORDER; i++){
- a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
- b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
- a2[i] = a1[i];
- a1[i] = a[i];
- b2[i] = b1[i];
- b1[i] = b[i];
- }
-
- for (j = 0; j < LPC_FILTERORDER; j++){
-
- if (j == 0) {
- a[0] = 0.25;
- b[0] = -0.25;
- } else {
- a[0] = b[0] = 0.0;
- }
-
- for (i = 0; i < LPC_HALFORDER; i++){
- a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
- b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
- a2[i] = a1[i];
- a1[i] = a[i];
- b2[i] = b1[i];
- b1[i] = b[i];
- }
-
- a_coef[j + 1] = 2 * (a[LPC_HALFORDER] + b[LPC_HALFORDER]);
- }
-
- a_coef[0] = 1.0;
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ lsf.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <string.h>
+#include <math.h>
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * conversion from lpc coefficients to lsf coefficients
+ *---------------------------------------------------------------*/
+
+void a2lsf(
+ float *freq,/* (o) lsf coefficients */
+ float *a /* (i) lpc coefficients */
+){
+ float steps[LSF_NUMBER_OF_STEPS] =
+ {(float)0.00635, (float)0.003175, (float)0.0015875,
+ (float)0.00079375};
+ float step;
+ int step_idx;
+ int lsp_index;
+ float p[LPC_HALFORDER];
+ float q[LPC_HALFORDER];
+ float p_pre[LPC_HALFORDER];
+
+
+ float q_pre[LPC_HALFORDER];
+ float old_p, old_q, *old;
+ float *pq_coef;
+ float omega, old_omega;
+ int i;
+ float hlp, hlp1, hlp2, hlp3, hlp4, hlp5;
+
+ for (i=0; i<LPC_HALFORDER; i++) {
+ p[i] = (float)-1.0 * (a[i + 1] + a[LPC_FILTERORDER - i]);
+ q[i] = a[LPC_FILTERORDER - i] - a[i + 1];
+ }
+
+ p_pre[0] = (float)-1.0 - p[0];
+ p_pre[1] = - p_pre[0] - p[1];
+ p_pre[2] = - p_pre[1] - p[2];
+ p_pre[3] = - p_pre[2] - p[3];
+ p_pre[4] = - p_pre[3] - p[4];
+ p_pre[4] = p_pre[4] / 2;
+
+ q_pre[0] = (float)1.0 - q[0];
+ q_pre[1] = q_pre[0] - q[1];
+ q_pre[2] = q_pre[1] - q[2];
+ q_pre[3] = q_pre[2] - q[3];
+ q_pre[4] = q_pre[3] - q[4];
+ q_pre[4] = q_pre[4] / 2;
+
+ omega = 0.0;
+ old_omega = 0.0;
+
+ old_p = FLOAT_MAX;
+ old_q = FLOAT_MAX;
+
+ /* Here we loop through lsp_index to find all the
+ LPC_FILTERORDER roots for omega. */
+
+ for (lsp_index = 0; lsp_index<LPC_FILTERORDER; lsp_index++) {
+
+ /* Depending on lsp_index being even or odd, we
+ alternatively solve the roots for the two LSP equations. */
+
+
+ if ((lsp_index & 0x1) == 0) {
+ pq_coef = p_pre;
+ old = &old_p;
+ } else {
+ pq_coef = q_pre;
+ old = &old_q;
+ }
+
+ /* Start with low resolution grid */
+
+ for (step_idx = 0, step = steps[step_idx];
+ step_idx < LSF_NUMBER_OF_STEPS;){
+
+
+
+ /* cos(10piw) + pq(0)cos(8piw) + pq(1)cos(6piw) +
+ pq(2)cos(4piw) + pq(3)cod(2piw) + pq(4) */
+
+ hlp = (float)cos(omega * TWO_PI);
+ hlp1 = (float)2.0 * hlp + pq_coef[0];
+ hlp2 = (float)2.0 * hlp * hlp1 - (float)1.0 +
+ pq_coef[1];
+ hlp3 = (float)2.0 * hlp * hlp2 - hlp1 + pq_coef[2];
+ hlp4 = (float)2.0 * hlp * hlp3 - hlp2 + pq_coef[3];
+ hlp5 = hlp * hlp4 - hlp3 + pq_coef[4];
+
+
+ if (((hlp5 * (*old)) <= 0.0) || (omega >= 0.5)){
+
+ if (step_idx == (LSF_NUMBER_OF_STEPS - 1)){
+
+ if (fabs(hlp5) >= fabs(*old)) {
+ freq[lsp_index] = omega - step;
+ } else {
+ freq[lsp_index] = omega;
+ }
+
+
+ if ((*old) >= 0.0){
+ *old = (float)-1.0 * FLOAT_MAX;
+ } else {
+ *old = FLOAT_MAX;
+ }
+
+ omega = old_omega;
+ step_idx = 0;
+
+ step_idx = LSF_NUMBER_OF_STEPS;
+ } else {
+
+ if (step_idx == 0) {
+ old_omega = omega;
+ }
+
+ step_idx++;
+ omega -= steps[step_idx];
+
+ /* Go back one grid step */
+
+ step = steps[step_idx];
+ }
+ } else {
+
+ /* increment omega until they are of different sign,
+ and we know there is at least one root between omega
+ and old_omega */
+ *old = hlp5;
+ omega += step;
+ }
+
+
+ }
+ }
+
+ for (i = 0; i<LPC_FILTERORDER; i++) {
+ freq[i] = freq[i] * TWO_PI;
+ }
+}
+
+/*----------------------------------------------------------------*
+ * conversion from lsf coefficients to lpc coefficients
+ *---------------------------------------------------------------*/
+
+void lsf2a(
+ float *a_coef, /* (o) lpc coefficients */
+ float *freq /* (i) lsf coefficients */
+){
+ int i, j;
+ float hlp;
+ float p[LPC_HALFORDER], q[LPC_HALFORDER];
+ float a[LPC_HALFORDER + 1], a1[LPC_HALFORDER],
+ a2[LPC_HALFORDER];
+ float b[LPC_HALFORDER + 1], b1[LPC_HALFORDER],
+ b2[LPC_HALFORDER];
+
+ for (i=0; i<LPC_FILTERORDER; i++) {
+ freq[i] = freq[i] * PI2;
+ }
+
+ /* Check input for ill-conditioned cases. This part is not
+ found in the TIA standard. It involves the following 2 IF
+ blocks. If "freq" is judged ill-conditioned, then we first
+ modify freq[0] and freq[LPC_HALFORDER-1] (normally
+ LPC_HALFORDER = 10 for LPC applications), then we adjust
+ the other "freq" values slightly */
+
+
+ if ((freq[0] <= 0.0) || (freq[LPC_FILTERORDER - 1] >= 0.5)){
+
+
+ if (freq[0] <= 0.0) {
+ freq[0] = (float)0.022;
+ }
+
+
+ if (freq[LPC_FILTERORDER - 1] >= 0.5) {
+ freq[LPC_FILTERORDER - 1] = (float)0.499;
+ }
+
+ hlp = (freq[LPC_FILTERORDER - 1] - freq[0]) /
+ (float) (LPC_FILTERORDER - 1);
+
+ for (i=1; i<LPC_FILTERORDER; i++) {
+ freq[i] = freq[i - 1] + hlp;
+ }
+
+
+ }
+
+ memset(a1, 0, LPC_HALFORDER*sizeof(float));
+ memset(a2, 0, LPC_HALFORDER*sizeof(float));
+ memset(b1, 0, LPC_HALFORDER*sizeof(float));
+ memset(b2, 0, LPC_HALFORDER*sizeof(float));
+ memset(a, 0, (LPC_HALFORDER+1)*sizeof(float));
+ memset(b, 0, (LPC_HALFORDER+1)*sizeof(float));
+
+ /* p[i] and q[i] compute cos(2*pi*omega_{2j}) and
+ cos(2*pi*omega_{2j-1} in eqs. 4.2.2.2-1 and 4.2.2.2-2.
+ Note that for this code p[i] specifies the coefficients
+ used in .Q_A(z) while q[i] specifies the coefficients used
+ in .P_A(z) */
+
+ for (i=0; i<LPC_HALFORDER; i++) {
+ p[i] = (float)cos(TWO_PI * freq[2 * i]);
+ q[i] = (float)cos(TWO_PI * freq[2 * i + 1]);
+ }
+
+ a[0] = 0.25;
+ b[0] = 0.25;
+
+ for (i= 0; i<LPC_HALFORDER; i++) {
+ a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
+ b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
+ a2[i] = a1[i];
+ a1[i] = a[i];
+ b2[i] = b1[i];
+ b1[i] = b[i];
+ }
+
+ for (j=0; j<LPC_FILTERORDER; j++) {
+
+ if (j == 0) {
+ a[0] = 0.25;
+ b[0] = -0.25;
+ } else {
+ a[0] = b[0] = 0.0;
+ }
+
+ for (i=0; i<LPC_HALFORDER; i++) {
+ a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
+ b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
+ a2[i] = a1[i];
+ a1[i] = a[i];
+ b2[i] = b1[i];
+ b1[i] = b[i];
+ }
+
+ a_coef[j + 1] = 2 * (a[LPC_HALFORDER] + b[LPC_HALFORDER]);
+ }
+
+ a_coef[0] = 1.0;
+
+
+}
+
+
Index: lsf.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/lsf.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- lsf.h 15 Apr 2003 04:36:52 -0000 1.1
+++ lsf.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,29 +1,30 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- lsf.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_LSF_H
-#define __iLBC_LSF_H
-
-void a2lsf(
- float *freq,/* (o) lsf coefficients */
- float *a /* (i) lpc coefficients */
-);
-
-void lsf2a(
- float *a_coef, /* (o) lpc coefficients */
- float *freq /* (i) lsf coefficients */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ lsf.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+
+
+******************************************************************/
+
+#ifndef __iLBC_LSF_H
+#define __iLBC_LSF_H
+
+void a2lsf(
+ float *freq,/* (o) lsf coefficients */
+ float *a /* (i) lpc coefficients */
+);
+
+void lsf2a(
+ float *a_coef, /* (o) lpc coefficients */
+ float *freq /* (i) lsf coefficients */
+);
+
+#endif
+
+
Index: packing.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/packing.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- packing.c 15 Aug 2003 04:38:39 -0000 1.2
+++ packing.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,170 +1,174 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- packing.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#include <math.h>
-#include <stdlib.h>
-
-#include "iLBC_define.h"
-#include "constants.h"
-#include "helpfun.h"
-#include "string.h"
-#include "packing.h"
-
-/*----------------------------------------------------------------*
- * splitting an integer into first most significant bits and
- * remaining least significant bits
- *---------------------------------------------------------------*/
-
-void packsplit(
- int *index, /* (i) the value to split */
- int *firstpart, /* (o) the value specified by most
- significant bits */
- int *rest, /* (o) the value specified by least
- significant bits */
- int bitno_firstpart, /* (i) number of bits in most
- significant part */
- int bitno_total /* (i) number of bits in full range
- of value */
-){
- int bitno_rest = bitno_total-bitno_firstpart;
-
- *firstpart = *index>>(bitno_rest);
- *rest = *index-(*firstpart<<(bitno_rest));
-}
-
-/*----------------------------------------------------------------*
- * combining a value corresponding to msb's with a value
- * corresponding to lsb's
- *---------------------------------------------------------------*/
-
-void packcombine(
- int *index, /* (i/o) the msb value in the
- combined value out */
- int rest, /* (i) the lsb value */
- int bitno_rest /* (i) the number of bits in the
- lsb part */
-){
- *index = *index<<bitno_rest;
- *index += rest;
-}
-
-/*----------------------------------------------------------------*
- * packing of bits into bitstream, i.e., vector of bytes
- *---------------------------------------------------------------*/
-
-void dopack(
- unsigned char **bitstream, /* (i/o) on entrance pointer to place
- in bitstream to pack new data,
- on exit pointer to place in
- bitstream to pack future
- data */
- int index, /* (i) the value to pack */
- int bitno, /* (i) the number of bits that the
- value will fit within */
- int *pos /* (i/o) write position in the
- current byte */
-){
- int posLeft;
-
- /* Clear the bits before starting in a new byte */
-
- if ((*pos)==0) {
- **bitstream=0;
- }
-
- while (bitno>0) {
-
- /* Jump to the next byte if end of this byte is reached*/
-
- if (*pos==8) {
- *pos=0;
- (*bitstream)++;
- **bitstream=0;
- }
-
- posLeft=8-(*pos);
-
- /* Insert index into the bitstream */
-
- if (bitno <= posLeft) {
- **bitstream |= (unsigned char)(index<<(posLeft-bitno));
- *pos+=bitno;
- bitno=0;
- } else {
- **bitstream |= (unsigned char)(index>>(bitno-posLeft));
-
- *pos=8;
- index-=((index>>(bitno-posLeft))<<(bitno-posLeft));
-
- bitno-=posLeft;
- }
- }
-}
-
-/*----------------------------------------------------------------*
- * unpacking of bits from bitstream, i.e., vector of bytes
- *---------------------------------------------------------------*/
-
-void unpack(
- unsigned char **bitstream, /* (i/o) on entrance pointer to
- place in bitstream to
- unpack new data from, on
- exit pointer to place in
- bitstream to unpack future
- data from */
- int *index, /* (o) resulting value */
- int bitno, /* (i) number of bits used to
- represent the value */
- int *pos /* (i/o) read position in the
- current byte */
-){
- int BitsLeft;
-
- *index=0;
-
- while (bitno>0) {
-
- /* move forward in bitstream when the end of the
- byte is reached */
-
- if (*pos==8) {
- *pos=0;
- (*bitstream)++;
- }
-
- BitsLeft=8-(*pos);
-
- /* Extract bits to index */
-
- if (BitsLeft>=bitno) {
- *index+=((((**bitstream)<<(*pos)) & 0xFF)>>(8-bitno));
-
- *pos+=bitno;
- bitno=0;
- } else {
-
- if ((8-bitno)>0) {
- *index+=((((**bitstream)<<(*pos)) & 0xFF)>>
- (8-bitno));
- *pos=8;
- } else {
- *index+=(((int)(((**bitstream)<<(*pos)) & 0xFF))<<
- (bitno-8));
- *pos=8;
- }
- bitno-=BitsLeft;
- }
- }
-}
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ packing.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "iLBC_define.h"
+#include "constants.h"
+#include "helpfun.h"
+#include "string.h"
+
+/*----------------------------------------------------------------*
+ * splitting an integer into first most significant bits and
+ * remaining least significant bits
+ *---------------------------------------------------------------*/
+
+void packsplit(
+ int *index, /* (i) the value to split */
+ int *firstpart, /* (o) the value specified by most
+ significant bits */
+ int *rest, /* (o) the value specified by least
+ significant bits */
+ int bitno_firstpart, /* (i) number of bits in most
+ significant part */
+ int bitno_total /* (i) number of bits in full range
+ of value */
+){
+ int bitno_rest = bitno_total-bitno_firstpart;
+
+
+
+ *firstpart = *index>>(bitno_rest);
+ *rest = *index-(*firstpart<<(bitno_rest));
+}
+
+/*----------------------------------------------------------------*
+ * combining a value corresponding to msb's with a value
+ * corresponding to lsb's
+ *---------------------------------------------------------------*/
+
+void packcombine(
+ int *index, /* (i/o) the msb value in the
+ combined value out */
+ int rest, /* (i) the lsb value */
+ int bitno_rest /* (i) the number of bits in the
+ lsb part */
+){
+ *index = *index<<bitno_rest;
+ *index += rest;
+}
+
+/*----------------------------------------------------------------*
+ * packing of bits into bitstream, i.e., vector of bytes
+ *---------------------------------------------------------------*/
+
+void dopack(
+ unsigned char **bitstream, /* (i/o) on entrance pointer to
+ place in bitstream to pack
+ new data, on exit pointer
+ to place in bitstream to
+ pack future data */
+ int index, /* (i) the value to pack */
+ int bitno, /* (i) the number of bits that the
+ value will fit within */
+ int *pos /* (i/o) write position in the
+ current byte */
+){
+ int posLeft;
+
+ /* Clear the bits before starting in a new byte */
+
+ if ((*pos)==0) {
+ **bitstream=0;
+ }
+
+ while (bitno>0) {
+
+ /* Jump to the next byte if end of this byte is reached*/
+
+ if (*pos==8) {
+ *pos=0;
+ (*bitstream)++;
+ **bitstream=0;
+ }
+
+
+
+ posLeft=8-(*pos);
+
+ /* Insert index into the bitstream */
+
+ if (bitno <= posLeft) {
+ **bitstream |= (unsigned char)(index<<(posLeft-bitno));
+ *pos+=bitno;
+ bitno=0;
+ } else {
+ **bitstream |= (unsigned char)(index>>(bitno-posLeft));
+
+ *pos=8;
+ index-=((index>>(bitno-posLeft))<<(bitno-posLeft));
+
+ bitno-=posLeft;
+ }
+ }
+}
+
+/*----------------------------------------------------------------*
+ * unpacking of bits from bitstream, i.e., vector of bytes
+ *---------------------------------------------------------------*/
+
+void unpack(
+ unsigned char **bitstream, /* (i/o) on entrance pointer to
+ place in bitstream to
+ unpack new data from, on
+ exit pointer to place in
+ bitstream to unpack future
+ data from */
+ int *index, /* (o) resulting value */
+ int bitno, /* (i) number of bits used to
+ represent the value */
+ int *pos /* (i/o) read position in the
+ current byte */
+){
+ int BitsLeft;
+
+ *index=0;
+
+ while (bitno>0) {
+
+ /* move forward in bitstream when the end of the
+ byte is reached */
+
+ if (*pos==8) {
+ *pos=0;
+ (*bitstream)++;
+ }
+
+ BitsLeft=8-(*pos);
+
+ /* Extract bits to index */
+
+
+
+ if (BitsLeft>=bitno) {
+ *index+=((((**bitstream)<<(*pos)) & 0xFF)>>(8-bitno));
+
+ *pos+=bitno;
+ bitno=0;
+ } else {
+
+ if ((8-bitno)>0) {
+ *index+=((((**bitstream)<<(*pos)) & 0xFF)>>
+ (8-bitno));
+ *pos=8;
+ } else {
+ *index+=(((int)(((**bitstream)<<(*pos)) & 0xFF))<<
+ (bitno-8));
+ *pos=8;
+ }
+ bitno-=BitsLeft;
+ }
+ }
+}
+
+
Index: packing.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/packing.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- packing.h 15 Apr 2003 04:36:52 -0000 1.1
+++ packing.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,65 +1,67 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- packing.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __PACKING_H
-#define __PACKING_H
-
-void packsplit(
- int *index, /* (i) the value to split */
- int *firstpart, /* (o) the value specified by most
- significant bits */
- int *rest, /* (o) the value specified by least
- significant bits */
- int bitno_firstpart, /* (i) number of bits in most
- significant part */
- int bitno_total /* (i) number of bits in full range
- of value */
-);
-
-void packcombine(
- int *index, /* (i/o) the msb value in the
- combined value out */
- int rest, /* (i) the lsb value */
- int bitno_rest /* (i) the number of bits in the
- lsb part */
-);
-
-void dopack(
- unsigned char **bitstream, /* (i/o) on entrance pointer to place
- in bitstream to pack new data,
- on exit pointer to place in
- bitstream to pack future
- data */
- int index, /* (i) the value to pack */
- int bitno, /* (i) the number of bits that the
- value will fit within */
- int *pos /* (i/o) write position in the
- current byte */
-);
-
-void unpack(
- unsigned char **bitstream, /* (i/o) on entrance pointer to place
- in bitstream to unpack
- new data from, on exit pointer
- to place in bitstream to
- unpack future data from */
- int *index, /* (o) resulting value */
- int bitno, /* (i) number of bits used to
- represent the value */
- int *pos /* (i/o) read position in the
- current byte */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ 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
+
+
Index: syntFilter.c
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/syntFilter.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- syntFilter.c 15 Aug 2003 04:38:39 -0000 1.2
+++ syntFilter.c 14 Oct 2004 05:15:48 -0000 1.3
@@ -1,66 +1,107 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- syntFilter.c
-
- Copyright (c) 2001,
- Global IP Sound AB.
- 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<LPC_FILTERORDER;i++) {
- pi=&Out[i-1];
- pa=&a[1];
- pm=&mem[LPC_FILTERORDER-1];
- for (j=1;j<=i;j++) {
- *po-=(*pa++)*(*pi--);
- }
- for (j=i+1;j<LPC_FILTERORDER+1;j++) {
- *po-=(*pa++)*(*pm--);
- }
- po++;
- }
-
- /* Filter last part where the state is entierly in
- the output vector */
-
- for (i=LPC_FILTERORDER;i<len;i++) {
- pi=&Out[i-1];
- pa=&a[1];
- for (j=1;j<LPC_FILTERORDER+1;j++) {
- *po-=(*pa++)*(*pi--);
- }
- po++;
- }
-
- /* Update state vector */
-
- memcpy(mem, &Out[len-LPC_FILTERORDER],
- LPC_FILTERORDER*sizeof(float));
-}
-
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ syntFilter.c
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#include "iLBC_define.h"
+
+/*----------------------------------------------------------------*
+ * LP synthesis filter.
+ *---------------------------------------------------------------*/
+
+void syntFilter(
+ float *Out, /* (i/o) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len, /* (i) Length of signal */
+ float *mem /* (i/o) Filter state */
+){
+ int i, j;
+ float *po, *pi, *pa, *pm;
+
+ po=Out;
+
+ /* Filter first part using memory from past */
+
+ for (i=0; i<LPC_FILTERORDER; i++) {
+ pi=&Out[i-1];
+ pa=&a[1];
+ pm=&mem[LPC_FILTERORDER-1];
+ for (j=1; j<=i; j++) {
+ *po-=(*pa++)*(*pi--);
+ }
+ for (j=i+1; j<LPC_FILTERORDER+1; j++) {
+ *po-=(*pa++)*(*pm--);
+ }
+ po++;
+ }
+
+ /* Filter last part where the state is entierly in
+ the output vector */
+
+ for (i=LPC_FILTERORDER; i<len; i++) {
+
+
+ pi=&Out[i-1];
+ pa=&a[1];
+ for (j=1; j<LPC_FILTERORDER+1; j++) {
+ *po-=(*pa++)*(*pi--);
+ }
+ po++;
+ }
+
+ /* Update state vector */
+
+ memcpy(mem, &Out[len-LPC_FILTERORDER],
+ LPC_FILTERORDER*sizeof(float));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: syntFilter.h
===================================================================
RCS file: /usr/cvsroot/asterisk/codecs/ilbc/syntFilter.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- syntFilter.h 15 Apr 2003 04:36:52 -0000 1.1
+++ syntFilter.h 14 Oct 2004 05:15:48 -0000 1.2
@@ -1,26 +1,27 @@
-
-/******************************************************************
-
- iLBC Speech Coder ANSI-C Source Code
-
- syntFilter.h
-
- Copyright (c) 2001,
- Global IP Sound AB.
- All rights reserved.
-
-******************************************************************/
-
-#ifndef __iLBC_SYNTFILTER_H
-#define __iLBC_SYNTFILTER_H
-
-void syntFilter(
- float *Out, /* (i/o) Signal to be filtered */
- float *a, /* (i) LP parameters */
- int len, /* (i) Length of signal */
- float *mem /* (i/o) Filter state */
-);
-
-#endif
-
-
+
+/******************************************************************
+
+ iLBC Speech Coder ANSI-C Source Code
+
+ syntFilter.h
+
+ Copyright (C) The Internet Society (2004).
+ All Rights Reserved.
+
+******************************************************************/
+
+#ifndef __iLBC_SYNTFILTER_H
+#define __iLBC_SYNTFILTER_H
+
+void syntFilter(
+ float *Out, /* (i/o) Signal to be filtered */
+ float *a, /* (i) LP parameters */
+ int len, /* (i) Length of signal */
+ float *mem /* (i/o) Filter state */
+
+
+);
+
+#endif
+
+
More information about the svn-commits
mailing list