kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-07-01 05:12:37 +00:00
Code Issues Projects Releases Wiki Activity

update ilbc and lpc10 codecs from openh323 sources.

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@211 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris 2005-12-27 18:42:30 +00:00
parent 27dd35f064
commit fb85339762
87 changed files with 17943 additions and 8326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
libs/codec/ilbc/FrameClassify.c
View File

@ -1,110 +1,109 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
FrameClassify.c FrameClassify.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "iLBC_define.h" #include "iLBC_define.h"
#include "FrameClassify.h"
/*---------------------------------------------------------------*
/*---------------------------------------------------------------* * Classification of subframes to localize start state
* Classification of subframes to localize start state *--------------------------------------------------------------*/
*--------------------------------------------------------------*/
int FrameClassify( /* index to the max-energy sub-frame */
int FrameClassify( /* index to the max-energy sub-frame */ iLBC_Enc_Inst_t *iLBCenc_inst,
iLBC_Enc_Inst_t *iLBCenc_inst, /* (i/o) the encoder state structure */
/* (i/o) the encoder state structure */ float *residual /* (i) lpc residual signal */
float *residual /* (i) lpc residual signal */ ) {
) { float max_ssqEn, fssqEn[NSUB_MAX], bssqEn[NSUB_MAX], *pp;
float max_ssqEn, fssqEn[NSUB_MAX], bssqEn[NSUB_MAX], *pp; int n, l, max_ssqEn_n;
int n, l, max_ssqEn_n; const float ssqEn_win[NSUB_MAX-1]={(float)0.8,(float)0.9,
const float ssqEn_win[NSUB_MAX-1]={(float)0.8,(float)0.9, (float)1.0,(float)0.9,(float)0.8};
(float)1.0,(float)0.9,(float)0.8}; const float sampEn_win[5]={(float)1.0/(float)6.0,
const float sampEn_win[5]={(float)1.0/(float)6.0, (float)2.0/(float)6.0, (float)3.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};
(float)4.0/(float)6.0, (float)5.0/(float)6.0};
/* init the front and back energies to zero */
/* init the front and back energies to zero */
memset(fssqEn, 0, NSUB_MAX*sizeof(float));
memset(fssqEn, 0, NSUB_MAX*sizeof(float)); memset(bssqEn, 0, NSUB_MAX*sizeof(float));
memset(bssqEn, 0, NSUB_MAX*sizeof(float));
/* Calculate front of first seqence */
/* Calculate front of first seqence */
n=0;
n=0; pp=residual;
pp=residual;
for (l=0; l<5; l++) {
for (l=0; l<5; l++) { fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
fssqEn[n] += sampEn_win[l] * (*pp) * (*pp); pp++;
pp++; }
} for (l=5; l<SUBL; l++) {
for (l=5; l<SUBL; l++) { fssqEn[n] += (*pp) * (*pp);
fssqEn[n] += (*pp) * (*pp); pp++;
pp++; }
}
/* Calculate front and back of all middle sequences */
/* Calculate front and back of all middle sequences */
for (n=1; n<iLBCenc_inst->nsub-1; n++) {
for (n=1; n<iLBCenc_inst->nsub-1; n++) { pp=residual+n*SUBL;
pp=residual+n*SUBL; for (l=0; l<5; l++) {
for (l=0; l<5; l++) { fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
fssqEn[n] += sampEn_win[l] * (*pp) * (*pp); bssqEn[n] += (*pp) * (*pp);
bssqEn[n] += (*pp) * (*pp); pp++;
pp++; }
} for (l=5; l<SUBL-5; l++) {
for (l=5; l<SUBL-5; l++) { fssqEn[n] += (*pp) * (*pp);
fssqEn[n] += (*pp) * (*pp); bssqEn[n] += (*pp) * (*pp);
bssqEn[n] += (*pp) * (*pp); pp++;
pp++; }
} for (l=SUBL-5; l<SUBL; l++) {
for (l=SUBL-5; l<SUBL; l++) { fssqEn[n] += (*pp) * (*pp);
fssqEn[n] += (*pp) * (*pp); bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp); pp++;
pp++; }
} }
}
/* Calculate back of last seqence */
/* Calculate back of last seqence */
n=iLBCenc_inst->nsub-1;
n=iLBCenc_inst->nsub-1; pp=residual+n*SUBL;
pp=residual+n*SUBL; for (l=0; l<SUBL-5; l++) {
for (l=0; l<SUBL-5; l++) { bssqEn[n] += (*pp) * (*pp);
bssqEn[n] += (*pp) * (*pp); pp++;
pp++; }
} for (l=SUBL-5; l<SUBL; l++) {
for (l=SUBL-5; l<SUBL; l++) { bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp);
bssqEn[n] += sampEn_win[SUBL-l-1] * (*pp) * (*pp); pp++;
pp++; }
}
/* find the index to the weighted 80 sample with
/* find the index to the weighted 80 sample with most energy */
most energy */
if (iLBCenc_inst->mode==20) l=1;
if (iLBCenc_inst->mode==20) l=1; else l=0;
else l=0;
max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[l];
max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[l]; max_ssqEn_n=1;
max_ssqEn_n=1; for (n=2; n<iLBCenc_inst->nsub; n++) {
for (n=2; n<iLBCenc_inst->nsub; n++) {
l++;
l++;
if ((fssqEn[n-1]+bssqEn[n])*ssqEn_win[l] > max_ssqEn) {
if ((fssqEn[n-1]+bssqEn[n])*ssqEn_win[l] > max_ssqEn) { max_ssqEn=(fssqEn[n-1]+bssqEn[n]) *
max_ssqEn=(fssqEn[n-1]+bssqEn[n]) * ssqEn_win[l];
ssqEn_win[l]; max_ssqEn_n=n;
max_ssqEn_n=n; }
} }
}
return max_ssqEn_n;
return max_ssqEn_n; }
}

52
libs/codec/ilbc/FrameClassify.h
View File

@ -1,26 +1,26 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
FrameClassify.h FrameClassify.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_FRAMECLASSIFY_H #ifndef __iLBC_FRAMECLASSIFY_H
#define __iLBC_FRAMECLASSIFY_H #define __iLBC_FRAMECLASSIFY_H
int FrameClassify( /* index to the max-energy sub-frame */ int FrameClassify( /* index to the max-energy sub-frame */
iLBC_Enc_Inst_t *iLBCenc_inst, iLBC_Enc_Inst_t *iLBCenc_inst,
/* (i/o) the encoder state structure */ /* (i/o) the encoder state structure */
float *residual /* (i) lpc residual signal */ float *residual /* (i) lpc residual signal */
); );
#endif #endif

303
libs/codec/ilbc/LPCdecode.c
View File

@ -1,152 +1,151 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
LPC_decode.c LPC_decode.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
#include "helpfun.h" #include "helpfun.h"
#include "lsf.h" #include "lsf.h"
#include "iLBC_define.h" #include "iLBC_define.h"
#include "LPCdecode.h" #include "constants.h"
#include "constants.h"
/*---------------------------------------------------------------*
/*---------------------------------------------------------------* * interpolation of lsf coefficients for the decoder
* interpolation of lsf coefficients for the decoder *--------------------------------------------------------------*/
*--------------------------------------------------------------*/
void LSFinterpolate2a_dec(
void LSFinterpolate2a_dec( float *a, /* (o) lpc coefficients for a sub-frame */
float *a, /* (o) lpc coefficients for a sub-frame */ float *lsf1, /* (i) first lsf coefficient vector */
float *lsf1, /* (i) first lsf coefficient vector */
float *lsf2, /* (i) second lsf coefficient vector */
float *lsf2, /* (i) second lsf coefficient vector */ float coef, /* (i) interpolation weight */
float coef, /* (i) interpolation weight */ int length /* (i) length of lsf vectors */
int length /* (i) length of lsf vectors */ ){
){ float lsftmp[LPC_FILTERORDER];
float lsftmp[LPC_FILTERORDER];
interpolate(lsftmp, lsf1, lsf2, coef, length);
interpolate(lsftmp, lsf1, lsf2, coef, length); lsf2a(a, lsftmp);
lsf2a(a, lsftmp); }
}
/*---------------------------------------------------------------*
/*---------------------------------------------------------------* * obtain dequantized lsf coefficients from quantization index
* obtain dequantized lsf coefficients from quantization index *--------------------------------------------------------------*/
*--------------------------------------------------------------*/
void SimplelsfDEQ(
void SimplelsfDEQ( float *lsfdeq, /* (o) dequantized lsf coefficients */
float *lsfdeq, /* (o) dequantized lsf coefficients */ int *index, /* (i) quantization index */
int *index, /* (i) quantization index */ int lpc_n /* (i) number of LPCs */
int lpc_n /* (i) number of LPCs */ ){
){ int i, j, pos, cb_pos;
int i, j, pos, cb_pos;
/* decode first LSF */
/* decode first LSF */
pos = 0;
pos = 0; cb_pos = 0;
cb_pos = 0; for (i = 0; i < LSF_NSPLIT; i++) {
for (i = 0; i < LSF_NSPLIT; i++) { for (j = 0; j < dim_lsfCbTbl[i]; j++) {
for (j = 0; j < dim_lsfCbTbl[i]; j++) { lsfdeq[pos + j] = lsfCbTbl[cb_pos +
lsfdeq[pos + j] = lsfCbTbl[cb_pos + (long)(index[i])*dim_lsfCbTbl[i] + j];
(long)(index[i])*dim_lsfCbTbl[i] + j]; }
} pos += dim_lsfCbTbl[i];
pos += dim_lsfCbTbl[i]; cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i];
cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i]; }
}
if (lpc_n>1) {
if (lpc_n>1) {
/* decode last LSF */
/* decode last LSF */
pos = 0;
pos = 0; cb_pos = 0;
cb_pos = 0; for (i = 0; i < LSF_NSPLIT; i++) {
for (i = 0; i < LSF_NSPLIT; i++) { for (j = 0; j < dim_lsfCbTbl[i]; j++) {
for (j = 0; j < dim_lsfCbTbl[i]; j++) { lsfdeq[LPC_FILTERORDER + pos + j] =
lsfdeq[LPC_FILTERORDER + pos + j] = lsfCbTbl[cb_pos +
lsfCbTbl[cb_pos + (long)(index[LSF_NSPLIT + i])*
(long)(index[LSF_NSPLIT + i])* dim_lsfCbTbl[i] + j];
dim_lsfCbTbl[i] + j]; }
} pos += dim_lsfCbTbl[i];
pos += dim_lsfCbTbl[i]; cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i];
cb_pos += size_lsfCbTbl[i]*dim_lsfCbTbl[i]; }
} }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------*
* obtain synthesis and weighting filters form lsf coefficients
* obtain synthesis and weighting filters form lsf coefficients *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void DecoderInterpolateLSF(
void DecoderInterpolateLSF( float *syntdenum, /* (o) synthesis filter coefficients */
float *syntdenum, /* (o) synthesis filter coefficients */ float *weightdenum, /* (o) weighting denumerator
float *weightdenum, /* (o) weighting denumerator coefficients */
coefficients */ float *lsfdeq, /* (i) dequantized lsf coefficients */
float *lsfdeq, /* (i) dequantized lsf coefficients */ int length, /* (i) length of lsf coefficient vector */
int length, /* (i) length of lsf coefficient vector */ iLBC_Dec_Inst_t *iLBCdec_inst
iLBC_Dec_Inst_t *iLBCdec_inst /* (i) the decoder state structure */
/* (i) the decoder state structure */ ){
){ int i, pos, lp_length;
int i, pos, lp_length; float lp[LPC_FILTERORDER + 1], *lsfdeq2;
float lp[LPC_FILTERORDER + 1], *lsfdeq2;
lsfdeq2 = lsfdeq + length;
lsfdeq2 = lsfdeq + length; lp_length = length + 1;
lp_length = length + 1;
if (iLBCdec_inst->mode==30) {
if (iLBCdec_inst->mode==30) { /* sub-frame 1: Interpolation between old and first */
/* sub-frame 1: Interpolation between old and first */
LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, lsfdeq,
LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, lsfdeq, lsf_weightTbl_30ms[0], length);
lsf_weightTbl_30ms[0], length); memcpy(syntdenum,lp,lp_length*sizeof(float));
memcpy(syntdenum,lp,lp_length*sizeof(float)); bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM,
bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
lp_length);
/* sub-frames 2 to 6: interpolation between first
/* sub-frames 2 to 6: interpolation between first and last LSF */
and last LSF */
pos = lp_length;
pos = lp_length; for (i = 1; i < 6; i++) {
for (i = 1; i < 6; i++) { LSFinterpolate2a_dec(lp, lsfdeq, lsfdeq2,
LSFinterpolate2a_dec(lp, lsfdeq, lsfdeq2, lsf_weightTbl_30ms[i], length);
lsf_weightTbl_30ms[i], length); memcpy(syntdenum + pos,lp,lp_length*sizeof(float));
memcpy(syntdenum + pos,lp,lp_length*sizeof(float)); bwexpand(weightdenum + pos, lp,
bwexpand(weightdenum + pos, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
LPC_CHIRP_WEIGHTDENUM, lp_length); pos += lp_length;
pos += lp_length; }
} }
} else {
else { pos = 0;
pos = 0; for (i = 0; i < iLBCdec_inst->nsub; i++) {
for (i = 0; i < iLBCdec_inst->nsub; i++) { LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold,
LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, lsfdeq, lsf_weightTbl_20ms[i], length);
lsfdeq, lsf_weightTbl_20ms[i], length); memcpy(syntdenum+pos,lp,lp_length*sizeof(float));
memcpy(syntdenum+pos,lp,lp_length*sizeof(float)); bwexpand(weightdenum+pos, lp, LPC_CHIRP_WEIGHTDENUM,
bwexpand(weightdenum+pos, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);
lp_length); pos += lp_length;
pos += lp_length; }
} }
}
/* update memory */
/* update memory */
if (iLBCdec_inst->mode==30)
if (iLBCdec_inst->mode==30) memcpy(iLBCdec_inst->lsfdeqold, lsfdeq2,
memcpy(iLBCdec_inst->lsfdeqold, lsfdeq2, length*sizeof(float));
length*sizeof(float)); else
else memcpy(iLBCdec_inst->lsfdeqold, lsfdeq,
memcpy(iLBCdec_inst->lsfdeqold, lsfdeq, length*sizeof(float));
length*sizeof(float));
}
}

88
libs/codec/ilbc/LPCdecode.h
View File

@ -1,44 +1,44 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
LPC_decode.h LPC_decode.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_LPC_DECODE_H #ifndef __iLBC_LPC_DECODE_H
#define __iLBC_LPC_DECODE_H #define __iLBC_LPC_DECODE_H
void LSFinterpolate2a_dec( void LSFinterpolate2a_dec(
float *a, /* (o) lpc coefficients for a sub-frame */ float *a, /* (o) lpc coefficients for a sub-frame */
float *lsf1, /* (i) first lsf coefficient vector */ float *lsf1, /* (i) first lsf coefficient vector */
float *lsf2, /* (i) second lsf coefficient vector */ float *lsf2, /* (i) second lsf coefficient vector */
float coef, /* (i) interpolation weight */ float coef, /* (i) interpolation weight */
int length /* (i) length of lsf vectors */ int length /* (i) length of lsf vectors */
); );
void SimplelsfDEQ( void SimplelsfDEQ(
float *lsfdeq, /* (o) dequantized lsf coefficients */ float *lsfdeq, /* (o) dequantized lsf coefficients */
int *index, /* (i) quantization index */ int *index, /* (i) quantization index */
int lpc_n /* (i) number of LPCs */ int lpc_n /* (i) number of LPCs */
); );
void DecoderInterpolateLSF( void DecoderInterpolateLSF(
float *syntdenum, /* (o) synthesis filter coefficients */ float *syntdenum, /* (o) synthesis filter coefficients */
float *weightdenum, /* (o) weighting denumerator float *weightdenum, /* (o) weighting denumerator
coefficients */ coefficients */
float *lsfdeq, /* (i) dequantized lsf coefficients */ float *lsfdeq, /* (i) dequantized lsf coefficients */
int length, /* (i) length of lsf coefficient vector */ int length, /* (i) length of lsf coefficient vector */
iLBC_Dec_Inst_t *iLBCdec_inst iLBC_Dec_Inst_t *iLBCdec_inst
/* (i) the decoder state structure */ /* (i) the decoder state structure */
); );
#endif #endif

453
libs/codec/ilbc/LPCencode.c
View File

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

58
libs/codec/ilbc/LPCencode.h
View File

@ -1,29 +1,29 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
LPCencode.h LPCencode.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_LPCENCOD_H #ifndef __iLBC_LPCENCOD_H
#define __iLBC_LPCENCOD_H #define __iLBC_LPCENCOD_H
void LPCencode( void LPCencode(
float *syntdenum, /* (i/o) synthesis filter coefficients float *syntdenum, /* (i/o) synthesis filter coefficients
before/after encoding */ before/after encoding */
float *weightdenum, /* (i/o) weighting denumerator coefficients float *weightdenum, /* (i/o) weighting denumerator coefficients
before/after encoding */ before/after encoding */
int *lsf_index, /* (o) lsf quantization index */ int *lsf_index, /* (o) lsf quantization index */
float *data, /* (i) lsf coefficients to quantize */ float *data, /* (i) lsf coefficients to quantize */
iLBC_Enc_Inst_t *iLBCenc_inst iLBC_Enc_Inst_t *iLBCenc_inst
/* (i/o) the encoder state structure */ /* (i/o) the encoder state structure */
); );
#endif #endif

151
libs/codec/ilbc/StateConstructW.c
View File

@ -1,76 +1,75 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
StateConstructW.c StateConstructW.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "StateConstructW.h" #include "constants.h"
#include "constants.h" #include "filter.h"
#include "filter.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * decoding of the start state
* decoding of the start state *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void StateConstructW(
void StateConstructW( int idxForMax, /* (i) 6-bit index for the quantization of
int idxForMax, /* (i) 6-bit index for the quantization of max amplitude */
max amplitude */ int *idxVec, /* (i) vector of quantization indexes */
int *idxVec, /* (i) vector of quantization indexes */ float *syntDenum, /* (i) synthesis filter denumerator */
float *syntDenum, /* (i) synthesis filter denumerator */ float *out, /* (o) the decoded state vector */
float *out, /* (o) the decoded state vector */ int len /* (i) length of a state vector */
int len /* (i) length of a state vector */ ){
){ float maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_LEN], *tmp,
float maxVal, tmpbuf[LPC_FILTERORDER+2*STATE_LEN], *tmp, numerator[LPC_FILTERORDER+1];
numerator[LPC_FILTERORDER+1]; float foutbuf[LPC_FILTERORDER+2*STATE_LEN], *fout;
float foutbuf[LPC_FILTERORDER+2*STATE_LEN], *fout; int k,tmpi;
int k,tmpi;
/* decoding of the maximum value */
/* decoding of the maximum value */
maxVal = state_frgqTbl[idxForMax];
maxVal = state_frgqTbl[idxForMax]; maxVal = (float)pow(10,maxVal)/(float)4.5;
maxVal = (float)pow(10,maxVal)/(float)4.5;
/* initialization of buffers and coefficients */
/* initialization of buffers and coefficients */
memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float)); memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float)); for (k=0; k<LPC_FILTERORDER; k++) {
for (k=0; k<LPC_FILTERORDER; k++) { numerator[k]=syntDenum[LPC_FILTERORDER-k];
numerator[k]=syntDenum[LPC_FILTERORDER-k]; }
} numerator[LPC_FILTERORDER]=syntDenum[0];
numerator[LPC_FILTERORDER]=syntDenum[0]; tmp = &tmpbuf[LPC_FILTERORDER];
tmp = &tmpbuf[LPC_FILTERORDER]; fout = &foutbuf[LPC_FILTERORDER];
fout = &foutbuf[LPC_FILTERORDER];
/* decoding of the sample values */
/* decoding of the sample values */
for (k=0; k<len; k++) {
for (k=0; k<len; k++) { tmpi = len-1-k;
tmpi = len-1-k; /* maxVal = 1/scal */
/* maxVal = 1/scal */
tmp[k] = maxVal*state_sq3Tbl[idxVec[tmpi]];
tmp[k] = maxVal*state_sq3Tbl[idxVec[tmpi]]; }
}
/* circular convolution with all-pass filter */
/* circular convolution with all-pass filter */
memset(tmp+len, 0, len*sizeof(float));
memset(tmp+len, 0, len*sizeof(float)); ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
ZeroPoleFilter(tmp, numerator, syntDenum, 2*len, LPC_FILTERORDER, fout);
LPC_FILTERORDER, fout); for (k=0;k<len;k++) {
for (k=0;k<len;k++) { out[k] = fout[len-1-k]+fout[2*len-1-k];
out[k] = fout[len-1-k]+fout[2*len-1-k]; }
} }
}

54
libs/codec/ilbc/StateConstructW.h
View File

@ -1,27 +1,27 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
StateConstructW.h StateConstructW.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_STATECONSTRUCTW_H #ifndef __iLBC_STATECONSTRUCTW_H
#define __iLBC_STATECONSTRUCTW_H #define __iLBC_STATECONSTRUCTW_H
void StateConstructW( void StateConstructW(
int idxForMax, /* (i) 6-bit index for the quantization of int idxForMax, /* (i) 6-bit index for the quantization of
max amplitude */ max amplitude */
int *idxVec, /* (i) vector of quantization indexes */ int *idxVec, /* (i) vector of quantization indexes */
float *syntDenum, /* (i) synthesis filter denumerator */ float *syntDenum, /* (i) synthesis filter denumerator */
float *out, /* (o) the decoded state vector */ float *out, /* (o) the decoded state vector */
int len /* (i) length of a state vector */ int len /* (i) length of a state vector */
); );
#endif #endif

387
libs/codec/ilbc/StateSearchW.c
View File

@ -1,194 +1,193 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
StateSearchW.c StateSearchW.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "StateSearchW.h" #include "constants.h"
#include "constants.h" #include "filter.h"
#include "filter.h" #include "helpfun.h"
#include "helpfun.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * predictive noise shaping encoding of scaled start state
* predictive noise shaping encoding of scaled start state * (subrutine for StateSearchW)
* (subrutine for StateSearchW) *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void AbsQuantW(
void AbsQuantW( iLBC_Enc_Inst_t *iLBCenc_inst,
iLBC_Enc_Inst_t *iLBCenc_inst, /* (i) Encoder instance */
/* (i) Encoder instance */ float *in, /* (i) vector to encode */
float *in, /* (i) vector to encode */ float *syntDenum, /* (i) denominator of synthesis filter */
float *syntDenum, /* (i) denominator of synthesis filter */ float *weightDenum, /* (i) denominator of weighting filter */
float *weightDenum, /* (i) denominator of weighting filter */ int *out, /* (o) vector of quantizer indexes */
int *out, /* (o) vector of quantizer indexes */ int len, /* (i) length of vector to encode and
int len, /* (i) length of vector to encode and vector of quantizer indexes */
vector of quantizer indexes */ int state_first /* (i) position of start state in the
int state_first /* (i) position of start state in the 80 vec */
80 vec */ ){
){ float *syntOut;
float *syntOut; float syntOutBuf[LPC_FILTERORDER+STATE_SHORT_LEN_30MS];
float syntOutBuf[LPC_FILTERORDER+STATE_SHORT_LEN_30MS]; float toQ, xq;
float toQ, xq; int n;
int n; int index;
int index;
/* initialization of buffer for filtering */
/* initialization of buffer for filtering */
memset(syntOutBuf, 0, LPC_FILTERORDER*sizeof(float));
memset(syntOutBuf, 0, LPC_FILTERORDER*sizeof(float));
/* initialization of pointer for filtering */
/* initialization of pointer for filtering */
syntOut = &syntOutBuf[LPC_FILTERORDER];
syntOut = &syntOutBuf[LPC_FILTERORDER];
/* synthesis and weighting filters on input */
/* synthesis and weighting filters on input */
if (state_first) {
if (state_first) { AllPoleFilter (in, weightDenum, SUBL, LPC_FILTERORDER);
AllPoleFilter (in, weightDenum, SUBL, LPC_FILTERORDER); } else {
} else { AllPoleFilter (in, weightDenum,
AllPoleFilter (in, weightDenum, iLBCenc_inst->state_short_len-SUBL,
iLBCenc_inst->state_short_len-SUBL, LPC_FILTERORDER);
LPC_FILTERORDER); }
}
/* encoding loop */
/* encoding loop */
for (n=0; n<len; n++) {
for (n=0; n<len; n++) {
/* time update of filter coefficients */
/* time update of filter coefficients */
if ((state_first)&&(n==SUBL)){
if ((state_first)&&(n==SUBL)){ syntDenum += (LPC_FILTERORDER+1);
syntDenum += (LPC_FILTERORDER+1); weightDenum += (LPC_FILTERORDER+1);
weightDenum += (LPC_FILTERORDER+1);
/* synthesis and weighting filters on input */
/* synthesis and weighting filters on input */ AllPoleFilter (&in[n], weightDenum, len-n,
AllPoleFilter (&in[n], weightDenum, len-n, LPC_FILTERORDER);
LPC_FILTERORDER);
} else if ((state_first==0)&&
} else if ((state_first==0)&& (n==(iLBCenc_inst->state_short_len-SUBL))) {
(n==(iLBCenc_inst->state_short_len-SUBL))) { syntDenum += (LPC_FILTERORDER+1);
syntDenum += (LPC_FILTERORDER+1); weightDenum += (LPC_FILTERORDER+1);
weightDenum += (LPC_FILTERORDER+1);
/* synthesis and weighting filters on input */
/* synthesis and weighting filters on input */ AllPoleFilter (&in[n], weightDenum, len-n,
AllPoleFilter (&in[n], weightDenum, len-n, LPC_FILTERORDER);
LPC_FILTERORDER);
}
}
/* prediction of synthesized and weighted input */
/* prediction of synthesized and weighted input */
syntOut[n] = 0.0;
syntOut[n] = 0.0; AllPoleFilter (&syntOut[n], weightDenum, 1,
AllPoleFilter (&syntOut[n], weightDenum, 1, LPC_FILTERORDER);
LPC_FILTERORDER);
/* quantization */
/* quantization */
toQ = in[n]-syntOut[n];
toQ = in[n]-syntOut[n]; sort_sq(&xq, &index, toQ, state_sq3Tbl, 8);
sort_sq(&xq, &index, toQ, state_sq3Tbl, 8); out[n]=index;
out[n]=index; syntOut[n] = state_sq3Tbl[out[n]];
syntOut[n] = state_sq3Tbl[out[n]];
/* update of the prediction filter */
/* update of the prediction filter */
AllPoleFilter(&syntOut[n], weightDenum, 1,
AllPoleFilter(&syntOut[n], weightDenum, 1, LPC_FILTERORDER);
LPC_FILTERORDER); }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * encoding of start state
* encoding of start state *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void StateSearchW(
void StateSearchW( iLBC_Enc_Inst_t *iLBCenc_inst,
iLBC_Enc_Inst_t *iLBCenc_inst, /* (i) Encoder instance */
/* (i) Encoder instance */ float *residual,/* (i) target residual vector */
float *residual,/* (i) target residual vector */ float *syntDenum, /* (i) lpc synthesis filter */
float *syntDenum, /* (i) lpc synthesis filter */ float *weightDenum, /* (i) weighting filter denuminator */
float *weightDenum, /* (i) weighting filter denuminator */ int *idxForMax, /* (o) quantizer index for maximum
int *idxForMax, /* (o) quantizer index for maximum amplitude */
amplitude */ int *idxVec, /* (o) vector of quantization indexes */
int *idxVec, /* (o) vector of quantization indexes */ int len, /* (i) length of all vectors */
int len, /* (i) length of all vectors */ int state_first /* (i) position of start state in the
int state_first /* (i) position of start state in the 80 vec */
80 vec */ ){
){ float dtmp, maxVal;
float dtmp, maxVal; float tmpbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN_30MS];
float tmpbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN_30MS]; float *tmp, numerator[1+LPC_FILTERORDER];
float *tmp, numerator[1+LPC_FILTERORDER]; float foutbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN_30MS], *fout;
float foutbuf[LPC_FILTERORDER+2*STATE_SHORT_LEN_30MS], *fout; int k;
int k; float qmax, scal;
float qmax, scal;
/* initialization of buffers and filter coefficients */
/* initialization of buffers and filter coefficients */
memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float));
memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float)); memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float));
memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float)); for (k=0; k<LPC_FILTERORDER; k++) {
for (k=0; k<LPC_FILTERORDER; k++) { numerator[k]=syntDenum[LPC_FILTERORDER-k];
numerator[k]=syntDenum[LPC_FILTERORDER-k]; }
} numerator[LPC_FILTERORDER]=syntDenum[0];
numerator[LPC_FILTERORDER]=syntDenum[0]; tmp = &tmpbuf[LPC_FILTERORDER];
tmp = &tmpbuf[LPC_FILTERORDER]; fout = &foutbuf[LPC_FILTERORDER];
fout = &foutbuf[LPC_FILTERORDER];
/* circular convolution with the all-pass filter */
/* circular convolution with the all-pass filter */
memcpy(tmp, residual, len*sizeof(float));
memcpy(tmp, residual, len*sizeof(float)); memset(tmp+len, 0, len*sizeof(float));
memset(tmp+len, 0, len*sizeof(float)); ZeroPoleFilter(tmp, numerator, syntDenum, 2*len,
ZeroPoleFilter(tmp, numerator, syntDenum, 2*len, LPC_FILTERORDER, fout);
LPC_FILTERORDER, fout); for (k=0; k<len; k++) {
for (k=0; k<len; k++) { fout[k] += fout[k+len];
fout[k] += fout[k+len]; }
}
/* identification of the maximum amplitude value */
/* identification of the maximum amplitude value */
maxVal = fout[0];
maxVal = fout[0];
for (k=1; k<len; k++) {
for (k=1; k<len; k++) {
if (fout[k]*fout[k] > maxVal*maxVal){
if (fout[k]*fout[k] > maxVal*maxVal){ maxVal = fout[k];
maxVal = fout[k]; }
} }
} maxVal=(float)fabs(maxVal);
maxVal=(float)fabs(maxVal);
/* encoding of the maximum amplitude value */
/* encoding of the maximum amplitude value */
if (maxVal < 10.0) {
if (maxVal < 10.0) { maxVal = 10.0;
maxVal = 10.0; }
} maxVal = (float)log10(maxVal);
maxVal = (float)log10(maxVal); sort_sq(&dtmp, idxForMax, maxVal, state_frgqTbl, 64);
sort_sq(&dtmp, idxForMax, maxVal, state_frgqTbl, 64);
/* decoding of the maximum amplitude representation value,
/* decoding of the maximum amplitude representation value, and corresponding scaling of start state */
and corresponding scaling of start state */
maxVal=state_frgqTbl[*idxForMax];
maxVal=state_frgqTbl[*idxForMax]; qmax = (float)pow(10,maxVal);
qmax = (float)pow(10,maxVal); scal = (float)(4.5)/qmax;
scal = (float)(4.5)/qmax; for (k=0; k<len; k++){
for (k=0; k<len; k++){ fout[k] *= scal;
fout[k] *= scal; }
}
/* predictive noise shaping encoding of scaled start state */
/* predictive noise shaping encoding of scaled start state */
AbsQuantW(iLBCenc_inst, fout,syntDenum,
AbsQuantW(iLBCenc_inst, fout,syntDenum, weightDenum,idxVec, len, state_first);
weightDenum,idxVec, len, state_first); }
}

96
libs/codec/ilbc/StateSearchW.h
View File

@ -1,48 +1,48 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
StateSearchW.h StateSearchW.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_STATESEARCHW_H #ifndef __iLBC_STATESEARCHW_H
#define __iLBC_STATESEARCHW_H #define __iLBC_STATESEARCHW_H
void AbsQuantW( void AbsQuantW(
iLBC_Enc_Inst_t *iLBCenc_inst, iLBC_Enc_Inst_t *iLBCenc_inst,
/* (i) Encoder instance */ /* (i) Encoder instance */
float *in, /* (i) vector to encode */ float *in, /* (i) vector to encode */
float *syntDenum, /* (i) denominator of synthesis filter */ float *syntDenum, /* (i) denominator of synthesis filter */
float *weightDenum, /* (i) denominator of weighting filter */ float *weightDenum, /* (i) denominator of weighting filter */
int *out, /* (o) vector of quantizer indexes */ int *out, /* (o) vector of quantizer indexes */
int len, /* (i) length of vector to encode and int len, /* (i) length of vector to encode and
vector of quantizer indexes */ vector of quantizer indexes */
int state_first /* (i) position of start state in the int state_first /* (i) position of start state in the
80 vec */ 80 vec */
); );
void StateSearchW( void StateSearchW(
iLBC_Enc_Inst_t *iLBCenc_inst, iLBC_Enc_Inst_t *iLBCenc_inst,
/* (i) Encoder instance */ /* (i) Encoder instance */
float *residual,/* (i) target residual vector */ float *residual,/* (i) target residual vector */
float *syntDenum, /* (i) lpc synthesis filter */ float *syntDenum, /* (i) lpc synthesis filter */
float *weightDenum, /* (i) weighting filter denuminator */ float *weightDenum, /* (i) weighting filter denuminator */
int *idxForMax, /* (o) quantizer index for maximum int *idxForMax, /* (o) quantizer index for maximum
amplitude */ amplitude */
int *idxVec, /* (o) vector of quantization indexes */ int *idxVec, /* (o) vector of quantization indexes */
int len, /* (i) length of all vectors */ int len, /* (i) length of all vectors */
int state_first /* (i) position of start state in the int state_first /* (i) position of start state in the
80 vec */ 80 vec */
); );
#endif #endif

141
libs/codec/ilbc/anaFilter.c
View File

@ -1,71 +1,70 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
anaFilter.c anaFilter.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <string.h> #include <string.h>
#include "anaFilter.h" #include "iLBC_define.h"
#include "iLBC_define.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * LP analysis filter.
* LP analysis filter.
*---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void anaFilter(
void anaFilter( float *In, /* (i) Signal to be filtered */
float *In, /* (i) Signal to be filtered */ float *a, /* (i) LP parameters */
float *a, /* (i) LP parameters */ int len,/* (i) Length of signal */
int len,/* (i) Length of signal */ float *Out, /* (o) Filtered signal */
float *Out, /* (o) Filtered signal */ float *mem /* (i/o) Filter state */
float *mem /* (i/o) Filter state */ ){
){ int i, j;
int i, j; float *po, *pi, *pm, *pa;
float *po, *pi, *pm, *pa;
po = Out;
po = Out;
/* Filter first part using memory from past */
/* Filter first part using memory from past */
for (i=0; i<LPC_FILTERORDER; i++) {
for (i=0; i<LPC_FILTERORDER; i++) { pi = &In[i];
pi = &In[i]; pm = &mem[LPC_FILTERORDER-1];
pm = &mem[LPC_FILTERORDER-1]; pa = a;
pa = a; *po=0.0;
*po=0.0; for (j=0; j<=i; j++) {
for (j=0; j<=i; j++) { *po+=(*pa++)*(*pi--);
*po+=(*pa++)*(*pi--); }
} for (j=i+1; j<LPC_FILTERORDER+1; j++) {
for (j=i+1; j<LPC_FILTERORDER+1; j++) {
*po+=(*pa++)*(*pm--);
*po+=(*pa++)*(*pm--); }
} po++;
po++; }
}
/* Filter last part where the state is entierly
/* Filter last part where the state is entierly in the input vector */
in the input vector */
for (i=LPC_FILTERORDER; i<len; i++) {
for (i=LPC_FILTERORDER; i<len; i++) { pi = &In[i];
pi = &In[i]; pa = a;
pa = a; *po=0.0;
*po=0.0; for (j=0; j<LPC_FILTERORDER+1; j++) {
for (j=0; j<LPC_FILTERORDER+1; j++) { *po+=(*pa++)*(*pi--);
*po+=(*pa++)*(*pi--); }
} po++;
po++; }
}
/* Update state vector */
/* Update state vector */
memcpy(mem, &In[len-LPC_FILTERORDER],
memcpy(mem, &In[len-LPC_FILTERORDER], LPC_FILTERORDER*sizeof(float));
LPC_FILTERORDER*sizeof(float)); }
}

52
libs/codec/ilbc/anaFilter.h
View File

@ -1,26 +1,26 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
anaFilter.h anaFilter.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_ANAFILTER_H #ifndef __iLBC_ANAFILTER_H
#define __iLBC_ANAFILTER_H #define __iLBC_ANAFILTER_H
void anaFilter( void anaFilter(
float *In, /* (i) Signal to be filtered */ float *In, /* (i) Signal to be filtered */
float *a, /* (i) LP parameters */ float *a, /* (i) LP parameters */
int len,/* (i) Length of signal */ int len,/* (i) Length of signal */
float *Out, /* (o) Filtered signal */ float *Out, /* (o) Filtered signal */
float *mem /* (i/o) Filter state */ float *mem /* (i/o) Filter state */
); );
#endif #endif

1458
libs/codec/ilbc/constants.c
View File

File diff suppressed because it is too large Load Diff

148
libs/codec/ilbc/constants.h
View File

@ -1,74 +1,74 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
constants.h constants.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_CONSTANTS_H #ifndef __iLBC_CONSTANTS_H
#define __iLBC_CONSTANTS_H #define __iLBC_CONSTANTS_H
#include "iLBC_define.h" #include "iLBC_define.h"
/* ULP bit allocation */ /* ULP bit allocation */
extern const iLBC_ULP_Inst_t ULP_20msTbl; extern const iLBC_ULP_Inst_t ULP_20msTbl;
extern const iLBC_ULP_Inst_t ULP_30msTbl; extern const iLBC_ULP_Inst_t ULP_30msTbl;
/* high pass filters */ /* high pass filters */
extern float hpi_zero_coefsTbl[]; extern float hpi_zero_coefsTbl[];
extern float hpi_pole_coefsTbl[]; extern float hpi_pole_coefsTbl[];
extern float hpo_zero_coefsTbl[]; extern float hpo_zero_coefsTbl[];
extern float hpo_pole_coefsTbl[]; extern float hpo_pole_coefsTbl[];
/* low pass filters */ /* low pass filters */
extern float lpFilt_coefsTbl[]; extern float lpFilt_coefsTbl[];
/* LPC analysis and quantization */ /* LPC analysis and quantization */
extern float lpc_winTbl[]; extern float lpc_winTbl[];
extern float lpc_asymwinTbl[]; extern float lpc_asymwinTbl[];
extern float lpc_lagwinTbl[]; extern float lpc_lagwinTbl[];
extern float lsfCbTbl[]; extern float lsfCbTbl[];
extern float lsfmeanTbl[]; extern float lsfmeanTbl[];
extern int dim_lsfCbTbl[]; extern int dim_lsfCbTbl[];
extern int size_lsfCbTbl[]; extern int size_lsfCbTbl[];
extern float lsf_weightTbl_30ms[]; extern float lsf_weightTbl_30ms[];
extern float lsf_weightTbl_20ms[]; extern float lsf_weightTbl_20ms[];
/* state quantization tables */ /* state quantization tables */
extern float state_sq3Tbl[]; extern float state_sq3Tbl[];
extern float state_frgqTbl[]; extern float state_frgqTbl[];
/* gain quantization tables */ /* gain quantization tables */
extern float gain_sq3Tbl[]; extern float gain_sq3Tbl[];
extern float gain_sq4Tbl[]; extern float gain_sq4Tbl[];
extern float gain_sq5Tbl[]; extern float gain_sq5Tbl[];
/* adaptive codebook definitions */ /* adaptive codebook definitions */
extern int search_rangeTbl[5][CB_NSTAGES]; extern int search_rangeTbl[5][CB_NSTAGES];
extern int memLfTbl[]; extern int memLfTbl[];
extern int stMemLTbl; extern int stMemLTbl;
extern float cbfiltersTbl[CB_FILTERLEN]; extern float cbfiltersTbl[CB_FILTERLEN];
/* enhancer definitions */ /* enhancer definitions */
extern float polyphaserTbl[]; extern float polyphaserTbl[];
extern float enh_plocsTbl[]; extern float enh_plocsTbl[];
#endif #endif

431
libs/codec/ilbc/createCB.c
View File

@ -1,216 +1,215 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
createCB.c createCB.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "iLBC_define.h" #include "iLBC_define.h"
#include "createCB.h" #include "constants.h"
#include "constants.h" #include <string.h>
#include <string.h> #include <math.h>
#include <math.h>
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Construct an additional codebook vector by filtering the
* Construct an additional codebook vector by filtering the * initial codebook buffer. This vector is then used to expand
* initial codebook buffer. This vector is then used to expand * the codebook with an additional section.
* the codebook with an additional section. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void filteredCBvecs(
void filteredCBvecs( float *cbvectors, /* (o) Codebook vectors for the
float *cbvectors, /* (o) Codebook vectors for the higher section */
higher section */ float *mem, /* (i) Buffer to create codebook
float *mem, /* (i) Buffer to create codebook vector from */
vector from */ int lMem /* (i) Length of buffer */
int lMem /* (i) Length of buffer */ ){
){ int j, k;
int j, k; float *pp, *pp1;
float *pp, *pp1; float tempbuff2[CB_MEML+CB_FILTERLEN];
float tempbuff2[CB_MEML+CB_FILTERLEN]; float *pos;
float *pos;
memset(tempbuff2, 0, (CB_HALFFILTERLEN-1)*sizeof(float));
memset(tempbuff2, 0, (CB_HALFFILTERLEN-1)*sizeof(float)); memcpy(&tempbuff2[CB_HALFFILTERLEN-1], mem, lMem*sizeof(float));
memcpy(&tempbuff2[CB_HALFFILTERLEN-1], mem, lMem*sizeof(float)); memset(&tempbuff2[lMem+CB_HALFFILTERLEN-1], 0,
memset(&tempbuff2[lMem+CB_HALFFILTERLEN-1], 0, (CB_HALFFILTERLEN+1)*sizeof(float));
(CB_HALFFILTERLEN+1)*sizeof(float));
/* Create codebook vector for higher section by filtering */
/* Create codebook vector for higher section by filtering */
/* do filtering */
/* do filtering */ pos=cbvectors;
pos=cbvectors; memset(pos, 0, lMem*sizeof(float));
memset(pos, 0, lMem*sizeof(float)); for (k=0; k<lMem; k++) {
for (k=0; k<lMem; k++) { pp=&tempbuff2[k];
pp=&tempbuff2[k]; pp1=&cbfiltersTbl[CB_FILTERLEN-1];
pp1=&cbfiltersTbl[CB_FILTERLEN-1]; for (j=0;j<CB_FILTERLEN;j++) {
for (j=0;j<CB_FILTERLEN;j++) { (*pos)+=(*pp++)*(*pp1--);
(*pos)+=(*pp++)*(*pp1--); }
} pos++;
pos++; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Search the augmented part of the codebook to find the best
* Search the augmented part of the codebook to find the best * measure.
* measure. *----------------------------------------------------------------*/
*----------------------------------------------------------------*/
void searchAugmentedCB(
void searchAugmentedCB( int low, /* (i) Start index for the search */
int low, /* (i) Start index for the search */ int high, /* (i) End index for the search */
int high, /* (i) End index for the search */ int stage, /* (i) Current stage */
int stage, /* (i) Current stage */ int startIndex, /* (i) Codebook index for the first
int startIndex, /* (i) Codebook index for the first aug vector */
aug vector */ float *target, /* (i) Target vector for encoding */
float *target, /* (i) Target vector for encoding */ float *buffer, /* (i) Pointer to the end of the buffer for
float *buffer, /* (i) Pointer to the end of the buffer for augmented codebook construction */
augmented codebook construction */ float *max_measure, /* (i/o) Currently maximum measure */
float *max_measure, /* (i/o) Currently maximum measure */ int *best_index,/* (o) Currently the best index */
int *best_index,/* (o) Currently the best index */ float *gain, /* (o) Currently the best gain */
float *gain, /* (o) Currently the best gain */ float *energy, /* (o) Energy of augmented codebook
float *energy, /* (o) Energy of augmented codebook vectors */
vectors */ float *invenergy/* (o) Inv energy of augmented codebook
float *invenergy/* (o) Inv energy of augmented codebook vectors */
vectors */ ) {
) { int icount, ilow, j, tmpIndex;
int icount, ilow, j, tmpIndex; float *pp, *ppo, *ppi, *ppe, crossDot, alfa;
float *pp, *ppo, *ppi, *ppe, crossDot, alfa; float weighted, measure, nrjRecursive;
float weighted, measure, nrjRecursive; float ftmp;
float ftmp;
/* Compute the energy for the first (low-5)
/* Compute the energy for the first (low-5) noninterpolated samples */
noninterpolated samples */ nrjRecursive = (float) 0.0;
nrjRecursive = (float) 0.0; pp = buffer - low + 1;
pp = buffer - low + 1; for (j=0; j<(low-5); j++) {
for (j=0; j<(low-5); j++) { nrjRecursive += ( (*pp)*(*pp) );
nrjRecursive += ( (*pp)*(*pp) ); pp++;
pp++; }
} ppe = buffer - low;
ppe = buffer - low;
for (icount=low; icount<=high; icount++) {
for (icount=low; icount<=high; icount++) {
/* Index of the codebook vector used for retrieving
/* Index of the codebook vector used for retrieving energy values */
energy values */ tmpIndex = startIndex+icount-20;
tmpIndex = startIndex+icount-20;
ilow = icount-4;
ilow = icount-4;
/* Update the energy recursively to save complexity */
/* Update the energy recursively to save complexity */ nrjRecursive = nrjRecursive + (*ppe)*(*ppe);
nrjRecursive = nrjRecursive + (*ppe)*(*ppe); ppe--;
ppe--; energy[tmpIndex] = nrjRecursive;
energy[tmpIndex] = nrjRecursive;
/* Compute cross dot product for the first (low-5)
/* Compute cross dot product for the first (low-5) samples */
samples */ crossDot = (float) 0.0;
crossDot = (float) 0.0;
pp = buffer-icount;
pp = buffer-icount; for (j=0; j<ilow; j++) {
for (j=0; j<ilow; j++) { crossDot += target[j]*(*pp++);
crossDot += target[j]*(*pp++); }
}
/* interpolation */
/* interpolation */ alfa = (float) 0.2;
alfa = (float) 0.2; ppo = buffer-4;
ppo = buffer-4; ppi = buffer-icount-4;
ppi = buffer-icount-4; for (j=ilow; j<icount; j++) {
for (j=ilow; j<icount; j++) { weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi); ppo++;
ppo++; ppi++;
ppi++; energy[tmpIndex] += weighted*weighted;
energy[tmpIndex] += weighted*weighted; crossDot += target[j]*weighted;
crossDot += target[j]*weighted; alfa += (float)0.2;
alfa += (float)0.2; }
}
/* Compute energy and cross dot product for the
/* Compute energy and cross dot product for the remaining samples */
remaining samples */ pp = buffer - icount;
pp = buffer - icount; for (j=icount; j<SUBL; j++) {
for (j=icount; j<SUBL; j++) { energy[tmpIndex] += (*pp)*(*pp);
energy[tmpIndex] += (*pp)*(*pp); crossDot += target[j]*(*pp++);
crossDot += target[j]*(*pp++); }
}
if (energy[tmpIndex]>0.0) {
if (energy[tmpIndex]>0.0) { invenergy[tmpIndex]=(float)1.0/(energy[tmpIndex]+EPS);
invenergy[tmpIndex]=(float)1.0/(energy[tmpIndex]+EPS); } else {
} else { invenergy[tmpIndex] = (float) 0.0;
invenergy[tmpIndex] = (float) 0.0; }
}
if (stage==0) {
if (stage==0) { measure = (float)-10000000.0;
measure = (float)-10000000.0;
if (crossDot > 0.0) {
if (crossDot > 0.0) { measure = crossDot*crossDot*invenergy[tmpIndex];
measure = crossDot*crossDot*invenergy[tmpIndex]; }
} }
} else {
else { measure = crossDot*crossDot*invenergy[tmpIndex];
measure = crossDot*crossDot*invenergy[tmpIndex]; }
}
/* check if measure is better */
/* check if measure is better */ ftmp = crossDot*invenergy[tmpIndex];
ftmp = crossDot*invenergy[tmpIndex];
if ((measure>*max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
if ((measure>*max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { *best_index = tmpIndex;
*best_index = tmpIndex; *max_measure = measure;
*max_measure = measure; *gain = ftmp;
*gain = ftmp; }
} }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Recreate a specific codebook vector from the augmented part.
* Recreate a specific codebook vector from the augmented part. *
* *----------------------------------------------------------------*/
*----------------------------------------------------------------*/
void createAugmentedVec(
void createAugmentedVec( int index, /* (i) Index for the augmented vector
int index, /* (i) Index for the augmented vector to be created */
to be created */ float *buffer, /* (i) Pointer to the end of the buffer for
float *buffer, /* (i) Pointer to the end of the buffer for augmented codebook construction */
augmented codebook construction */ float *cbVec/* (o) The construced codebook vector */
float *cbVec/* (o) The construced codebook vector */ ) {
) { int ilow, j;
int ilow, j; float *pp, *ppo, *ppi, alfa, alfa1, weighted;
float *pp, *ppo, *ppi, alfa, alfa1, weighted;
ilow = index-5;
ilow = index-5;
/* copy the first noninterpolated part */
/* copy the first noninterpolated part */
pp = buffer-index;
pp = buffer-index; memcpy(cbVec,pp,sizeof(float)*index);
memcpy(cbVec,pp,sizeof(float)*index);
/* interpolation */
/* interpolation */
alfa1 = (float)0.2;
alfa1 = (float)0.2; alfa = 0.0;
alfa = 0.0; ppo = buffer-5;
ppo = buffer-5; ppi = buffer-index-5;
ppi = buffer-index-5; for (j=ilow; j<index; j++) {
for (j=ilow; j<index; j++) { weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi); ppo++;
ppo++; ppi++;
ppi++; cbVec[j] = weighted;
cbVec[j] = weighted; alfa += alfa1;
alfa += alfa1; }
}
/* copy the second noninterpolated part */
/* copy the second noninterpolated part */
pp = buffer - index;
pp = buffer - index; memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index));
memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index)); }
}

112
libs/codec/ilbc/createCB.h
View File

@ -1,56 +1,56 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
createCB.h createCB.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_CREATECB_H #ifndef __iLBC_CREATECB_H
#define __iLBC_CREATECB_H #define __iLBC_CREATECB_H
void filteredCBvecs( void filteredCBvecs(
float *cbvectors, /* (o) Codebook vector for the float *cbvectors, /* (o) Codebook vector for the
higher section */ higher section */
float *mem, /* (i) Buffer to create codebook float *mem, /* (i) Buffer to create codebook
vectors from */ vectors from */
int lMem /* (i) Length of buffer */ int lMem /* (i) Length of buffer */
); );
void searchAugmentedCB( void searchAugmentedCB(
int low, /* (i) Start index for the search */ int low, /* (i) Start index for the search */
int high, /* (i) End index for the search */ int high, /* (i) End index for the search */
int stage, /* (i) Current stage */ int stage, /* (i) Current stage */
int startIndex, /* (i) CB index for the first int startIndex, /* (i) CB index for the first
augmented vector */ augmented vector */
float *target, /* (i) Target vector for encoding */ float *target, /* (i) Target vector for encoding */
float *buffer, /* (i) Pointer to the end of the float *buffer, /* (i) Pointer to the end of the
buffer for augmented codebook buffer for augmented codebook
construction */ construction */
float *max_measure, /* (i/o) Currently maximum measure */ float *max_measure, /* (i/o) Currently maximum measure */
int *best_index,/* (o) Currently the best index */ int *best_index,/* (o) Currently the best index */
float *gain, /* (o) Currently the best gain */ float *gain, /* (o) Currently the best gain */
float *energy, /* (o) Energy of augmented float *energy, /* (o) Energy of augmented
codebook vectors */ codebook vectors */
float *invenergy/* (o) Inv energy of aug codebook float *invenergy/* (o) Inv energy of aug codebook
vectors */ vectors */
); );
void createAugmentedVec( void createAugmentedVec(
int index, /* (i) Index for the aug vector int index, /* (i) Index for the aug vector
to be created */ to be created */
float *buffer, /* (i) Pointer to the end of the float *buffer, /* (i) Pointer to the end of the
buffer for augmented codebook buffer for augmented codebook
construction */ construction */
float *cbVec /* (o) The construced codebook vector */ float *cbVec /* (o) The construced codebook vector */
); );
#endif #endif

517
libs/codec/ilbc/doCPLC.c
View File

@ -1,259 +1,258 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
doCPLC.c doCPLC.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "doCPLC.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Compute cross correlation and pitch gain for pitch prediction
* Compute cross correlation and pitch gain for pitch prediction * of last subframe at given lag.
* of last subframe at given lag. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void compCorr(
static void compCorr( float *cc, /* (o) cross correlation coefficient */
float *cc, /* (o) cross correlation coefficient */ float *gc, /* (o) gain */
float *gc, /* (o) gain */ float *pm,
float *pm, float *buffer, /* (i) signal buffer */
float *buffer, /* (i) signal buffer */ int lag, /* (i) pitch lag */
int lag, /* (i) pitch lag */ int bLen, /* (i) length of buffer */
int bLen, /* (i) length of buffer */ int sRange /* (i) correlation search length */
int sRange /* (i) correlation search length */ ){
){
int i;
int i; float ftmp1, ftmp2, ftmp3;
float ftmp1, ftmp2, ftmp3;
/* Guard against getting outside buffer */
/* Guard against getting outside buffer */ if ((bLen-sRange-lag)<0) {
if ((bLen-sRange-lag)<0) { sRange=bLen-lag;
sRange=bLen-lag; }
}
ftmp1 = 0.0;
ftmp1 = 0.0; ftmp2 = 0.0;
ftmp2 = 0.0; ftmp3 = 0.0;
ftmp3 = 0.0; for (i=0; i<sRange; i++) {
for (i=0; i<sRange; i++) { ftmp1 += buffer[bLen-sRange+i] *
ftmp1 += buffer[bLen-sRange+i] * buffer[bLen-sRange+i-lag];
buffer[bLen-sRange+i-lag]; ftmp2 += buffer[bLen-sRange+i-lag] *
ftmp2 += buffer[bLen-sRange+i-lag] * buffer[bLen-sRange+i-lag];
buffer[bLen-sRange+i-lag]; ftmp3 += buffer[bLen-sRange+i] *
ftmp3 += buffer[bLen-sRange+i] * buffer[bLen-sRange+i];
buffer[bLen-sRange+i]; }
}
if (ftmp2 > 0.0) {
if (ftmp2 > 0.0) { *cc = ftmp1*ftmp1/ftmp2;
*cc = ftmp1*ftmp1/ftmp2; *gc = (float)fabs(ftmp1/ftmp2);
*gc = (float)fabs(ftmp1/ftmp2); *pm=(float)fabs(ftmp1)/
*pm=(float)fabs(ftmp1)/ ((float)sqrt(ftmp2)*(float)sqrt(ftmp3));
((float)sqrt(ftmp2)*(float)sqrt(ftmp3)); }
} else {
else { *cc = 0.0;
*cc = 0.0; *gc = 0.0;
*gc = 0.0; *pm=0.0;
*pm=0.0; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Packet loss concealment routine. Conceals a residual signal
* Packet loss concealment routine. Conceals a residual signal * and LP parameters. If no packet loss, update state.
* and LP parameters. If no packet loss, update state. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void doThePLC(
void doThePLC( float *PLCresidual, /* (o) concealed residual */
float *PLCresidual, /* (o) concealed residual */ float *PLClpc, /* (o) concealed LP parameters */
float *PLClpc, /* (o) concealed LP parameters */ int PLI, /* (i) packet loss indicator
int PLI, /* (i) packet loss indicator 0 - no PL, 1 = PL */
0 - no PL, 1 = PL */ float *decresidual, /* (i) decoded residual */
float *decresidual, /* (i) decoded residual */ float *lpc, /* (i) decoded LPC (only used for no PL) */
float *lpc, /* (i) decoded LPC (only used for no PL) */ int inlag, /* (i) pitch lag */
int inlag, /* (i) pitch lag */ iLBC_Dec_Inst_t *iLBCdec_inst
iLBC_Dec_Inst_t *iLBCdec_inst /* (i/o) decoder instance */
/* (i/o) decoder instance */ ){
){ int lag=20, randlag;
int lag=20, randlag; float gain, maxcc;
float gain, maxcc; float use_gain;
float use_gain; float gain_comp, maxcc_comp, per, max_per;
float gain_comp, maxcc_comp, per, max_per; int i, pick, use_lag;
int i, pick, use_lag;
float ftmp, randvec[BLOCKL_MAX], pitchfact, energy;
float ftmp, randvec[BLOCKL_MAX], pitchfact, energy;
/* Packet Loss */
/* Packet Loss */
if (PLI == 1) {
if (PLI == 1) {
iLBCdec_inst->consPLICount += 1;
iLBCdec_inst->consPLICount += 1;
/* if previous frame not lost,
/* if previous frame not lost, determine pitch pred. gain */
determine pitch pred. gain */
if (iLBCdec_inst->prevPLI != 1) {
if (iLBCdec_inst->prevPLI != 1) {
/* Search around the previous lag to find the
/* Search around the previous lag to find the best pitch period */
best pitch period */
lag=inlag-3;
lag=inlag-3; compCorr(&maxcc, &gain, &max_per,
compCorr(&maxcc, &gain, &max_per, iLBCdec_inst->prevResidual,
iLBCdec_inst->prevResidual, lag, iLBCdec_inst->blockl, 60);
lag, iLBCdec_inst->blockl, 60); for (i=inlag-2;i<=inlag+3;i++) {
for (i=inlag-2;i<=inlag+3;i++) { compCorr(&maxcc_comp, &gain_comp, &per,
compCorr(&maxcc_comp, &gain_comp, &per, iLBCdec_inst->prevResidual,
iLBCdec_inst->prevResidual, i, iLBCdec_inst->blockl, 60);
i, iLBCdec_inst->blockl, 60);
if (maxcc_comp>maxcc) {
if (maxcc_comp>maxcc) { maxcc=maxcc_comp;
maxcc=maxcc_comp; gain=gain_comp;
gain=gain_comp; lag=i;
lag=i; max_per=per;
max_per=per; }
} }
}
}
}
/* previous frame lost, use recorded lag and periodicity */
/* previous frame lost, use recorded lag and periodicity */
else {
else { lag=iLBCdec_inst->prevLag;
lag=iLBCdec_inst->prevLag; max_per=iLBCdec_inst->per;
max_per=iLBCdec_inst->per; }
}
/* downscaling */
/* downscaling */
use_gain=1.0;
use_gain=1.0; if (iLBCdec_inst->consPLICount*iLBCdec_inst->blockl>320)
if (iLBCdec_inst->consPLICount*iLBCdec_inst->blockl>320) use_gain=(float)0.9;
use_gain=(float)0.9; else if (iLBCdec_inst->consPLICount*
else if (iLBCdec_inst->consPLICount* iLBCdec_inst->blockl>2*320)
iLBCdec_inst->blockl>2*320) use_gain=(float)0.7;
use_gain=(float)0.7; else if (iLBCdec_inst->consPLICount*
else if (iLBCdec_inst->consPLICount* iLBCdec_inst->blockl>3*320)
iLBCdec_inst->blockl>3*320) use_gain=(float)0.5;
use_gain=(float)0.5; else if (iLBCdec_inst->consPLICount*
else if (iLBCdec_inst->consPLICount*
iLBCdec_inst->blockl>4*320)
iLBCdec_inst->blockl>4*320) use_gain=(float)0.0;
use_gain=(float)0.0;
/* mix noise and pitch repeatition */
/* mix noise and pitch repeatition */ ftmp=(float)sqrt(max_per);
ftmp=(float)sqrt(max_per); if (ftmp>(float)0.7)
if (ftmp>(float)0.7) pitchfact=(float)1.0;
pitchfact=(float)1.0; else if (ftmp>(float)0.4)
else if (ftmp>(float)0.4) pitchfact=(ftmp-(float)0.4)/((float)0.7-(float)0.4);
pitchfact=(ftmp-(float)0.4)/((float)0.7-(float)0.4); else
else pitchfact=0.0;
pitchfact=0.0;
/* avoid repetition of same pitch cycle */
/* avoid repetition of same pitch cycle */ use_lag=lag;
use_lag=lag; if (lag<80) {
if (lag<80) { use_lag=2*lag;
use_lag=2*lag; }
}
/* compute concealed residual */
/* compute concealed residual */
energy = 0.0;
energy = 0.0; for (i=0; i<iLBCdec_inst->blockl; i++) {
for (i=0; i<iLBCdec_inst->blockl; i++) {
/* noise component */
/* noise component */
iLBCdec_inst->seed=(iLBCdec_inst->seed*69069L+1) &
iLBCdec_inst->seed=(iLBCdec_inst->seed*69069L+1) & (0x80000000L-1);
(0x80000000L-1); randlag = 50 + ((signed long) iLBCdec_inst->seed)%70;
randlag = 50 + ((signed long) iLBCdec_inst->seed)%70; pick = i - randlag;
pick = i - randlag;
if (pick < 0) {
if (pick < 0) { randvec[i] =
randvec[i] = iLBCdec_inst->prevResidual[
iLBCdec_inst->prevResidual[ iLBCdec_inst->blockl+pick];
iLBCdec_inst->blockl+pick]; } else {
} else { randvec[i] = randvec[pick];
randvec[i] = randvec[pick]; }
}
/* pitch repeatition component */
/* pitch repeatition component */ pick = i - use_lag;
pick = i - use_lag;
if (pick < 0) {
if (pick < 0) { PLCresidual[i] =
PLCresidual[i] = iLBCdec_inst->prevResidual[
iLBCdec_inst->prevResidual[ iLBCdec_inst->blockl+pick];
iLBCdec_inst->blockl+pick]; } else {
} else { PLCresidual[i] = PLCresidual[pick];
PLCresidual[i] = PLCresidual[pick]; }
}
/* mix random and periodicity component */
/* mix random and periodicity component */
if (i<80)
if (i<80) PLCresidual[i] = use_gain*(pitchfact *
PLCresidual[i] = use_gain*(pitchfact *
PLCresidual[i] +
PLCresidual[i] + ((float)1.0 - pitchfact) * randvec[i]);
((float)1.0 - pitchfact) * randvec[i]); else if (i<160)
else if (i<160) PLCresidual[i] = (float)0.95*use_gain*(pitchfact *
PLCresidual[i] = (float)0.95*use_gain*(pitchfact * PLCresidual[i] +
PLCresidual[i] + ((float)1.0 - pitchfact) * randvec[i]);
((float)1.0 - pitchfact) * randvec[i]); else
else PLCresidual[i] = (float)0.9*use_gain*(pitchfact *
PLCresidual[i] = (float)0.9*use_gain*(pitchfact * PLCresidual[i] +
PLCresidual[i] + ((float)1.0 - pitchfact) * randvec[i]);
((float)1.0 - pitchfact) * randvec[i]);
energy += PLCresidual[i] * PLCresidual[i];
energy += PLCresidual[i] * PLCresidual[i]; }
}
/* less than 30 dB, use only noise */
/* less than 30 dB, use only noise */
if (sqrt(energy/(float)iLBCdec_inst->blockl) < 30.0) {
if (sqrt(energy/(float)iLBCdec_inst->blockl) < 30.0) { gain=0.0;
gain=0.0; for (i=0; i<iLBCdec_inst->blockl; i++) {
for (i=0; i<iLBCdec_inst->blockl; i++) { PLCresidual[i] = randvec[i];
PLCresidual[i] = randvec[i]; }
} }
}
/* use old LPC */
/* use old LPC */
memcpy(PLClpc,iLBCdec_inst->prevLpc,
memcpy(PLClpc,iLBCdec_inst->prevLpc, (LPC_FILTERORDER+1)*sizeof(float));
(LPC_FILTERORDER+1)*sizeof(float));
}
}
/* no packet loss, copy input */
/* no packet loss, copy input */
else {
else { memcpy(PLCresidual, decresidual,
memcpy(PLCresidual, decresidual, iLBCdec_inst->blockl*sizeof(float));
iLBCdec_inst->blockl*sizeof(float)); memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float));
memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float)); iLBCdec_inst->consPLICount = 0;
iLBCdec_inst->consPLICount = 0; }
}
/* update state */
/* update state */
if (PLI) {
if (PLI) { iLBCdec_inst->prevLag = lag;
iLBCdec_inst->prevLag = lag; iLBCdec_inst->per=max_per;
iLBCdec_inst->per=max_per; }
}
iLBCdec_inst->prevPLI = PLI;
iLBCdec_inst->prevPLI = PLI; memcpy(iLBCdec_inst->prevLpc, PLClpc,
memcpy(iLBCdec_inst->prevLpc, PLClpc, (LPC_FILTERORDER+1)*sizeof(float));
(LPC_FILTERORDER+1)*sizeof(float)); memcpy(iLBCdec_inst->prevResidual, PLCresidual,
memcpy(iLBCdec_inst->prevResidual, PLCresidual, iLBCdec_inst->blockl*sizeof(float));
iLBCdec_inst->blockl*sizeof(float)); }
}

64
libs/codec/ilbc/doCPLC.h
View File

@ -1,32 +1,32 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
doCPLC.h doCPLC.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_DOLPC_H #ifndef __iLBC_DOLPC_H
#define __iLBC_DOLPC_H #define __iLBC_DOLPC_H
void doThePLC( void doThePLC(
float *PLCresidual, /* (o) concealed residual */ float *PLCresidual, /* (o) concealed residual */
float *PLClpc, /* (o) concealed LP parameters */ float *PLClpc, /* (o) concealed LP parameters */
int PLI, /* (i) packet loss indicator int PLI, /* (i) packet loss indicator
0 - no PL, 1 = PL */ 0 - no PL, 1 = PL */
float *decresidual, /* (i) decoded residual */ float *decresidual, /* (i) decoded residual */
float *lpc, /* (i) decoded LPC (only used for no PL) */ float *lpc, /* (i) decoded LPC (only used for no PL) */
int inlag, /* (i) pitch lag */ int inlag, /* (i) pitch lag */
iLBC_Dec_Inst_t *iLBCdec_inst iLBC_Dec_Inst_t *iLBCdec_inst
/* (i/o) decoder instance */ /* (i/o) decoder instance */
); );
#endif #endif

10191
libs/codec/ilbc/draft-ietf-avt-ilbc-codec-05.txt Normal file
View File

File diff suppressed because it is too large Load Diff

1327
libs/codec/ilbc/enhancer.c
View File

File diff suppressed because it is too large Load Diff

66
libs/codec/ilbc/enhancer.h
View File

@ -1,33 +1,33 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
enhancer.h enhancer.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __ENHANCER_H #ifndef __ENHANCER_H
#define __ENHANCER_H #define __ENHANCER_H
#include "iLBC_define.h" #include "iLBC_define.h"
float xCorrCoef( float xCorrCoef(
float *target, /* (i) first array */ float *target, /* (i) first array */
float *regressor, /* (i) second array */ float *regressor, /* (i) second array */
int subl /* (i) dimension arrays */ int subl /* (i) dimension arrays */
); );
int enhancerInterface( int enhancerInterface(
float *out, /* (o) the enhanced recidual signal */ float *out, /* (o) the enhanced recidual signal */
float *in, /* (i) the recidual signal to enhance */ float *in, /* (i) the recidual signal to enhance */
iLBC_Dec_Inst_t *iLBCdec_inst iLBC_Dec_Inst_t *iLBCdec_inst
/* (i/o) the decoder state structure */ /* (i/o) the decoder state structure */
); );
#endif #endif

17
libs/codec/ilbc/extract-cfile.awk Normal file
View File

@ -0,0 +1,17 @@
BEGIN { srcname = "nothing"; }
{ if (/^A\.[0-9][0-9]* [a-zA-Z][a-zA-Z_0-9]*\.[ch]/) {
if (srcname != "nothing")
close(srcname);
srcname = $2;
printf("creating source file %s\n", srcname);
}else if (srcname != "nothing") {
if (/Andersen et\. al\./ || /Internet Low Bit Rate Codec *May 04/)
printf("skipping %s\n", $0);
else
print $0 >> srcname;
}
}
END {
printf("ending file %s\n", srcname);
close(srcname);
}

335
libs/codec/ilbc/filter.c
View File

@ -1,168 +1,167 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
filter.c filter.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "iLBC_define.h" #include "iLBC_define.h"
#include "filter.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * all-pole filter
* all-pole filter *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void AllPoleFilter(
void AllPoleFilter( float *InOut, /* (i/o) on entrance InOut[-orderCoef] to
float *InOut, /* (i/o) on entrance InOut[-orderCoef] to InOut[-1] contain the state of the
InOut[-1] contain the state of the filter (delayed samples). InOut[0] to
filter (delayed samples). InOut[0] to InOut[lengthInOut-1] contain the filter
InOut[lengthInOut-1] contain the filter input, on en exit InOut[-orderCoef] to
input, on en exit InOut[-orderCoef] to InOut[-1] is unchanged and InOut[0] to
InOut[-1] is unchanged and InOut[0] to InOut[lengthInOut-1] contain filtered
InOut[lengthInOut-1] contain filtered samples */
samples */ float *Coef,/* (i) filter coefficients, Coef[0] is assumed
float *Coef,/* (i) filter coefficients, Coef[0] is assumed to be 1.0 */
to be 1.0 */ int lengthInOut,/* (i) number of input/output samples */
int lengthInOut,/* (i) number of input/output samples */ int orderCoef /* (i) number of filter coefficients */
int orderCoef /* (i) number of filter coefficients */ ){
){ int n,k;
int n,k;
for(n=0;n<lengthInOut;n++){
for(n=0;n<lengthInOut;n++){ for(k=1;k<=orderCoef;k++){
for(k=1;k<=orderCoef;k++){ *InOut -= Coef[k]*InOut[-k];
*InOut -= Coef[k]*InOut[-k]; }
} InOut++;
InOut++; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * all-zero filter
* all-zero filter *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void AllZeroFilter(
void AllZeroFilter( float *In, /* (i) In[0] to In[lengthInOut-1] contain
float *In, /* (i) In[0] to In[lengthInOut-1] contain filter input samples */
filter input samples */ float *Coef,/* (i) filter coefficients (Coef[0] is assumed
float *Coef,/* (i) filter coefficients (Coef[0] is assumed to be 1.0) */
to be 1.0) */ int lengthInOut,/* (i) number of input/output samples */
int lengthInOut,/* (i) number of input/output samples */ int orderCoef, /* (i) number of filter coefficients */
int orderCoef, /* (i) number of filter coefficients */ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1] contain the filter state, on exit Out[0]
contain the filter state, on exit Out[0] to Out[lengthInOut-1] contain filtered
to Out[lengthInOut-1] contain filtered samples */
samples */ ){
){ int n,k;
int n,k;
for(n=0;n<lengthInOut;n++){
for(n=0;n<lengthInOut;n++){ *Out = Coef[0]*In[0];
*Out = Coef[0]*In[0]; for(k=1;k<=orderCoef;k++){
for(k=1;k<=orderCoef;k++){ *Out += Coef[k]*In[-k];
*Out += Coef[k]*In[-k]; }
}
Out++;
Out++; In++;
In++; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * pole-zero filter
* pole-zero filter *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void ZeroPoleFilter(
void ZeroPoleFilter( float *In, /* (i) In[0] to In[lengthInOut-1] contain
float *In, /* (i) In[0] to In[lengthInOut-1] contain filter input samples In[-orderCoef] to
filter input samples In[-orderCoef] to In[-1] contain state of all-zero
In[-1] contain state of all-zero section */
section */ float *ZeroCoef,/* (i) filter coefficients for all-zero
float *ZeroCoef,/* (i) filter coefficients for all-zero section (ZeroCoef[0] is assumed to
section (ZeroCoef[0] is assumed to be 1.0) */
be 1.0) */ float *PoleCoef,/* (i) filter coefficients for all-pole section
float *PoleCoef,/* (i) filter coefficients for all-pole section (ZeroCoef[0] is assumed to be 1.0) */
(ZeroCoef[0] is assumed to be 1.0) */ int lengthInOut,/* (i) number of input/output samples */
int lengthInOut,/* (i) number of input/output samples */ int orderCoef, /* (i) number of filter coefficients */
int orderCoef, /* (i) number of filter coefficients */ float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1] contain state of all-pole section. On
contain state of all-pole section. On exit Out[0] to Out[lengthInOut-1]
exit Out[0] to Out[lengthInOut-1] contain filtered samples */
contain filtered samples */ ){
){ AllZeroFilter(In,ZeroCoef,lengthInOut,orderCoef,Out);
AllZeroFilter(In,ZeroCoef,lengthInOut,orderCoef,Out); AllPoleFilter(Out,PoleCoef,lengthInOut,orderCoef);
AllPoleFilter(Out,PoleCoef,lengthInOut,orderCoef); }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * downsample (LP filter and decimation)
* downsample (LP filter and decimation) *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void DownSample (
void DownSample ( float *In, /* (i) input samples */
float *In, /* (i) input samples */ float *Coef, /* (i) filter coefficients */
float *Coef, /* (i) filter coefficients */ int lengthIn, /* (i) number of input samples */
int lengthIn, /* (i) number of input samples */ float *state, /* (i) filter state */
float *state, /* (i) filter state */ float *Out /* (o) downsampled output */
float *Out /* (o) downsampled output */ ){
){ float o;
float o; float *Out_ptr = Out;
float *Out_ptr = Out; float *Coef_ptr, *In_ptr;
float *Coef_ptr, *In_ptr; float *state_ptr;
float *state_ptr; int i, j, stop;
int i, j, stop;
/* LP filter and decimate at the same time */
/* LP filter and decimate at the same time */
for (i = DELAY_DS; i < lengthIn; i+=FACTOR_DS)
for (i = DELAY_DS; i < lengthIn; i+=FACTOR_DS) {
{ Coef_ptr = &Coef[0];
Coef_ptr = &Coef[0]; In_ptr = &In[i];
In_ptr = &In[i]; state_ptr = &state[FILTERORDER_DS-2];
state_ptr = &state[FILTERORDER_DS-2];
o = (float)0.0;
o = (float)0.0;
stop = (i < FILTERORDER_DS) ? i + 1 : FILTERORDER_DS;
stop = (i < FILTERORDER_DS) ? i + 1 : FILTERORDER_DS;
for (j = 0; j < stop; j++)
for (j = 0; j < stop; j++) {
{ o += *Coef_ptr++ * (*In_ptr--);
o += *Coef_ptr++ * (*In_ptr--); }
} for (j = i + 1; j < FILTERORDER_DS; j++)
for (j = i + 1; j < FILTERORDER_DS; j++) {
{ o += *Coef_ptr++ * (*state_ptr--);
o += *Coef_ptr++ * (*state_ptr--); }
}
*Out_ptr++ = o;
*Out_ptr++ = o; }
}
/* Get the last part (use zeros as input for the future) */
/* Get the last part (use zeros as input for the future) */
for (i=(lengthIn+FACTOR_DS); i<(lengthIn+DELAY_DS);
for (i=(lengthIn+FACTOR_DS); i<(lengthIn+DELAY_DS); i+=FACTOR_DS) {
i+=FACTOR_DS) {
o=(float)0.0;
o=(float)0.0;
if (i<lengthIn) {
if (i<lengthIn) { Coef_ptr = &Coef[0];
Coef_ptr = &Coef[0]; In_ptr = &In[i];
In_ptr = &In[i]; for (j=0; j<FILTERORDER_DS; j++) {
for (j=0; j<FILTERORDER_DS; j++) { o += *Coef_ptr++ * (*Out_ptr--);
o += *Coef_ptr++ * (*Out_ptr--); }
} } else {
} else { Coef_ptr = &Coef[i-lengthIn];
Coef_ptr = &Coef[i-lengthIn]; In_ptr = &In[lengthIn-1];
In_ptr = &In[lengthIn-1]; for (j=0; j<FILTERORDER_DS-(i-lengthIn); j++) {
for (j=0; j<FILTERORDER_DS-(i-lengthIn); j++) { o += *Coef_ptr++ * (*In_ptr--);
o += *Coef_ptr++ * (*In_ptr--); }
} }
} *Out_ptr++ = o;
*Out_ptr++ = o; }
} }
}

146
libs/codec/ilbc/filter.h
View File

@ -1,73 +1,73 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
filter.h filter.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_FILTER_H #ifndef __iLBC_FILTER_H
#define __iLBC_FILTER_H #define __iLBC_FILTER_H
void AllPoleFilter( void AllPoleFilter(
float *InOut, /* (i/o) on entrance InOut[-orderCoef] to float *InOut, /* (i/o) on entrance InOut[-orderCoef] to
InOut[-1] contain the state of the InOut[-1] contain the state of the
filter (delayed samples). InOut[0] to filter (delayed samples). InOut[0] to
InOut[lengthInOut-1] contain the filter InOut[lengthInOut-1] contain the filter
input, on en exit InOut[-orderCoef] to input, on en exit InOut[-orderCoef] to
InOut[-1] is unchanged and InOut[0] to InOut[-1] is unchanged and InOut[0] to
InOut[lengthInOut-1] contain filtered InOut[lengthInOut-1] contain filtered
samples */ samples */
float *Coef,/* (i) filter coefficients, Coef[0] is assumed float *Coef,/* (i) filter coefficients, Coef[0] is assumed
to be 1.0 */ to be 1.0 */
int lengthInOut,/* (i) number of input/output samples */ int lengthInOut,/* (i) number of input/output samples */
int orderCoef /* (i) number of filter coefficients */ int orderCoef /* (i) number of filter coefficients */
); );
void AllZeroFilter( void AllZeroFilter(
float *In, /* (i) In[0] to In[lengthInOut-1] contain float *In, /* (i) In[0] to In[lengthInOut-1] contain
filter input samples */ filter input samples */
float *Coef,/* (i) filter coefficients (Coef[0] is assumed float *Coef,/* (i) filter coefficients (Coef[0] is assumed
to be 1.0) */ to be 1.0) */
int lengthInOut,/* (i) number of input/output samples */ int lengthInOut,/* (i) number of input/output samples */
int orderCoef, /* (i) number of filter coefficients */ int orderCoef, /* (i) number of filter coefficients */
float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1] float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
contain the filter state, on exit Out[0] contain the filter state, on exit Out[0]
to Out[lengthInOut-1] contain filtered to Out[lengthInOut-1] contain filtered
samples */ samples */
); );
void ZeroPoleFilter( void ZeroPoleFilter(
float *In, /* (i) In[0] to In[lengthInOut-1] contain filter float *In, /* (i) In[0] to In[lengthInOut-1] contain filter
input samples In[-orderCoef] to In[-1] input samples In[-orderCoef] to In[-1]
contain state of all-zero section */ contain state of all-zero section */
float *ZeroCoef,/* (i) filter coefficients for all-zero float *ZeroCoef,/* (i) filter coefficients for all-zero
section (ZeroCoef[0] is assumed to section (ZeroCoef[0] is assumed to
be 1.0) */ be 1.0) */
float *PoleCoef,/* (i) filter coefficients for all-pole section float *PoleCoef,/* (i) filter coefficients for all-pole section
(ZeroCoef[0] is assumed to be 1.0) */ (ZeroCoef[0] is assumed to be 1.0) */
int lengthInOut,/* (i) number of input/output samples */ int lengthInOut,/* (i) number of input/output samples */
int orderCoef, /* (i) number of filter coefficients */ int orderCoef, /* (i) number of filter coefficients */
float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1] float *Out /* (i/o) on entrance Out[-orderCoef] to Out[-1]
contain state of all-pole section. On contain state of all-pole section. On
exit Out[0] to Out[lengthInOut-1] exit Out[0] to Out[lengthInOut-1]
contain filtered samples */ contain filtered samples */
); );
void DownSample ( void DownSample (
float *In, /* (i) input samples */ float *In, /* (i) input samples */
float *Coef, /* (i) filter coefficients */ float *Coef, /* (i) filter coefficients */
int lengthIn, /* (i) number of input samples */ int lengthIn, /* (i) number of input samples */
float *state, /* (i) filter state */ float *state, /* (i) filter state */
float *Out /* (o) downsampled output */ float *Out /* (o) downsampled output */
); );
#endif #endif

211
libs/codec/ilbc/gainquant.c
View File

@ -1,107 +1,106 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
gainquant.c gainquant.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#include "constants.h" #include "constants.h"
#include "gainquant.h" #include "filter.h"
#include "filter.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * quantizer for the gain in the gain-shape coding of residual
* quantizer for the gain in the gain-shape coding of residual *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
float gainquant(/* (o) quantized gain value */
float gainquant(/* (o) quantized gain value */ float in, /* (i) gain value */
float in, /* (i) gain value */ float maxIn,/* (i) maximum of gain value */
float maxIn,/* (i) maximum of gain value */ int cblen, /* (i) number of quantization indices */
int cblen, /* (i) number of quantization indices */ int *index /* (o) quantization index */
int *index /* (o) quantization index */ ){
){ int i, tindex;
int i, tindex; float minmeasure,measure, *cb, scale;
float minmeasure,measure, *cb, scale;
/* ensure a lower bound on the scaling factor */
/* ensure a lower bound on the scaling factor */
scale=maxIn;
scale=maxIn;
if (scale<0.1) {
scale=(float)0.1;
}
/* select the quantization table */
if (cblen == 8) {
cb = gain_sq3Tbl;
} else if (cblen == 16) {
cb = gain_sq4Tbl;
} else {
cb = gain_sq5Tbl;
}
/* select the best index in the quantization table */
minmeasure=10000000.0;
tindex=0;
for (i=0; i<cblen; i++) {
measure=(in-scale*cb[i])*(in-scale*cb[i]);
if (measure<minmeasure) {
tindex=i;
minmeasure=measure;
}
}
*index=tindex;
/* return the quantized value */ if (scale<0.1) {
scale=(float)0.1;
}
return scale*cb[tindex]; /* select the quantization table */
}
if (cblen == 8) {
/*----------------------------------------------------------------* cb = gain_sq3Tbl;
* decoder for quantized gains in the gain-shape coding of } else if (cblen == 16) {
* residual cb = gain_sq4Tbl;
*---------------------------------------------------------------*/ } else {
cb = gain_sq5Tbl;
float gaindequant( /* (o) quantized gain value */ }
int index, /* (i) quantization index */
float maxIn,/* (i) maximum of unquantized gain */ /* select the best index in the quantization table */
int cblen /* (i) number of quantization indices */
){ minmeasure=10000000.0;
float scale; tindex=0;
for (i=0; i<cblen; i++) {
/* obtain correct scale factor */ measure=(in-scale*cb[i])*(in-scale*cb[i]);
scale=(float)fabs(maxIn); if (measure<minmeasure) {
tindex=i;
if (scale<0.1) { minmeasure=measure;
scale=(float)0.1; }
} }
*index=tindex;
/* select the quantization table and return the decoded value */
/* return the quantized value */
if (cblen==8) {
return scale*gain_sq3Tbl[index];
} else if (cblen==16) {
return scale*gain_sq4Tbl[index]; return scale*cb[tindex];
} }
else if (cblen==32) {
return scale*gain_sq5Tbl[index]; /*----------------------------------------------------------------*
} * decoder for quantized gains in the gain-shape coding of
* residual
return 0.0; *---------------------------------------------------------------*/
}
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;
}

62
libs/codec/ilbc/gainquant.h
View File

@ -1,31 +1,31 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
gainquant.h gainquant.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_GAINQUANT_H #ifndef __iLBC_GAINQUANT_H
#define __iLBC_GAINQUANT_H #define __iLBC_GAINQUANT_H
float gainquant(/* (o) quantized gain value */ float gainquant(/* (o) quantized gain value */
float in, /* (i) gain value */ float in, /* (i) gain value */
float maxIn,/* (i) maximum of gain value */ float maxIn,/* (i) maximum of gain value */
int cblen, /* (i) number of quantization indices */ int cblen, /* (i) number of quantization indices */
int *index /* (o) quantization index */ int *index /* (o) quantization index */
); );
float gaindequant( /* (o) quantized gain value */ float gaindequant( /* (o) quantized gain value */
int index, /* (i) quantization index */ int index, /* (i) quantization index */
float maxIn,/* (i) maximum of unquantized gain */ float maxIn,/* (i) maximum of unquantized gain */
int cblen /* (i) number of quantization indices */ int cblen /* (i) number of quantization indices */
); );
#endif #endif

361
libs/codec/ilbc/getCBvec.c
View File

@ -1,181 +1,180 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
getCBvec.c getCBvec.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "iLBC_define.h" #include "iLBC_define.h"
#include "getCBvec.h" #include "constants.h"
#include "constants.h" #include <string.h>
#include <string.h>
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Construct codebook vector for given index.
* Construct codebook vector for given index. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void getCBvec(
void getCBvec( float *cbvec, /* (o) Constructed codebook vector */
float *cbvec, /* (o) Constructed codebook vector */ float *mem, /* (i) Codebook buffer */
float *mem, /* (i) Codebook buffer */ int index, /* (i) Codebook index */
int index, /* (i) Codebook index */ int lMem, /* (i) Length of codebook buffer */
int lMem, /* (i) Length of codebook buffer */ int cbveclen/* (i) Codebook vector length */
int cbveclen/* (i) Codebook vector length */ ){
){ int j, k, n, memInd, sFilt;
int j, k, n, memInd, sFilt; float tmpbuf[CB_MEML];
float tmpbuf[CB_MEML]; int base_size;
int base_size; int ilow, ihigh;
int ilow, ihigh; float alfa, alfa1;
float alfa, alfa1;
/* Determine size of codebook sections */
/* Determine size of codebook sections */
base_size=lMem-cbveclen+1;
base_size=lMem-cbveclen+1;
if (cbveclen==SUBL) {
if (cbveclen==SUBL) { base_size+=cbveclen/2;
base_size+=cbveclen/2; }
}
/* No filter -> First codebook section */
/* No filter -> First codebook section */
if (index<lMem-cbveclen+1) {
if (index<lMem-cbveclen+1) {
/* first non-interpolated vectors */
/* first non-interpolated vectors */
k=index+cbveclen;
k=index+cbveclen; /* get vector */
/* get vector */ memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
} else if (index < base_size) {
} else if (index < base_size) {
k=2*(index-(lMem-cbveclen+1))+cbveclen;
k=2*(index-(lMem-cbveclen+1))+cbveclen;
ihigh=k/2;
ihigh=k/2; ilow=ihigh-5;
ilow=ihigh-5;
/* Copy first noninterpolated part */
/* Copy first noninterpolated part */
memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
/* interpolation */
/* interpolation */
alfa1=(float)0.2;
alfa1=(float)0.2; alfa=0.0;
alfa=0.0; for (j=ilow; j<ihigh; j++) {
for (j=ilow; j<ihigh; j++) { cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+
cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+ alfa*mem[lMem-k+j];
alfa*mem[lMem-k+j]; alfa+=alfa1;
alfa+=alfa1; }
}
/* Copy second noninterpolated part */
/* Copy second noninterpolated part */
memcpy(cbvec+ihigh, mem+lMem-k+ihigh,
memcpy(cbvec+ihigh, mem+lMem-k+ihigh, (cbveclen-ihigh)*sizeof(float));
(cbveclen-ihigh)*sizeof(float));
}
}
/* Higher codebbok section based on filtering */
/* Higher codebbok section based on filtering */
else {
else {
/* first non-interpolated vectors */
/* first non-interpolated vectors */
if (index-base_size<lMem-cbveclen+1) {
if (index-base_size<lMem-cbveclen+1) { float tempbuff2[CB_MEML+CB_FILTERLEN+1];
float tempbuff2[CB_MEML+CB_FILTERLEN+1]; float *pos;
float *pos; float *pp, *pp1;
float *pp, *pp1;
memset(tempbuff2, 0,
memset(tempbuff2, 0, CB_HALFFILTERLEN*sizeof(float));
CB_HALFFILTERLEN*sizeof(float)); memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
memcpy(&tempbuff2[CB_HALFFILTERLEN], mem, lMem*sizeof(float));
lMem*sizeof(float)); memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0, (CB_HALFFILTERLEN+1)*sizeof(float));
(CB_HALFFILTERLEN+1)*sizeof(float));
k=index-base_size+cbveclen;
k=index-base_size+cbveclen; sFilt=lMem-k;
sFilt=lMem-k; memInd=sFilt+1-CB_HALFFILTERLEN;
memInd=sFilt+1-CB_HALFFILTERLEN;
/* do filtering */
/* do filtering */ pos=cbvec;
pos=cbvec; memset(pos, 0, cbveclen*sizeof(float));
memset(pos, 0, cbveclen*sizeof(float)); for (n=0; n<cbveclen; n++) {
for (n=0; n<cbveclen; n++) { pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];
pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN]; pp1=&cbfiltersTbl[CB_FILTERLEN-1];
pp1=&cbfiltersTbl[CB_FILTERLEN-1]; for (j=0; j<CB_FILTERLEN; j++) {
for (j=0; j<CB_FILTERLEN; j++) { (*pos)+=(*pp++)*(*pp1--);
(*pos)+=(*pp++)*(*pp1--); }
} pos++;
pos++; }
} }
}
/* interpolated vectors */
/* interpolated vectors */
else {
else { float tempbuff2[CB_MEML+CB_FILTERLEN+1];
float tempbuff2[CB_MEML+CB_FILTERLEN+1];
float *pos;
float *pos; float *pp, *pp1;
float *pp, *pp1; int i;
int i;
memset(tempbuff2, 0,
memset(tempbuff2, 0, CB_HALFFILTERLEN*sizeof(float));
CB_HALFFILTERLEN*sizeof(float)); memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
memcpy(&tempbuff2[CB_HALFFILTERLEN], mem, lMem*sizeof(float));
lMem*sizeof(float)); memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0, (CB_HALFFILTERLEN+1)*sizeof(float));
(CB_HALFFILTERLEN+1)*sizeof(float));
k=2*(index-base_size-
k=2*(index-base_size- (lMem-cbveclen+1))+cbveclen;
(lMem-cbveclen+1))+cbveclen; sFilt=lMem-k;
sFilt=lMem-k; memInd=sFilt+1-CB_HALFFILTERLEN;
memInd=sFilt+1-CB_HALFFILTERLEN;
/* do filtering */
/* do filtering */ pos=&tmpbuf[sFilt];
pos=&tmpbuf[sFilt]; memset(pos, 0, k*sizeof(float));
memset(pos, 0, k*sizeof(float)); for (i=0; i<k; i++) {
for (i=0; i<k; i++) { pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];
pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN]; pp1=&cbfiltersTbl[CB_FILTERLEN-1];
pp1=&cbfiltersTbl[CB_FILTERLEN-1]; for (j=0; j<CB_FILTERLEN; j++) {
for (j=0; j<CB_FILTERLEN; j++) { (*pos)+=(*pp++)*(*pp1--);
(*pos)+=(*pp++)*(*pp1--); }
} pos++;
pos++; }
}
ihigh=k/2;
ihigh=k/2; ilow=ihigh-5;
ilow=ihigh-5;
/* Copy first noninterpolated part */
/* Copy first noninterpolated part */
memcpy(cbvec, tmpbuf+lMem-k/2,
memcpy(cbvec, tmpbuf+lMem-k/2, ilow*sizeof(float));
ilow*sizeof(float));
/* interpolation */
/* interpolation */
alfa1=(float)0.2;
alfa1=(float)0.2; alfa=0.0;
alfa=0.0; for (j=ilow; j<ihigh; j++) {
for (j=ilow; j<ihigh; j++) { cbvec[j]=((float)1.0-alfa)*
cbvec[j]=((float)1.0-alfa)* tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];
tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j]; alfa+=alfa1;
alfa+=alfa1; }
}
/* Copy second noninterpolated part */
/* Copy second noninterpolated part */
memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,
memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh, (cbveclen-ihigh)*sizeof(float));
(cbveclen-ihigh)*sizeof(float)); }
} }
} }
}

56
libs/codec/ilbc/getCBvec.h
View File

@ -1,28 +1,28 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
getCBvec.h getCBvec.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_GETCBVEC_H #ifndef __iLBC_GETCBVEC_H
#define __iLBC_GETCBVEC_H #define __iLBC_GETCBVEC_H
void getCBvec( void getCBvec(
float *cbvec, /* (o) Constructed codebook vector */ float *cbvec, /* (o) Constructed codebook vector */
float *mem, /* (i) Codebook buffer */ float *mem, /* (i) Codebook buffer */
int index, /* (i) Codebook index */ int index, /* (i) Codebook index */
int lMem, /* (i) Length of codebook buffer */ int lMem, /* (i) Length of codebook buffer */
int cbveclen/* (i) Codebook vector length */ int cbveclen/* (i) Codebook vector length */
); );
#endif #endif

615
libs/codec/ilbc/helpfun.c
View File

@ -1,308 +1,307 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
helpfun.c helpfun.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "helpfun.h" #include "constants.h"
#include "constants.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * calculation of auto correlation
* calculation of auto correlation *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void autocorr(
void autocorr( float *r, /* (o) autocorrelation vector */
float *r, /* (o) autocorrelation vector */ const float *x, /* (i) data vector */
const float *x, /* (i) data vector */ int N, /* (i) length of data vector */
int N, /* (i) length of data vector */ int order /* largest lag for calculated
int order /* largest lag for calculated autocorrelations */
autocorrelations */ ){
){ int lag, n;
int lag, n; float sum;
float sum;
for (lag = 0; lag <= order; lag++) {
for (lag = 0; lag <= order; lag++) { sum = 0;
sum = 0; for (n = 0; n < N - lag; n++) {
for (n = 0; n < N - lag; n++) { sum += x[n] * x[n+lag];
sum += x[n] * x[n+lag]; }
} r[lag] = sum;
r[lag] = sum; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * window multiplication
* window multiplication *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void window(
void window( float *z, /* (o) the windowed data */
float *z, /* (o) the windowed data */ const float *x, /* (i) the original data vector */
const float *x, /* (i) the original data vector */ const float *y, /* (i) the window */
const float *y, /* (i) the window */ int N /* (i) length of all vectors */
int N /* (i) length of all vectors */ ){
){ int i;
int i;
for (i = 0; i < N; i++) {
for (i = 0; i < N; i++) { z[i] = x[i] * y[i];
z[i] = x[i] * y[i]; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * levinson-durbin solution for lpc coefficients
* levinson-durbin solution for lpc coefficients *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void levdurb(
void levdurb( float *a, /* (o) lpc coefficient vector starting
float *a, /* (o) lpc coefficient vector starting with 1.0 */
with 1.0 */ float *k, /* (o) reflection coefficients */
float *k, /* (o) reflection coefficients */ float *r, /* (i) autocorrelation vector */
float *r, /* (i) autocorrelation vector */ int order /* (i) order of lpc filter */
int order /* (i) order of lpc filter */ ){
){ float sum, alpha;
float sum, alpha; int m, m_h, i;
int m, m_h, i;
a[0] = 1.0;
a[0] = 1.0;
if (r[0] < EPS) { /* if r[0] <= 0, set LPC coeff. to zero */
if (r[0] < EPS) { /* if r[0] <= 0, set LPC coeff. to zero */ for (i = 0; i < order; i++) {
for (i = 0; i < order; i++) { k[i] = 0;
k[i] = 0; a[i+1] = 0;
a[i+1] = 0; }
} } else {
} else { a[1] = k[0] = -r[1]/r[0];
a[1] = k[0] = -r[1]/r[0]; alpha = r[0] + r[1] * k[0];
alpha = r[0] + r[1] * k[0]; for (m = 1; m < order; m++){
for (m = 1; m < order; m++){ sum = r[m + 1];
sum = r[m + 1]; for (i = 0; i < m; i++){
for (i = 0; i < m; i++){ sum += a[i+1] * r[m - i];
sum += a[i+1] * r[m - i]; }
} k[m] = -sum / alpha;
k[m] = -sum / alpha; alpha += k[m] * sum;
alpha += k[m] * sum; m_h = (m + 1) >> 1;
m_h = (m + 1) >> 1; for (i = 0; i < m_h; i++){
for (i = 0; i < m_h; i++){ sum = a[i+1] + k[m] * a[m - i];
sum = a[i+1] + k[m] * a[m - i]; a[m - i] += k[m] * a[i+1];
a[m - i] += k[m] * a[i+1]; a[i+1] = sum;
a[i+1] = sum;
}
} a[m+1] = k[m];
a[m+1] = k[m]; }
} }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * interpolation between vectors
* interpolation between vectors *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void interpolate(
void interpolate( float *out, /* (o) the interpolated vector */
float *out, /* (o) the interpolated vector */ float *in1, /* (i) the first vector for the
float *in1, /* (i) the first vector for the interpolation */
interpolation */ float *in2, /* (i) the second vector for the
float *in2, /* (i) the second vector for the interpolation */
interpolation */ float coef, /* (i) interpolation weights */
float coef, /* (i) interpolation weights */ int length /* (i) length of all vectors */
int length /* (i) length of all vectors */ ){
){ int i;
int i; float invcoef;
float invcoef;
invcoef = (float)1.0 - coef;
invcoef = (float)1.0 - coef; for (i = 0; i < length; i++) {
for (i = 0; i < length; i++) { out[i] = coef * in1[i] + invcoef * in2[i];
out[i] = coef * in1[i] + invcoef * in2[i]; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * lpc bandwidth expansion
* lpc bandwidth expansion *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void bwexpand(
void bwexpand( float *out, /* (o) the bandwidth expanded lpc
float *out, /* (o) the bandwidth expanded lpc coefficients */
coefficients */ float *in, /* (i) the lpc coefficients before bandwidth
float *in, /* (i) the lpc coefficients before bandwidth expansion */
expansion */ float coef, /* (i) the bandwidth expansion factor */
float coef, /* (i) the bandwidth expansion factor */ int length /* (i) the length of lpc coefficient vectors */
int length /* (i) the length of lpc coefficient vectors */ ){
){ int i;
int i; float chirp;
float chirp;
chirp = coef;
chirp = coef;
out[0] = in[0];
out[0] = in[0]; for (i = 1; i < length; i++) {
for (i = 1; i < length; i++) { out[i] = chirp * in[i];
out[i] = chirp * in[i]; chirp *= coef;
chirp *= coef; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * vector quantization
* vector quantization
*---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void vq(
void vq( float *Xq, /* (o) the quantized vector */
float *Xq, /* (o) the quantized vector */ int *index, /* (o) the quantization index */
int *index, /* (o) the quantization index */ const float *CB,/* (i) the vector quantization codebook */
const float *CB,/* (i) the vector quantization codebook */ float *X, /* (i) the vector to quantize */
float *X, /* (i) the vector to quantize */ int n_cb, /* (i) the number of vectors in the codebook */
int n_cb, /* (i) the number of vectors in the codebook */ int dim /* (i) the dimension of all vectors */
int dim /* (i) the dimension of all vectors */ ){
){ int i, j;
int i, j; int pos, minindex;
int pos, minindex; float dist, tmp, mindist;
float dist, tmp, mindist;
pos = 0;
pos = 0; mindist = FLOAT_MAX;
mindist = FLOAT_MAX; minindex = 0;
minindex = 0; for (j = 0; j < n_cb; j++) {
for (j = 0; j < n_cb; j++) { dist = X[0] - CB[pos];
dist = X[0] - CB[pos]; dist *= dist;
dist *= dist; for (i = 1; i < dim; i++) {
for (i = 1; i < dim; i++) { tmp = X[i] - CB[pos + i];
tmp = X[i] - CB[pos + i]; dist += tmp*tmp;
dist += tmp*tmp; }
}
if (dist < mindist) {
if (dist < mindist) { mindist = dist;
mindist = dist; minindex = j;
minindex = j; }
} pos += dim;
pos += dim; }
} for (i = 0; i < dim; i++) {
for (i = 0; i < dim; i++) { Xq[i] = CB[minindex*dim + i];
Xq[i] = CB[minindex*dim + i]; }
} *index = minindex;
*index = minindex; }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * split vector quantization
* split vector quantization *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void SplitVQ(
void SplitVQ( float *qX, /* (o) the quantized vector */
float *qX, /* (o) the quantized vector */ int *index, /* (o) a vector of indexes for all vector
int *index, /* (o) a vector of indexes for all vector codebooks in the split */
codebooks in the split */ float *X, /* (i) the vector to quantize */
float *X, /* (i) the vector to quantize */ const float *CB,/* (i) the quantizer codebook */
const float *CB,/* (i) the quantizer codebook */ int nsplit, /* the number of vector splits */
int nsplit, /* the number of vector splits */ const int *dim, /* the dimension of X and qX */
const int *dim, /* the dimension of X and qX */ const int *cbsize /* the number of vectors in the codebook */
const int *cbsize /* the number of vectors in the codebook */ ){
){ int cb_pos, X_pos, i;
int cb_pos, X_pos, i;
cb_pos = 0;
cb_pos = 0;
X_pos= 0;
X_pos= 0; for (i = 0; i < nsplit; i++) {
for (i = 0; i < nsplit; i++) { vq(qX + X_pos, index + i, CB + cb_pos, X + X_pos,
vq(qX + X_pos, index + i, CB + cb_pos, X + X_pos, cbsize[i], dim[i]);
cbsize[i], dim[i]); X_pos += dim[i];
X_pos += dim[i]; cb_pos += dim[i] * cbsize[i];
cb_pos += dim[i] * cbsize[i]; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * scalar quantization
* scalar quantization *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void sort_sq(
void sort_sq( float *xq, /* (o) the quantized value */
float *xq, /* (o) the quantized value */ int *index, /* (o) the quantization index */
int *index, /* (o) the quantization index */ float x, /* (i) the value to quantize */
float x, /* (i) the value to quantize */ const float *cb,/* (i) the quantization codebook */
const float *cb,/* (i) the quantization codebook */ int cb_size /* (i) the size of the quantization codebook */
int cb_size /* (i) the size of the quantization codebook */ ){
){ int i;
int i;
if (x <= cb[0]) {
if (x <= cb[0]) { *index = 0;
*index = 0; *xq = cb[0];
*xq = cb[0]; } else {
} else { i = 0;
i = 0; while ((x > cb[i]) && i < cb_size - 1) {
while ((x > cb[i]) && i < cb_size - 1) { i++;
i++; }
}
if (x > ((cb[i] + cb[i - 1])/2)) {
if (x > ((cb[i] + cb[i - 1])/2)) { *index = i;
*index = i; *xq = cb[i];
*xq = cb[i]; } else {
} else { *index = i - 1;
*index = i - 1; *xq = cb[i - 1];
*xq = cb[i - 1]; }
} }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * check for stability of lsf coefficients
* check for stability of lsf coefficients *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
int LSF_check( /* (o) 1 for stable lsf vectors and 0 for
int LSF_check( /* (o) 1 for stable lsf vectors and 0 for nonstable ones */
nonstable ones */ float *lsf, /* (i) a table of lsf vectors */
float *lsf, /* (i) a table of lsf vectors */ int dim, /* (i) the dimension of each lsf vector */
int dim, /* (i) the dimension of each lsf vector */ int NoAn /* (i) the number of lsf vectors in the
int NoAn /* (i) the number of lsf vectors in the table */
table */ ){
){ int k,n,m, Nit=2, change=0,pos;
int k,n,m, Nit=2, change=0,pos; float tmp;
float tmp;
static float eps=(float)0.039; /* 50 Hz */
static float eps=(float)0.039; /* 50 Hz */ static float eps2=(float)0.0195;
static float eps2=(float)0.0195; static float maxlsf=(float)3.14; /* 4000 Hz */
static float maxlsf=(float)3.14; /* 4000 Hz */ static float minlsf=(float)0.01; /* 0 Hz */
static float minlsf=(float)0.01; /* 0 Hz */
/* LSF separation check*/
/* LSF separation check*/
for (n=0; n<Nit; n++) { /* Run through a couple of times */
for (n=0; n<Nit; n++) { /* Run through a couple of times */ for (m=0; m<NoAn; m++) { /* Number of analyses per frame */
for (m=0; m<NoAn; m++) { /* Number of analyses per frame */ for (k=0; k<(dim-1); k++) {
for (k=0; k<(dim-1); k++) { pos=m*dim+k;
pos=m*dim+k;
if ((lsf[pos+1]-lsf[pos])<eps) {
if ((lsf[pos+1]-lsf[pos])<eps) {
if (lsf[pos+1]<lsf[pos]) {
if (lsf[pos+1]<lsf[pos]) { tmp=lsf[pos+1];
tmp=lsf[pos+1]; lsf[pos+1]= lsf[pos]+eps2;
lsf[pos+1]= lsf[pos]+eps2; lsf[pos]= lsf[pos+1]-eps2;
lsf[pos]= lsf[pos+1]-eps2; } else {
} else { lsf[pos]-=eps2;
lsf[pos]-=eps2; lsf[pos+1]+=eps2;
lsf[pos+1]+=eps2; }
} change=1;
change=1; }
}
if (lsf[pos]<minlsf) {
if (lsf[pos]<minlsf) { lsf[pos]=minlsf;
lsf[pos]=minlsf; change=1;
change=1; }
}
if (lsf[pos]>maxlsf) {
if (lsf[pos]>maxlsf) { lsf[pos]=maxlsf;
lsf[pos]=maxlsf; change=1;
change=1; }
} }
} }
} }
}
return change;
return change; }
}

202
libs/codec/ilbc/helpfun.h
View File

@ -1,101 +1,101 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
helpfun.h helpfun.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_HELPFUN_H #ifndef __iLBC_HELPFUN_H
#define __iLBC_HELPFUN_H #define __iLBC_HELPFUN_H
void autocorr( void autocorr(
float *r, /* (o) autocorrelation vector */ float *r, /* (o) autocorrelation vector */
const float *x, /* (i) data vector */ const float *x, /* (i) data vector */
int N, /* (i) length of data vector */ int N, /* (i) length of data vector */
int order /* largest lag for calculated int order /* largest lag for calculated
autocorrelations */ autocorrelations */
); );
void window( void window(
float *z, /* (o) the windowed data */ float *z, /* (o) the windowed data */
const float *x, /* (i) the original data vector */ const float *x, /* (i) the original data vector */
const float *y, /* (i) the window */ const float *y, /* (i) the window */
int N /* (i) length of all vectors */ int N /* (i) length of all vectors */
); );
void levdurb( void levdurb(
float *a, /* (o) lpc coefficient vector starting float *a, /* (o) lpc coefficient vector starting
with 1.0 */ with 1.0 */
float *k, /* (o) reflection coefficients */ float *k, /* (o) reflection coefficients */
float *r, /* (i) autocorrelation vector */ float *r, /* (i) autocorrelation vector */
int order /* (i) order of lpc filter */ int order /* (i) order of lpc filter */
); );
void interpolate( void interpolate(
float *out, /* (o) the interpolated vector */ float *out, /* (o) the interpolated vector */
float *in1, /* (i) the first vector for the float *in1, /* (i) the first vector for the
interpolation */ interpolation */
float *in2, /* (i) the second vector for the float *in2, /* (i) the second vector for the
interpolation */ interpolation */
float coef, /* (i) interpolation weights */ float coef, /* (i) interpolation weights */
int length /* (i) length of all vectors */ int length /* (i) length of all vectors */
); );
void bwexpand( void bwexpand(
float *out, /* (o) the bandwidth expanded lpc float *out, /* (o) the bandwidth expanded lpc
coefficients */ coefficients */
float *in, /* (i) the lpc coefficients before bandwidth float *in, /* (i) the lpc coefficients before bandwidth
expansion */ expansion */
float coef, /* (i) the bandwidth expansion factor */ float coef, /* (i) the bandwidth expansion factor */
int length /* (i) the length of lpc coefficient vectors */ int length /* (i) the length of lpc coefficient vectors */
); );
void vq( void vq(
float *Xq, /* (o) the quantized vector */ float *Xq, /* (o) the quantized vector */
int *index, /* (o) the quantization index */ int *index, /* (o) the quantization index */
const float *CB,/* (i) the vector quantization codebook */ const float *CB,/* (i) the vector quantization codebook */
float *X, /* (i) the vector to quantize */ float *X, /* (i) the vector to quantize */
int n_cb, /* (i) the number of vectors in the codebook */ int n_cb, /* (i) the number of vectors in the codebook */
int dim /* (i) the dimension of all vectors */ int dim /* (i) the dimension of all vectors */
); );
void SplitVQ( void SplitVQ(
float *qX, /* (o) the quantized vector */ float *qX, /* (o) the quantized vector */
int *index, /* (o) a vector of indexes for all vector int *index, /* (o) a vector of indexes for all vector
codebooks in the split */ codebooks in the split */
float *X, /* (i) the vector to quantize */ float *X, /* (i) the vector to quantize */
const float *CB,/* (i) the quantizer codebook */ const float *CB,/* (i) the quantizer codebook */
int nsplit, /* the number of vector splits */ int nsplit, /* the number of vector splits */
const int *dim, /* the dimension of X and qX */ const int *dim, /* the dimension of X and qX */
const int *cbsize /* the number of vectors in the codebook */ const int *cbsize /* the number of vectors in the codebook */
); );
void sort_sq( void sort_sq(
float *xq, /* (o) the quantized value */ float *xq, /* (o) the quantized value */
int *index, /* (o) the quantization index */ int *index, /* (o) the quantization index */
float x, /* (i) the value to quantize */ float x, /* (i) the value to quantize */
const float *cb,/* (i) the quantization codebook */ const float *cb,/* (i) the quantization codebook */
int cb_size /* (i) the size of 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 int LSF_check( /* (o) 1 for stable lsf vectors and 0 for
nonstable ones */ nonstable ones */
float *lsf, /* (i) a table of lsf vectors */ float *lsf, /* (i) a table of lsf vectors */
int dim, /* (i) the dimension of each lsf vector */ int dim, /* (i) the dimension of each lsf vector */
int NoAn /* (i) the number of lsf vectors in the int NoAn /* (i) the number of lsf vectors in the
table */ table */
); );
#endif #endif

119
libs/codec/ilbc/hpInput.c
View File

@ -1,60 +1,59 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
hpInput.c hpInput.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "constants.h" #include "constants.h"
#include "hpInput.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Input high-pass filter
* Input high-pass filter *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void hpInput(
void hpInput( float *In, /* (i) vector to filter */
float *In, /* (i) vector to filter */ int len, /* (i) length of vector to filter */
int len, /* (i) length of vector to filter */ float *Out, /* (o) the resulting filtered vector */
float *Out, /* (o) the resulting filtered vector */ float *mem /* (i/o) the filter state */
float *mem /* (i/o) the filter state */ ){
){ int i;
int i; float *pi, *po;
float *pi, *po;
/* all-zero section*/
/* all-zero section*/
pi = &In[0];
pi = &In[0]; po = &Out[0];
po = &Out[0]; for (i=0; i<len; i++) {
for (i=0; i<len; i++) { *po = hpi_zero_coefsTbl[0] * (*pi);
*po = hpi_zero_coefsTbl[0] * (*pi); *po += hpi_zero_coefsTbl[1] * mem[0];
*po += hpi_zero_coefsTbl[1] * mem[0]; *po += hpi_zero_coefsTbl[2] * mem[1];
*po += hpi_zero_coefsTbl[2] * mem[1];
mem[1] = mem[0];
mem[1] = mem[0]; mem[0] = *pi;
mem[0] = *pi; po++;
po++;
pi++;
pi++;
}
}
/* all-pole section*/
/* all-pole section*/
po = &Out[0];
po = &Out[0]; for (i=0; i<len; i++) {
for (i=0; i<len; i++) { *po -= hpi_pole_coefsTbl[1] * mem[2];
*po -= hpi_pole_coefsTbl[1] * mem[2]; *po -= hpi_pole_coefsTbl[2] * mem[3];
*po -= hpi_pole_coefsTbl[2] * mem[3];
mem[3] = mem[2];
mem[3] = mem[2]; mem[2] = *po;
mem[2] = *po; po++;
po++; }
} }
}

54
libs/codec/ilbc/hpInput.h
View File

@ -1,27 +1,27 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
hpInput.h hpInput.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_HPINPUT_H #ifndef __iLBC_HPINPUT_H
#define __iLBC_HPINPUT_H #define __iLBC_HPINPUT_H
void hpInput( void hpInput(
float *In, /* (i) vector to filter */ float *In, /* (i) vector to filter */
int len, /* (i) length of vector to filter */ int len, /* (i) length of vector to filter */
float *Out, /* (o) the resulting filtered vector */ float *Out, /* (o) the resulting filtered vector */
float *mem /* (i/o) the filter state */ float *mem /* (i/o) the filter state */
); );
#endif #endif

118
libs/codec/ilbc/hpOutput.c
View File

@ -1,59 +1,59 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
hpOutput.c hpOutput.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "constants.h" #include "constants.h"
#include "hpOutput.h"
/*----------------------------------------------------------------* /*----------------------------------------------------------------*
* Output high-pass filter * Output high-pass filter
*---------------------------------------------------------------*/ *---------------------------------------------------------------*/
void hpOutput( void hpOutput(
float *In, /* (i) vector to filter */ float *In, /* (i) vector to filter */
int len,/* (i) length of vector to filter */ int len,/* (i) length of vector to filter */
float *Out, /* (o) the resulting filtered vector */ float *Out, /* (o) the resulting filtered vector */
float *mem /* (i/o) the filter state */ float *mem /* (i/o) the filter state */
){ ){
int i; int i;
float *pi, *po; float *pi, *po;
/* all-zero section*/ /* all-zero section*/
pi = &In[0]; pi = &In[0];
po = &Out[0]; po = &Out[0];
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
*po = hpo_zero_coefsTbl[0] * (*pi); *po = hpo_zero_coefsTbl[0] * (*pi);
*po += hpo_zero_coefsTbl[1] * mem[0]; *po += hpo_zero_coefsTbl[1] * mem[0];
*po += hpo_zero_coefsTbl[2] * mem[1]; *po += hpo_zero_coefsTbl[2] * mem[1];
mem[1] = mem[0]; mem[1] = mem[0];
mem[0] = *pi; mem[0] = *pi;
po++; po++;
pi++; pi++;
} }
/* all-pole section*/ /* all-pole section*/
po = &Out[0]; po = &Out[0];
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
*po -= hpo_pole_coefsTbl[1] * mem[2]; *po -= hpo_pole_coefsTbl[1] * mem[2];
*po -= hpo_pole_coefsTbl[2] * mem[3]; *po -= hpo_pole_coefsTbl[2] * mem[3];
mem[3] = mem[2]; mem[3] = mem[2];
mem[2] = *po; mem[2] = *po;
po++; po++;
} }
} }

50
libs/codec/ilbc/hpOutput.h
View File

@ -1,25 +1,25 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
hpOutput.h hpOutput.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_HPOUTPUT_H #ifndef __iLBC_HPOUTPUT_H
#define __iLBC_HPOUTPUT_H #define __iLBC_HPOUTPUT_H
void hpOutput( void hpOutput(
float *In, /* (i) vector to filter */ float *In, /* (i) vector to filter */
int len,/* (i) length of vector to filter */ int len,/* (i) length of vector to filter */
float *Out, /* (o) the resulting filtered vector */ float *Out, /* (o) the resulting filtered vector */
float *mem /* (i/o) the filter state */ float *mem /* (i/o) the filter state */
); );
#endif #endif

215
libs/codec/ilbc/iCBConstruct.c
View File

@ -1,108 +1,107 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iCBConstruct.c iCBConstruct.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "iCBConstruct.h" #include "gainquant.h"
#include "gainquant.h" #include "getCBvec.h"
#include "getCBvec.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Convert the codebook indexes to make the search easier
* Convert the codebook indexes to make the search easier *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void index_conv_enc(
void index_conv_enc( int *index /* (i/o) Codebook indexes */
int *index /* (i/o) Codebook indexes */ ){
){ int k;
int k;
for (k=1; k<CB_NSTAGES; k++) {
for (k=1; k<CB_NSTAGES; k++) {
if ((index[k]>=108)&&(index[k]<172)) {
if ((index[k]>=108)&&(index[k]<172)) { index[k]-=64;
index[k]-=64; } else if (index[k]>=236) {
} else if (index[k]>=236) { index[k]-=128;
index[k]-=128; } else {
} else { /* ERROR */
/* ERROR */ }
} }
} }
}
void index_conv_dec(
void index_conv_dec( int *index /* (i/o) Codebook indexes */
int *index /* (i/o) Codebook indexes */ ){
){ int k;
int k;
for (k=1; k<CB_NSTAGES; k++) {
for (k=1; k<CB_NSTAGES; k++) {
if ((index[k]>=44)&&(index[k]<108)) {
if ((index[k]>=44)&&(index[k]<108)) { index[k]+=64;
index[k]+=64; } else if ((index[k]>=108)&&(index[k]<128)) {
} else if ((index[k]>=108)&&(index[k]<128)) { index[k]+=128;
index[k]+=128; } else {
} else { /* ERROR */
/* ERROR */ }
} }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Construct decoded vector from codebook and gains.
* Construct decoded vector from codebook and gains. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void iCBConstruct(
void iCBConstruct( float *decvector, /* (o) Decoded vector */
float *decvector, /* (o) Decoded vector */ int *index, /* (i) Codebook indices */
int *index, /* (i) Codebook indices */ int *gain_index,/* (i) Gain quantization indices */
int *gain_index,/* (i) Gain quantization indices */ float *mem, /* (i) Buffer for codevector construction */
float *mem, /* (i) Buffer for codevector construction */ int lMem, /* (i) Length of buffer */
int lMem, /* (i) Length of buffer */ int veclen, /* (i) Length of vector */
int veclen, /* (i) Length of vector */ int nStages /* (i) Number of codebook stages */
int nStages /* (i) Number of codebook stages */ ){
){ int j,k;
int j,k; float gain[CB_NSTAGES];
float gain[CB_NSTAGES]; float cbvec[SUBL];
float cbvec[SUBL];
/* gain de-quantization */
/* gain de-quantization */
gain[0] = gaindequant(gain_index[0], 1.0, 32);
gain[0] = gaindequant(gain_index[0], 1.0, 32);
if (nStages > 1) {
if (nStages > 1) { gain[1] = gaindequant(gain_index[1],
gain[1] = gaindequant(gain_index[1], (float)fabs(gain[0]), 16);
(float)fabs(gain[0]), 16); }
} if (nStages > 2) {
if (nStages > 2) { gain[2] = gaindequant(gain_index[2],
gain[2] = gaindequant(gain_index[2], (float)fabs(gain[1]), 8);
(float)fabs(gain[1]), 8); }
}
/* codebook vector construction and construction of
/* codebook vector construction and construction of total vector */
total vector */
getCBvec(cbvec, mem, index[0], lMem, veclen);
getCBvec(cbvec, mem, index[0], lMem, veclen); for (j=0;j<veclen;j++){
for (j=0;j<veclen;j++){ decvector[j] = gain[0]*cbvec[j];
decvector[j] = gain[0]*cbvec[j]; }
} if (nStages > 1) {
if (nStages > 1) { for (k=1; k<nStages; k++) {
for (k=1; k<nStages; k++) { getCBvec(cbvec, mem, index[k], lMem, veclen);
getCBvec(cbvec, mem, index[k], lMem, veclen); for (j=0;j<veclen;j++) {
for (j=0;j<veclen;j++) { decvector[j] += gain[k]*cbvec[j];
decvector[j] += gain[k]*cbvec[j]; }
} }
} }
} }
}

76
libs/codec/ilbc/iCBConstruct.h
View File

@ -1,38 +1,38 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iCBConstruct.h iCBConstruct.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_ICBCONSTRUCT_H #ifndef __iLBC_ICBCONSTRUCT_H
#define __iLBC_ICBCONSTRUCT_H #define __iLBC_ICBCONSTRUCT_H
void index_conv_enc( void index_conv_enc(
int *index /* (i/o) Codebook indexes */ int *index /* (i/o) Codebook indexes */
); );
void index_conv_dec( void index_conv_dec(
int *index /* (i/o) Codebook indexes */ int *index /* (i/o) Codebook indexes */
); );
void iCBConstruct( void iCBConstruct(
float *decvector, /* (o) Decoded vector */ float *decvector, /* (o) Decoded vector */
int *index, /* (i) Codebook indices */ int *index, /* (i) Codebook indices */
int *gain_index,/* (i) Gain quantization indices */ int *gain_index,/* (i) Gain quantization indices */
float *mem, /* (i) Buffer for codevector construction */ float *mem, /* (i) Buffer for codevector construction */
int lMem, /* (i) Length of buffer */ int lMem, /* (i) Length of buffer */
int veclen, /* (i) Length of vector */ int veclen, /* (i) Length of vector */
int nStages /* (i) Number of codebook stages */ int nStages /* (i) Number of codebook stages */
); );
#endif #endif

957
libs/codec/ilbc/iCBSearch.c
View File

@ -1,480 +1,477 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iCBSearch.c iCBSearch.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "iCBSearch.h" #include "gainquant.h"
#include "gainquant.h" #include "createCB.h"
#include "createCB.h" #include "filter.h"
#include "filter.h" #include "constants.h"
#include "constants.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * Search routine for codebook encoding and gain quantization.
* Search routine for codebook encoding and gain quantization. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void iCBSearch(
void iCBSearch( iLBC_Enc_Inst_t *iLBCenc_inst,
iLBC_Enc_Inst_t *iLBCenc_inst, /* (i) the encoder state structure */
/* (i) the encoder state structure */ int *index, /* (o) Codebook indices */
int *index, /* (o) Codebook indices */ int *gain_index,/* (o) Gain quantization indices */
int *gain_index,/* (o) Gain quantization indices */ float *intarget,/* (i) Target vector for encoding */
float *intarget,/* (i) Target vector for encoding */ float *mem, /* (i) Buffer for codebook construction */
float *mem, /* (i) Buffer for codebook construction */ int lMem, /* (i) Length of buffer */
int lMem, /* (i) Length of buffer */ int lTarget, /* (i) Length of vector */
int lTarget, /* (i) Length of vector */ int nStages, /* (i) Number of codebook stages */
int nStages, /* (i) Number of codebook stages */ float *weightDenum, /* (i) weighting filter coefficients */
float *weightDenum, /* (i) weighting filter coefficients */ float *weightState, /* (i) weighting filter state */
float *weightState, /* (i) weighting filter state */ int block /* (i) the sub-block number */
int block /* (i) the sub-block number */ ){
){ int i, j, icount, stage, best_index, range, counter;
int i, j, icount, stage, best_index, range, counter; float max_measure, gain, measure, crossDot, ftmp;
float max_measure, gain, measure, crossDot, ftmp; float gains[CB_NSTAGES];
float gains[CB_NSTAGES]; float target[SUBL];
float target[SUBL]; int base_index, sInd, eInd, base_size;
int base_index, sInd, eInd, base_size; int sIndAug=0, eIndAug=0;
int sIndAug=0, eIndAug=0; float buf[CB_MEML+SUBL+2*LPC_FILTERORDER];
float buf[CB_MEML+SUBL+2*LPC_FILTERORDER];
float invenergy[CB_EXPAND*128], energy[CB_EXPAND*128];
float invenergy[CB_EXPAND*128], energy[CB_EXPAND*128]; float *pp, *ppi=0, *ppo=0, *ppe=0;
float *pp, *ppi=0, *ppo=0, *ppe=0; float cbvectors[CB_MEML];
float cbvectors[CB_MEML]; float tene, cene, cvec[SUBL];
float tene, cene, cvec[SUBL]; float aug_vec[SUBL];
float aug_vec[SUBL];
memset(cvec,0,SUBL*sizeof(float));
memset(cvec,0,SUBL*sizeof(float));
/* Determine size of codebook sections */
/* Determine size of codebook sections */
base_size=lMem-lTarget+1;
base_size=lMem-lTarget+1;
if (lTarget==SUBL) {
if (lTarget==SUBL) { base_size=lMem-lTarget+1+lTarget/2;
base_size=lMem-lTarget+1+lTarget/2; }
}
/* setup buffer for weighting */
/* setup buffer for weighting */
memcpy(buf,weightState,sizeof(float)*LPC_FILTERORDER);
memcpy(buf,weightState,sizeof(float)*LPC_FILTERORDER); memcpy(buf+LPC_FILTERORDER,mem,lMem*sizeof(float));
memcpy(buf+LPC_FILTERORDER,mem,lMem*sizeof(float)); memcpy(buf+LPC_FILTERORDER+lMem,intarget,lTarget*sizeof(float));
memcpy(buf+LPC_FILTERORDER+lMem,intarget,lTarget*sizeof(float));
/* weighting */
/* weighting */
AllPoleFilter(buf+LPC_FILTERORDER, weightDenum,
AllPoleFilter(buf+LPC_FILTERORDER, weightDenum, lMem+lTarget, LPC_FILTERORDER);
lMem+lTarget, LPC_FILTERORDER);
/* Construct the codebook and target needed */
/* Construct the codebook and target needed */
memcpy(target, buf+LPC_FILTERORDER+lMem, lTarget*sizeof(float));
memcpy(target, buf+LPC_FILTERORDER+lMem, lTarget*sizeof(float));
tene=0.0;
tene=0.0; for (i=0; i<lTarget; i++) {
for (i=0; i<lTarget; i++) { tene+=target[i]*target[i];
tene+=target[i]*target[i]; }
}
/* Prepare search over one more codebook section. This section
/* Prepare search over one more codebook section. This section is created by filtering the original buffer with a filter. */
is created by filtering the original buffer with a filter. */
filteredCBvecs(cbvectors, buf+LPC_FILTERORDER, lMem);
filteredCBvecs(cbvectors, buf+LPC_FILTERORDER, lMem);
/* The Main Loop over stages */
/* The Main Loop over stages */
for (stage=0; stage<nStages; stage++) {
for (stage=0; stage<nStages; stage++) {
range = search_rangeTbl[block][stage];
range = search_rangeTbl[block][stage];
/* initialize search measure */
/* initialize search measure */
max_measure = (float)-10000000.0;
max_measure = (float)-10000000.0; gain = (float)0.0;
gain = (float)0.0; best_index = 0;
best_index = 0;
/* Compute cross dot product between the target
/* Compute cross dot product between the target
and the CB memory */
and the CB memory */
crossDot=0.0;
crossDot=0.0; pp=buf+LPC_FILTERORDER+lMem-lTarget;
pp=buf+LPC_FILTERORDER+lMem-lTarget; for (j=0; j<lTarget; j++) {
for (j=0; j<lTarget; j++) { crossDot += target[j]*(*pp++);
crossDot += target[j]*(*pp++); }
}
if (stage==0) {
if (stage==0) {
/* Calculate energy in the first block of
/* Calculate energy in the first block of 'lTarget' sampels. */
'lTarget' sampels. */ ppe = energy;
ppe = energy; ppi = buf+LPC_FILTERORDER+lMem-lTarget-1;
ppi = buf+LPC_FILTERORDER+lMem-lTarget-1; ppo = buf+LPC_FILTERORDER+lMem-1;
ppo = buf+LPC_FILTERORDER+lMem-1;
*ppe=0.0;
*ppe=0.0; pp=buf+LPC_FILTERORDER+lMem-lTarget;
pp=buf+LPC_FILTERORDER+lMem-lTarget; for (j=0; j<lTarget; j++) {
for (j=0; j<lTarget; j++) { *ppe+=(*pp)*(*pp++);
*ppe+=(*pp)*(*pp); }
pp++;
} if (*ppe>0.0) {
invenergy[0] = (float) 1.0 / (*ppe + EPS);
if (*ppe>0.0) { } else {
invenergy[0] = (float) 1.0 / (*ppe + EPS); invenergy[0] = (float) 0.0;
} else { }
invenergy[0] = (float) 0.0; ppe++;
}
ppe++; measure=(float)-10000000.0;
measure=(float)-10000000.0; if (crossDot > 0.0) {
measure = crossDot*crossDot*invenergy[0];
if (crossDot > 0.0) { }
measure = crossDot*crossDot*invenergy[0]; }
} else {
} measure = crossDot*crossDot*invenergy[0];
else { }
measure = crossDot*crossDot*invenergy[0];
} /* check if measure is better */
ftmp = crossDot*invenergy[0];
/* check if measure is better */
ftmp = crossDot*invenergy[0]; if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
best_index = 0;
if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { max_measure = measure;
best_index = 0; gain = ftmp;
max_measure = measure; }
gain = ftmp;
} /* loop over the main first codebook section,
full search */
/* loop over the main first codebook section,
full search */ for (icount=1; icount<range; icount++) {
for (icount=1; icount<range; icount++) { /* calculate measure */
/* calculate measure */
crossDot=0.0;
pp = buf+LPC_FILTERORDER+lMem-lTarget-icount;
crossDot=0.0;
pp = buf+LPC_FILTERORDER+lMem-lTarget-icount; for (j=0; j<lTarget; j++) {
crossDot += target[j]*(*pp++);
for (j=0; j<lTarget; j++) { }
crossDot += target[j]*(*pp++);
} if (stage==0) {
*ppe++ = energy[icount-1] + (*ppi)*(*ppi) -
if (stage==0) { (*ppo)*(*ppo);
*ppe++ = energy[icount-1] + (*ppi)*(*ppi) - ppo--;
(*ppo)*(*ppo); ppi--;
ppo--;
ppi--; if (energy[icount]>0.0) {
invenergy[icount] =
if (energy[icount]>0.0) { (float)1.0/(energy[icount]+EPS);
invenergy[icount] = } else {
(float)1.0/(energy[icount]+EPS); invenergy[icount] = (float) 0.0;
} else { }
invenergy[icount] = (float) 0.0;
} measure=(float)-10000000.0;
measure=(float)-10000000.0; if (crossDot > 0.0) {
measure = crossDot*crossDot*invenergy[icount];
if (crossDot > 0.0) { }
measure = crossDot*crossDot*invenergy[icount]; }
} else {
} measure = crossDot*crossDot*invenergy[icount];
else { }
measure = crossDot*crossDot*invenergy[icount];
} /* check if measure is better */
ftmp = crossDot*invenergy[icount];
/* check if measure is better */
ftmp = crossDot*invenergy[icount]; if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
best_index = icount;
if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { max_measure = measure;
best_index = icount; gain = ftmp;
max_measure = measure; }
gain = ftmp; }
}
} /* Loop over augmented part in the first codebook
* section, full search.
/* Loop over augmented part in the first codebook * The vectors are interpolated.
* section, full search. */
* The vectors are interpolated.
*/ if (lTarget==SUBL) {
if (lTarget==SUBL) { /* Search for best possible cb vector and
compute the CB-vectors' energy. */
/* Search for best possible cb vector and searchAugmentedCB(20, 39, stage, base_size-lTarget/2,
compute the CB-vectors' energy. */ target, buf+LPC_FILTERORDER+lMem,
searchAugmentedCB(20, 39, stage, base_size-lTarget/2, &max_measure, &best_index, &gain, energy,
target, buf+LPC_FILTERORDER+lMem, invenergy);
&max_measure, &best_index, &gain, energy,
invenergy);
}
} /* set search range for following codebook sections */
/* set search range for following codebook sections */ base_index=best_index;
base_index=best_index; /* unrestricted search */
/* unrestricted search */ if (CB_RESRANGE == -1) {
sInd=0;
if (CB_RESRANGE == -1) { eInd=range-1;
sInd=0; sIndAug=20;
eInd=range-1; eIndAug=39;
sIndAug=20; }
eIndAug=39;
} /* restriced search around best index from first
codebook section */
/* restriced search around best index from first
codebook section */ else {
/* Initialize search indices */
else { sIndAug=0;
/* Initialize search indices */ eIndAug=0;
sIndAug=0; sInd=base_index-CB_RESRANGE/2;
eIndAug=0; eInd=sInd+CB_RESRANGE;
sInd=base_index-CB_RESRANGE/2;
eInd=sInd+CB_RESRANGE; if (lTarget==SUBL) {
if (lTarget==SUBL) { if (sInd<0) {
if (sInd<0) { sIndAug = 40 + sInd;
eIndAug = 39;
sIndAug = 40 + sInd; sInd=0;
eIndAug = 39;
sInd=0; } else if ( base_index < (base_size-20) ) {
} else if ( base_index < (base_size-20) ) { if (eInd > range) {
sInd -= (eInd-range);
if (eInd > range) { eInd = range;
sInd -= (eInd-range); }
eInd = range; } else { /* base_index >= (base_size-20) */
}
} else { /* base_index >= (base_size-20) */ if (sInd < (base_size-20)) {
sIndAug = 20;
if (sInd < (base_size-20)) { sInd = 0;
sIndAug = 20; eInd = 0;
sInd = 0; eIndAug = 19 + CB_RESRANGE;
eInd = 0;
eIndAug = 19 + CB_RESRANGE; if(eIndAug > 39) {
eInd = eIndAug-39;
if(eIndAug > 39) { eIndAug = 39;
eInd = eIndAug-39; }
eIndAug = 39; } else {
} sIndAug = 20 + sInd - (base_size-20);
} else { eIndAug = 39;
sIndAug = 20 + sInd - (base_size-20);
eIndAug = 39;
sInd = 0;
eInd = CB_RESRANGE - (eIndAug-sIndAug+1);
sInd = 0; }
eInd = CB_RESRANGE - (eIndAug-sIndAug+1); }
}
} } else { /* lTarget = 22 or 23 */
} else { /* lTarget = 22 or 23 */ if (sInd < 0) {
eInd -= sInd;
if (sInd < 0) { sInd = 0;
eInd -= sInd; }
sInd = 0;
} if(eInd > range) {
sInd -= (eInd - range);
if(eInd > range) { eInd = range;
sInd -= (eInd - range); }
eInd = range; }
} }
}
} /* search of higher codebook section */
/* search of higher codebook section */ /* index search range */
counter = sInd;
/* index search range */ sInd += base_size;
counter = sInd; eInd += base_size;
sInd += base_size;
eInd += base_size;
if (stage==0) {
ppe = energy+base_size;
if (stage==0) { *ppe=0.0;
ppe = energy+base_size;
*ppe=0.0; pp=cbvectors+lMem-lTarget;
for (j=0; j<lTarget; j++) {
pp=cbvectors+lMem-lTarget; *ppe+=(*pp)*(*pp++);
for (j=0; j<lTarget; j++) { }
*ppe+=(*pp)*(*pp);
pp++; ppi = cbvectors + lMem - 1 - lTarget;
} ppo = cbvectors + lMem - 1;
ppi = cbvectors + lMem - 1 - lTarget; for (j=0; j<(range-1); j++) {
ppo = cbvectors + lMem - 1; *(ppe+1) = *ppe + (*ppi)*(*ppi) - (*ppo)*(*ppo);
ppo--;
for (j=0; j<(range-1); j++) { ppi--;
*(ppe+1) = *ppe + (*ppi)*(*ppi) - (*ppo)*(*ppo); ppe++;
ppo--; }
ppi--; }
ppe++;
} /* loop over search range */
}
for (icount=sInd; icount<eInd; icount++) {
/* loop over search range */
/* calculate measure */
for (icount=sInd; icount<eInd; icount++) {
crossDot=0.0;
/* calculate measure */
crossDot=0.0; pp=cbvectors + lMem - (counter++) - lTarget;
for (j=0;j<lTarget;j++) {
pp=cbvectors + lMem - (counter++) - lTarget; crossDot += target[j]*(*pp++);
}
for (j=0;j<lTarget;j++) {
crossDot += target[j]*(*pp++); if (energy[icount]>0.0) {
} invenergy[icount] =(float)1.0/(energy[icount]+EPS);
} else {
if (energy[icount]>0.0) { invenergy[icount] =(float)0.0;
invenergy[icount] =(float)1.0/(energy[icount]+EPS); }
} else {
invenergy[icount] =(float)0.0; if (stage==0) {
}
measure=(float)-10000000.0;
if (stage==0) {
if (crossDot > 0.0) {
measure=(float)-10000000.0; measure = crossDot*crossDot*
invenergy[icount];
if (crossDot > 0.0) { }
measure = crossDot*crossDot* }
invenergy[icount]; else {
} measure = crossDot*crossDot*invenergy[icount];
} }
else {
measure = crossDot*crossDot*invenergy[icount]; /* check if measure is better */
} ftmp = crossDot*invenergy[icount];
/* check if measure is better */ if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
ftmp = crossDot*invenergy[icount]; best_index = icount;
max_measure = measure;
if ((measure>max_measure) && (fabs(ftmp)<CB_MAXGAIN)) { gain = ftmp;
best_index = icount; }
max_measure = measure; }
gain = ftmp;
} /* Search the augmented CB inside the limited range. */
}
if ((lTarget==SUBL)&&(sIndAug!=0)) {
/* Search the augmented CB inside the limited range. */ searchAugmentedCB(sIndAug, eIndAug, stage,
2*base_size-20, target, cbvectors+lMem,
if ((lTarget==SUBL)&&(sIndAug!=0)) { &max_measure, &best_index, &gain, energy,
searchAugmentedCB(sIndAug, eIndAug, stage, invenergy);
2*base_size-20, target, cbvectors+lMem, }
&max_measure, &best_index, &gain, energy,
invenergy); /* record best index */
}
index[stage] = best_index;
/* record best index */
/* gain quantization */
index[stage] = best_index;
if (stage==0){
/* gain quantization */
if (gain<0.0){
if (stage==0){ gain = 0.0;
if (gain<0.0){
gain = 0.0; }
if (gain>CB_MAXGAIN) {
} gain = (float)CB_MAXGAIN;
}
if (gain>CB_MAXGAIN) { gain = gainquant(gain, 1.0, 32, &gain_index[stage]);
gain = (float)CB_MAXGAIN; }
} else {
gain = gainquant(gain, 1.0, 32, &gain_index[stage]); if (stage==1) {
} gain = gainquant(gain, (float)fabs(gains[stage-1]),
else { 16, &gain_index[stage]);
if (stage==1) { } else {
gain = gainquant(gain, (float)fabs(gains[stage-1]), gain = gainquant(gain, (float)fabs(gains[stage-1]),
16, &gain_index[stage]); 8, &gain_index[stage]);
} else { }
gain = gainquant(gain, (float)fabs(gains[stage-1]), }
8, &gain_index[stage]);
} /* Extract the best (according to measure)
} codebook vector */
/* Extract the best (according to measure) if (lTarget==(STATE_LEN-iLBCenc_inst->state_short_len)) {
codebook vector */
if (index[stage]<base_size) {
if (lTarget==(STATE_LEN-iLBCenc_inst->state_short_len)) { pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage];
} else {
if (index[stage]<base_size) { pp=cbvectors+lMem-lTarget-
pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage]; index[stage]+base_size;
} else { }
pp=cbvectors+lMem-lTarget- } else {
index[stage]+base_size;
} if (index[stage]<base_size) {
} else { if (index[stage]<(base_size-20)) {
pp=buf+LPC_FILTERORDER+lMem-
if (index[stage]<base_size) { lTarget-index[stage];
if (index[stage]<(base_size-20)) { } else {
pp=buf+LPC_FILTERORDER+lMem- createAugmentedVec(index[stage]-base_size+40,
lTarget-index[stage]; buf+LPC_FILTERORDER+lMem,aug_vec);
} else { pp=aug_vec;
createAugmentedVec(index[stage]-base_size+40, }
buf+LPC_FILTERORDER+lMem,aug_vec); } else {
pp=aug_vec; int filterno, position;
}
} else { filterno=index[stage]/base_size;
int filterno, position; position=index[stage]-filterno*base_size;
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;
if (position<(base_size-20)) { } else {
pp=cbvectors+filterno*lMem-lTarget- createAugmentedVec(
index[stage]+filterno*base_size; index[stage]-(filterno+1)*base_size+40,
} else { cbvectors+filterno*lMem,aug_vec);
createAugmentedVec( pp=aug_vec;
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 */
/* Subtract the best codebook vector, according for (j=0;j<lTarget;j++) {
to measure, from the target vector */ cvec[j] += gain*(*pp);
target[j] -= gain*(*pp++);
for (j=0;j<lTarget;j++) { }
cvec[j] += gain*(*pp);
target[j] -= gain*(*pp++); /* record quantized gain */
}
gains[stage]=gain;
/* record quantized gain */
}/* end of Main Loop. for (stage=0;... */
gains[stage]=gain;
/* Gain adjustment for energy matching */
}/* end of Main Loop. for (stage=0;... */ cene=0.0;
for (i=0; i<lTarget; i++) {
/* Gain adjustment for energy matching */ cene+=cvec[i]*cvec[i];
cene=0.0; }
for (i=0; i<lTarget; i++) { j=gain_index[0];
cene+=cvec[i]*cvec[i];
} for (i=gain_index[0]; i<32; i++) {
j=gain_index[0]; ftmp=cene*gain_sq5Tbl[i]*gain_sq5Tbl[i];
for (i=gain_index[0]; i<32; i++) { if ((ftmp<(tene*gains[0]*gains[0])) &&
ftmp=cene*gain_sq5Tbl[i]*gain_sq5Tbl[i]; (gain_sq5Tbl[j]<(2.0*gains[0]))) {
j=i;
if ((ftmp<(tene*gains[0]*gains[0])) && }
(gain_sq5Tbl[j]<(2.0*gains[0]))) { }
j=i; gain_index[0]=j;
} }
}
gain_index[0]=j;
}

70
libs/codec/ilbc/iCBSearch.h
View File

@ -1,35 +1,35 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iCBSearch.h iCBSearch.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_ICBSEARCH_H #ifndef __iLBC_ICBSEARCH_H
#define __iLBC_ICBSEARCH_H #define __iLBC_ICBSEARCH_H
void iCBSearch( void iCBSearch(
iLBC_Enc_Inst_t *iLBCenc_inst, iLBC_Enc_Inst_t *iLBCenc_inst,
/* (i) the encoder state structure */ /* (i) the encoder state structure */
int *index, /* (o) Codebook indices */ int *index, /* (o) Codebook indices */
int *gain_index,/* (o) Gain quantization indices */ int *gain_index,/* (o) Gain quantization indices */
float *intarget,/* (i) Target vector for encoding */ float *intarget,/* (i) Target vector for encoding */
float *mem, /* (i) Buffer for codebook construction */ float *mem, /* (i) Buffer for codebook construction */
int lMem, /* (i) Length of buffer */ int lMem, /* (i) Length of buffer */
int lTarget, /* (i) Length of vector */ int lTarget, /* (i) Length of vector */
int nStages, /* (i) Number of codebook stages */ int nStages, /* (i) Number of codebook stages */
float *weightDenum, /* (i) weighting filter coefficients */ float *weightDenum, /* (i) weighting filter coefficients */
float *weightState, /* (i) weighting filter state */ float *weightState, /* (i) weighting filter state */
int block /* (i) the sub-block number */ int block /* (i) the sub-block number */
); );
#endif #endif

1237
libs/codec/ilbc/iLBC_decode.c
View File

File diff suppressed because it is too large Load Diff

80
libs/codec/ilbc/iLBC_decode.h
View File

@ -1,40 +1,40 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iLBC_decode.h iLBC_decode.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_ILBCDECODE_H #ifndef __iLBC_ILBCDECODE_H
#define __iLBC_ILBCDECODE_H #define __iLBC_ILBCDECODE_H
#include "iLBC_define.h" #include "iLBC_define.h"
short initDecode( /* (o) Number of decoded short initDecode( /* (o) Number of decoded
samples */ samples */
iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) Decoder instance */ iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) Decoder instance */
int mode, /* (i) frame size mode */ int mode, /* (i) frame size mode */
int use_enhancer /* (i) 1 to use enhancer int use_enhancer /* (i) 1 to use enhancer
0 to run without 0 to run without
enhancer */ enhancer */
); );
void iLBC_decode( void iLBC_decode(
float *decblock, /* (o) decoded signal block */ float *decblock, /* (o) decoded signal block */
unsigned char *bytes, /* (i) encoded signal bits */ unsigned char *bytes, /* (i) encoded signal bits */
iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state
structure */ structure */
int mode /* (i) 0: bad packet, PLC, int mode /* (i) 0: bad packet, PLC,
1: normal */ 1: normal */
); );
#endif #endif

405
libs/codec/ilbc/iLBC_define.h
View File

@ -1,201 +1,204 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iLBC_define.h iLBC_define.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <string.h> #include <string.h>
#ifndef __iLBC_ILBCDEFINE_H #ifndef __iLBC_ILBCDEFINE_H
#define __iLBC_ILBCDEFINE_H #define __iLBC_ILBCDEFINE_H
/* general codec settings */ /* general codec settings */
#define FS (float)8000.0 #define FS (float)8000.0
#define BLOCKL_20MS 160 #define BLOCKL_20MS 160
#define BLOCKL_30MS 240 #define BLOCKL_30MS 240
#define BLOCKL_MAX 240 #define BLOCKL_MAX 240
#define NSUB_20MS 4 #define NSUB_20MS 4
#define NSUB_30MS 6 #define NSUB_30MS 6
#define NSUB_MAX 6 #define NSUB_MAX 6
#define NASUB_20MS 2 #define NASUB_20MS 2
#define NASUB_30MS 4 #define NASUB_30MS 4
#define NASUB_MAX 4 #define NASUB_MAX 4
#define SUBL 40 #define SUBL 40
#define STATE_LEN 80 #define STATE_LEN 80
#define STATE_SHORT_LEN_30MS 58 #define STATE_SHORT_LEN_30MS 58
#define STATE_SHORT_LEN_20MS 57 #define STATE_SHORT_LEN_20MS 57
/* LPC settings */ /* LPC settings */
#define LPC_FILTERORDER 10 #define LPC_FILTERORDER 10
#define LPC_CHIRP_SYNTDENUM (float)0.9025 #define LPC_CHIRP_SYNTDENUM (float)0.9025
#define LPC_CHIRP_WEIGHTDENUM (float)0.4222 #define LPC_CHIRP_WEIGHTDENUM (float)0.4222
#define LPC_LOOKBACK 60 #define LPC_LOOKBACK 60
#define LPC_N_20MS 1 #define LPC_N_20MS 1
#define LPC_N_30MS 2 #define LPC_N_30MS 2
#define LPC_N_MAX 2 #define LPC_N_MAX 2
#define LPC_ASYMDIFF 20 #define LPC_ASYMDIFF 20
#define LPC_BW (float)60.0 #define LPC_BW (float)60.0
#define LPC_WN (float)1.0001 #define LPC_WN (float)1.0001
#define LSF_NSPLIT 3 #define LSF_NSPLIT 3
#define LSF_NUMBER_OF_STEPS 4
#define LPC_HALFORDER (LPC_FILTERORDER/2) #define LSF_NUMBER_OF_STEPS 4
#define LPC_HALFORDER (LPC_FILTERORDER/2)
/* cb settings */
/* cb settings */
#define CB_NSTAGES 3
#define CB_EXPAND 2 #define CB_NSTAGES 3
#define CB_MEML 147 #define CB_EXPAND 2
#define CB_FILTERLEN 2*4 #define CB_MEML 147
#define CB_HALFFILTERLEN 4 #define CB_FILTERLEN 2*4
#define CB_RESRANGE 34 #define CB_HALFFILTERLEN 4
#define CB_MAXGAIN (float)1.3 #define CB_RESRANGE 34
#define CB_MAXGAIN (float)1.3
/* enhancer */
/* enhancer */
#define ENH_BLOCKL 80 /* block length */
#define ENH_BLOCKL_HALF (ENH_BLOCKL/2) #define ENH_BLOCKL 80 /* block length */
#define ENH_HL 3 /* 2*ENH_HL+1 is number blocks #define ENH_BLOCKL_HALF (ENH_BLOCKL/2)
in said second sequence */ #define ENH_HL 3 /* 2*ENH_HL+1 is number blocks
#define ENH_SLOP 2 /* max difference estimated and in said second sequence */
correct pitch period */ #define ENH_SLOP 2 /* max difference estimated and
#define ENH_PLOCSL 20 /* pitch-estimates and pitch- correct pitch period */
locations buffer length */ #define ENH_PLOCSL 20 /* pitch-estimates and pitch-
#define ENH_OVERHANG 2 locations buffer length */
#define ENH_UPS0 4 /* upsampling rate */ #define ENH_OVERHANG 2
#define ENH_FL0 3 /* 2*FLO+1 is the length of #define ENH_UPS0 4 /* upsampling rate */
each filter */ #define ENH_FL0 3 /* 2*FLO+1 is the length of
#define ENH_VECTL (ENH_BLOCKL+2*ENH_FL0) each filter */
#define ENH_CORRDIM (2*ENH_SLOP+1) #define ENH_VECTL (ENH_BLOCKL+2*ENH_FL0)
#define ENH_NBLOCKS (BLOCKL_MAX/ENH_BLOCKL) #define ENH_CORRDIM (2*ENH_SLOP+1)
#define ENH_NBLOCKS_EXTRA 5 #define ENH_NBLOCKS (BLOCKL_MAX/ENH_BLOCKL)
#define ENH_NBLOCKS_TOT 8 /* ENH_NBLOCKS + #define ENH_NBLOCKS_EXTRA 5
ENH_NBLOCKS_EXTRA */ #define ENH_NBLOCKS_TOT 8 /* ENH_NBLOCKS +
#define ENH_BUFL (ENH_NBLOCKS_TOT)*ENH_BLOCKL ENH_NBLOCKS_EXTRA */
#define ENH_ALPHA0 (float)0.05 #define ENH_BUFL (ENH_NBLOCKS_TOT)*ENH_BLOCKL
#define ENH_ALPHA0 (float)0.05
/* Down sampling */
/* Down sampling */
#define FILTERORDER_DS 7
#define DELAY_DS 3 #define FILTERORDER_DS 7
#define FACTOR_DS 2 #define DELAY_DS 3
#define FACTOR_DS 2
/* bit stream defs */
/* bit stream defs */
#define NO_OF_BYTES_20MS 38
#define NO_OF_BYTES_30MS 50 #define NO_OF_BYTES_20MS 38
#define NO_OF_WORDS_20MS 19 #define NO_OF_BYTES_30MS 50
#define NO_OF_WORDS_30MS 25 #define NO_OF_WORDS_20MS 19
#define STATE_BITS 3 #define NO_OF_WORDS_30MS 25
#define BYTE_LEN 8 #define STATE_BITS 3
#define ULP_CLASSES 3 #define BYTE_LEN 8
#define ULP_CLASSES 3
/* help parameters */
/* help parameters */
#define FLOAT_MAX (float)1.0e37
#define EPS (float)2.220446049250313e-016
#define PI (float)3.14159265358979323846 #define FLOAT_MAX (float)1.0e37
#define MIN_SAMPLE -32768 #define EPS (float)2.220446049250313e-016
#define MAX_SAMPLE 32767 #define PI (float)3.14159265358979323846
#define TWO_PI (float)6.283185307 #define MIN_SAMPLE -32768
#define PI2 (float)0.159154943 #define MAX_SAMPLE 32767
#define TWO_PI (float)6.283185307
/* type definition encoder instance */ #define PI2 (float)0.159154943
typedef struct iLBC_ULP_Inst_t_ {
int lsf_bits[6][ULP_CLASSES+2]; /* type definition encoder instance */
int start_bits[ULP_CLASSES+2]; typedef struct iLBC_ULP_Inst_t_ {
int startfirst_bits[ULP_CLASSES+2]; int lsf_bits[6][ULP_CLASSES+2];
int scale_bits[ULP_CLASSES+2]; int start_bits[ULP_CLASSES+2];
int state_bits[ULP_CLASSES+2]; int startfirst_bits[ULP_CLASSES+2];
int extra_cb_index[CB_NSTAGES][ULP_CLASSES+2]; int scale_bits[ULP_CLASSES+2];
int extra_cb_gain[CB_NSTAGES][ULP_CLASSES+2]; int state_bits[ULP_CLASSES+2];
int cb_index[NSUB_MAX][CB_NSTAGES][ULP_CLASSES+2]; int extra_cb_index[CB_NSTAGES][ULP_CLASSES+2];
int cb_gain[NSUB_MAX][CB_NSTAGES][ULP_CLASSES+2]; int extra_cb_gain[CB_NSTAGES][ULP_CLASSES+2];
} iLBC_ULP_Inst_t; int cb_index[NSUB_MAX][CB_NSTAGES][ULP_CLASSES+2];
int cb_gain[NSUB_MAX][CB_NSTAGES][ULP_CLASSES+2];
/* type definition encoder instance */ } iLBC_ULP_Inst_t;
typedef struct iLBC_Enc_Inst_t_ {
/* type definition encoder instance */
/* flag for frame size mode */ typedef struct iLBC_Enc_Inst_t_ {
int mode;
/* flag for frame size mode */
/* basic parameters for different frame sizes */ int mode;
int blockl;
int nsub; /* basic parameters for different frame sizes */
int nasub; int blockl;
int no_of_bytes, no_of_words; int nsub;
int lpc_n; int nasub;
int state_short_len; int no_of_bytes, no_of_words;
const iLBC_ULP_Inst_t *ULP_inst; int lpc_n;
int state_short_len;
/* analysis filter state */ const iLBC_ULP_Inst_t *ULP_inst;
float anaMem[LPC_FILTERORDER];
/* analysis filter state */
/* old lsf parameters for interpolation */ float anaMem[LPC_FILTERORDER];
float lsfold[LPC_FILTERORDER];
float lsfdeqold[LPC_FILTERORDER]; /* old lsf parameters for interpolation */
float lsfold[LPC_FILTERORDER];
/* signal buffer for LP analysis */ float lsfdeqold[LPC_FILTERORDER];
float lpc_buffer[LPC_LOOKBACK + BLOCKL_MAX];
/* signal buffer for LP analysis */
/* state of input HP filter */ float lpc_buffer[LPC_LOOKBACK + BLOCKL_MAX];
float hpimem[4];
/* state of input HP filter */
} iLBC_Enc_Inst_t; float hpimem[4];
/* type definition decoder instance */ } iLBC_Enc_Inst_t;
typedef struct iLBC_Dec_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 */ /* flag for frame size mode */
int blockl; int mode;
int nsub;
int nasub; /* basic parameters for different frame sizes */
int no_of_bytes, no_of_words; int blockl;
int lpc_n; int nsub;
int state_short_len; int nasub;
const iLBC_ULP_Inst_t *ULP_inst; int no_of_bytes, no_of_words;
int lpc_n;
/* synthesis filter state */ int state_short_len;
float syntMem[LPC_FILTERORDER]; const iLBC_ULP_Inst_t *ULP_inst;
/* old LSF for interpolation */ /* synthesis filter state */
float lsfdeqold[LPC_FILTERORDER]; float syntMem[LPC_FILTERORDER];
/* pitch lag estimated in enhancer and used in PLC */ /* old LSF for interpolation */
int last_lag; float lsfdeqold[LPC_FILTERORDER];
/* PLC state information */ /* pitch lag estimated in enhancer and used in PLC */
int prevLag, consPLICount, prevPLI, prev_enh_pl; int last_lag;
float prevLpc[LPC_FILTERORDER+1];
float prevResidual[NSUB_MAX*SUBL]; /* PLC state information */
float per; int prevLag, consPLICount, prevPLI, prev_enh_pl;
unsigned long seed; float prevLpc[LPC_FILTERORDER+1];
float prevResidual[NSUB_MAX*SUBL];
/* previous synthesis filter parameters */ float per;
float old_syntdenum[(LPC_FILTERORDER + 1)*NSUB_MAX]; unsigned long seed;
/* state of output HP filter */ /* previous synthesis filter parameters */
float hpomem[4]; float old_syntdenum[(LPC_FILTERORDER + 1)*NSUB_MAX];
/* enhancer state information */ /* state of output HP filter */
int use_enhancer; float hpomem[4];
float enh_buf[ENH_BUFL];
float enh_period[ENH_NBLOCKS_TOT]; /* enhancer state information */
int use_enhancer;
} iLBC_Dec_Inst_t; float enh_buf[ENH_BUFL];
float enh_period[ENH_NBLOCKS_TOT];
#endif
} iLBC_Dec_Inst_t;
#endif

1021
libs/codec/ilbc/iLBC_encode.c
View File

File diff suppressed because it is too large Load Diff

70
libs/codec/ilbc/iLBC_encode.h
View File

@ -1,37 +1,37 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
iLBC_encode.h iLBC_encode.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_ILBCENCODE_H #ifndef __iLBC_ILBCENCODE_H
#define __iLBC_ILBCENCODE_H #define __iLBC_ILBCENCODE_H
#include "iLBC_define.h" #include "iLBC_define.h"
short initEncode( /* (o) Number of bytes short initEncode( /* (o) Number of bytes
encoded */ encoded */
iLBC_Enc_Inst_t *iLBCenc_inst, /* (i/o) Encoder instance */ iLBC_Enc_Inst_t *iLBCenc_inst, /* (i/o) Encoder instance */
int mode /* (i) frame size mode */ int mode /* (i) frame size mode */
); );
void iLBC_encode( void iLBC_encode(
unsigned char *bytes, /* (o) encoded data bits iLBC */ unsigned char *bytes, /* (o) encoded data bits iLBC */
float *block, /* (o) speech vector to float *block, /* (o) speech vector to
encode */ encode */
iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder
state */ state */
); );
#endif #endif

527
libs/codec/ilbc/lsf.c
View File

@ -1,264 +1,263 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
lsf.c lsf.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "lsf.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * conversion from lpc coefficients to lsf coefficients
* conversion from lpc coefficients to lsf coefficients *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void a2lsf(
void a2lsf( float *freq,/* (o) lsf coefficients */
float *freq,/* (o) lsf coefficients */ float *a /* (i) lpc coefficients */
float *a /* (i) lpc coefficients */ ){
){ float steps[LSF_NUMBER_OF_STEPS] =
float steps[LSF_NUMBER_OF_STEPS] = {(float)0.00635, (float)0.003175, (float)0.0015875,
{(float)0.00635, (float)0.003175, (float)0.0015875, (float)0.00079375};
(float)0.00079375}; float step;
float step; int step_idx;
int step_idx; int lsp_index;
int lsp_index; float p[LPC_HALFORDER];
float p[LPC_HALFORDER]; float q[LPC_HALFORDER];
float q[LPC_HALFORDER]; float p_pre[LPC_HALFORDER];
float p_pre[LPC_HALFORDER];
float q_pre[LPC_HALFORDER];
float q_pre[LPC_HALFORDER]; float old_p, old_q, *old;
float old_p, old_q, *old; float *pq_coef;
float *pq_coef; float omega, old_omega;
float omega, old_omega; int i;
int i; float hlp, hlp1, hlp2, hlp3, hlp4, hlp5;
float hlp, hlp1, hlp2, hlp3, hlp4, hlp5;
for (i=0; i<LPC_HALFORDER; i++) {
for (i=0; i<LPC_HALFORDER; i++) { p[i] = (float)-1.0 * (a[i + 1] + a[LPC_FILTERORDER - i]);
p[i] = (float)-1.0 * (a[i + 1] + a[LPC_FILTERORDER - i]); q[i] = a[LPC_FILTERORDER - i] - a[i + 1];
q[i] = a[LPC_FILTERORDER - i] - a[i + 1]; }
}
p_pre[0] = (float)-1.0 - p[0];
p_pre[0] = (float)-1.0 - p[0]; p_pre[1] = - p_pre[0] - p[1];
p_pre[1] = - p_pre[0] - p[1]; p_pre[2] = - p_pre[1] - p[2];
p_pre[2] = - p_pre[1] - p[2]; p_pre[3] = - p_pre[2] - p[3];
p_pre[3] = - p_pre[2] - p[3]; p_pre[4] = - p_pre[3] - p[4];
p_pre[4] = - p_pre[3] - p[4]; p_pre[4] = p_pre[4] / 2;
p_pre[4] = p_pre[4] / 2;
q_pre[0] = (float)1.0 - q[0];
q_pre[0] = (float)1.0 - q[0]; q_pre[1] = q_pre[0] - q[1];
q_pre[1] = q_pre[0] - q[1]; q_pre[2] = q_pre[1] - q[2];
q_pre[2] = q_pre[1] - q[2]; q_pre[3] = q_pre[2] - q[3];
q_pre[3] = q_pre[2] - q[3]; q_pre[4] = q_pre[3] - q[4];
q_pre[4] = q_pre[3] - q[4]; q_pre[4] = q_pre[4] / 2;
q_pre[4] = q_pre[4] / 2;
omega = 0.0;
omega = 0.0; old_omega = 0.0;
old_omega = 0.0;
old_p = FLOAT_MAX;
old_p = FLOAT_MAX; old_q = FLOAT_MAX;
old_q = FLOAT_MAX;
/* Here we loop through lsp_index to find all the
/* Here we loop through lsp_index to find all the LPC_FILTERORDER roots for omega. */
LPC_FILTERORDER roots for omega. */
for (lsp_index = 0; lsp_index<LPC_FILTERORDER; lsp_index++) {
for (lsp_index = 0; lsp_index<LPC_FILTERORDER; lsp_index++) {
/* Depending on lsp_index being even or odd, we
/* Depending on lsp_index being even or odd, we alternatively solve the roots for the two LSP equations. */
alternatively solve the roots for the two LSP equations. */
if ((lsp_index & 0x1) == 0) {
if ((lsp_index & 0x1) == 0) { pq_coef = p_pre;
pq_coef = p_pre; old = &old_p;
old = &old_p; } else {
} else { pq_coef = q_pre;
pq_coef = q_pre; old = &old_q;
old = &old_q; }
}
/* Start with low resolution grid */
/* Start with low resolution grid */
for (step_idx = 0, step = steps[step_idx];
for (step_idx = 0, step = steps[step_idx]; step_idx < LSF_NUMBER_OF_STEPS;){
step_idx < LSF_NUMBER_OF_STEPS;){
/* cos(10piw) + pq(0)cos(8piw) + pq(1)cos(6piw) +
/* cos(10piw) + pq(0)cos(8piw) + pq(1)cos(6piw) + pq(2)cos(4piw) + pq(3)cod(2piw) + pq(4) */
pq(2)cos(4piw) + pq(3)cod(2piw) + pq(4) */
hlp = (float)cos(omega * TWO_PI);
hlp = (float)cos(omega * TWO_PI); hlp1 = (float)2.0 * hlp + pq_coef[0];
hlp1 = (float)2.0 * hlp + pq_coef[0]; hlp2 = (float)2.0 * hlp * hlp1 - (float)1.0 +
hlp2 = (float)2.0 * hlp * hlp1 - (float)1.0 + pq_coef[1];
pq_coef[1]; hlp3 = (float)2.0 * hlp * hlp2 - hlp1 + pq_coef[2];
hlp3 = (float)2.0 * hlp * hlp2 - hlp1 + pq_coef[2]; hlp4 = (float)2.0 * hlp * hlp3 - hlp2 + pq_coef[3];
hlp4 = (float)2.0 * hlp * hlp3 - hlp2 + pq_coef[3]; hlp5 = hlp * hlp4 - hlp3 + pq_coef[4];
hlp5 = hlp * hlp4 - hlp3 + pq_coef[4];
if (((hlp5 * (*old)) <= 0.0) || (omega >= 0.5)){
if (((hlp5 * (*old)) <= 0.0) || (omega >= 0.5)){
if (step_idx == (LSF_NUMBER_OF_STEPS - 1)){
if (step_idx == (LSF_NUMBER_OF_STEPS - 1)){
if (fabs(hlp5) >= fabs(*old)) {
if (fabs(hlp5) >= fabs(*old)) { freq[lsp_index] = omega - step;
freq[lsp_index] = omega - step; } else {
} else { freq[lsp_index] = omega;
freq[lsp_index] = omega; }
}
if ((*old) >= 0.0){
if ((*old) >= 0.0){ *old = (float)-1.0 * FLOAT_MAX;
*old = (float)-1.0 * FLOAT_MAX; } else {
} else { *old = FLOAT_MAX;
*old = FLOAT_MAX; }
}
omega = old_omega;
omega = old_omega; step_idx = 0;
step_idx = 0;
step_idx = LSF_NUMBER_OF_STEPS;
step_idx = LSF_NUMBER_OF_STEPS; } else {
} else {
if (step_idx == 0) {
if (step_idx == 0) { old_omega = omega;
old_omega = omega; }
}
step_idx++;
step_idx++; omega -= steps[step_idx];
omega -= steps[step_idx];
/* Go back one grid step */
/* Go back one grid step */
step = steps[step_idx];
step = steps[step_idx]; }
} } else {
} else {
/* increment omega until they are of different sign,
/* increment omega until they are of different sign, and we know there is at least one root between omega
and we know there is at least one root between omega and old_omega */
and old_omega */ *old = hlp5;
*old = hlp5; omega += step;
omega += step; }
}
}
} }
}
for (i = 0; i<LPC_FILTERORDER; i++) {
for (i = 0; i<LPC_FILTERORDER; i++) { freq[i] = freq[i] * TWO_PI;
freq[i] = freq[i] * TWO_PI; }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * conversion from lsf coefficients to lpc coefficients
* conversion from lsf coefficients to lpc coefficients *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void lsf2a(
void lsf2a( float *a_coef, /* (o) lpc coefficients */
float *a_coef, /* (o) lpc coefficients */ float *freq /* (i) lsf coefficients */
float *freq /* (i) lsf coefficients */ ){
){ int i, j;
int i, j; float hlp;
float hlp; float p[LPC_HALFORDER], q[LPC_HALFORDER];
float p[LPC_HALFORDER], q[LPC_HALFORDER]; float a[LPC_HALFORDER + 1], a1[LPC_HALFORDER],
float a[LPC_HALFORDER + 1], a1[LPC_HALFORDER], a2[LPC_HALFORDER];
a2[LPC_HALFORDER]; float b[LPC_HALFORDER + 1], b1[LPC_HALFORDER],
float b[LPC_HALFORDER + 1], b1[LPC_HALFORDER], b2[LPC_HALFORDER];
b2[LPC_HALFORDER];
for (i=0; i<LPC_FILTERORDER; i++) {
for (i=0; i<LPC_FILTERORDER; i++) { freq[i] = freq[i] * PI2;
freq[i] = freq[i] * PI2; }
}
/* Check input for ill-conditioned cases. This part is not
/* Check input for ill-conditioned cases. This part is not found in the TIA standard. It involves the following 2 IF
found in the TIA standard. It involves the following 2 IF blocks. If "freq" is judged ill-conditioned, then we first
blocks. If "freq" is judged ill-conditioned, then we first modify freq[0] and freq[LPC_HALFORDER-1] (normally
modify freq[0] and freq[LPC_HALFORDER-1] (normally LPC_HALFORDER = 10 for LPC applications), then we adjust
LPC_HALFORDER = 10 for LPC applications), then we adjust the other "freq" values slightly */
the other "freq" values slightly */
if ((freq[0] <= 0.0) || (freq[LPC_FILTERORDER - 1] >= 0.5)){
if ((freq[0] <= 0.0) || (freq[LPC_FILTERORDER - 1] >= 0.5)){
if (freq[0] <= 0.0) {
if (freq[0] <= 0.0) { freq[0] = (float)0.022;
freq[0] = (float)0.022; }
}
if (freq[LPC_FILTERORDER - 1] >= 0.5) {
if (freq[LPC_FILTERORDER - 1] >= 0.5) { freq[LPC_FILTERORDER - 1] = (float)0.499;
freq[LPC_FILTERORDER - 1] = (float)0.499; }
}
hlp = (freq[LPC_FILTERORDER - 1] - freq[0]) /
hlp = (freq[LPC_FILTERORDER - 1] - freq[0]) / (float) (LPC_FILTERORDER - 1);
(float) (LPC_FILTERORDER - 1);
for (i=1; i<LPC_FILTERORDER; i++) {
for (i=1; i<LPC_FILTERORDER; i++) { freq[i] = freq[i - 1] + hlp;
freq[i] = freq[i - 1] + hlp; }
}
}
}
memset(a1, 0, LPC_HALFORDER*sizeof(float));
memset(a1, 0, LPC_HALFORDER*sizeof(float)); memset(a2, 0, LPC_HALFORDER*sizeof(float));
memset(a2, 0, LPC_HALFORDER*sizeof(float)); memset(b1, 0, LPC_HALFORDER*sizeof(float));
memset(b1, 0, LPC_HALFORDER*sizeof(float)); memset(b2, 0, LPC_HALFORDER*sizeof(float));
memset(b2, 0, LPC_HALFORDER*sizeof(float)); memset(a, 0, (LPC_HALFORDER+1)*sizeof(float));
memset(a, 0, (LPC_HALFORDER+1)*sizeof(float)); memset(b, 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
/* 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.
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
Note that for this code p[i] specifies the coefficients used in .Q_A(z) while q[i] specifies the coefficients used
used in .Q_A(z) while q[i] specifies the coefficients used in .P_A(z) */
in .P_A(z) */
for (i=0; i<LPC_HALFORDER; i++) {
for (i=0; i<LPC_HALFORDER; i++) { p[i] = (float)cos(TWO_PI * freq[2 * i]);
p[i] = (float)cos(TWO_PI * freq[2 * i]); q[i] = (float)cos(TWO_PI * freq[2 * i + 1]);
q[i] = (float)cos(TWO_PI * freq[2 * i + 1]); }
}
a[0] = 0.25;
a[0] = 0.25; b[0] = 0.25;
b[0] = 0.25;
for (i= 0; i<LPC_HALFORDER; i++) {
for (i= 0; i<LPC_HALFORDER; i++) { a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[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];
b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i]; a2[i] = a1[i];
a2[i] = a1[i]; a1[i] = a[i];
a1[i] = a[i]; b2[i] = b1[i];
b2[i] = b1[i]; b1[i] = b[i];
b1[i] = b[i]; }
}
for (j=0; j<LPC_FILTERORDER; j++) {
for (j=0; j<LPC_FILTERORDER; j++) {
if (j == 0) {
if (j == 0) { a[0] = 0.25;
a[0] = 0.25; b[0] = -0.25;
b[0] = -0.25; } else {
} else { a[0] = b[0] = 0.0;
a[0] = b[0] = 0.0; }
}
for (i=0; i<LPC_HALFORDER; i++) {
for (i=0; i<LPC_HALFORDER; i++) { a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[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];
b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i]; a2[i] = a1[i];
a2[i] = a1[i]; a1[i] = a[i];
a1[i] = a[i]; b2[i] = b1[i];
b2[i] = b1[i]; b1[i] = b[i];
b1[i] = b[i]; }
}
a_coef[j + 1] = 2 * (a[LPC_HALFORDER] + b[LPC_HALFORDER]);
a_coef[j + 1] = 2 * (a[LPC_HALFORDER] + b[LPC_HALFORDER]); }
}
a_coef[0] = 1.0;
a_coef[0] = 1.0;
}
}

60
libs/codec/ilbc/lsf.h
View File

@ -1,30 +1,30 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
lsf.h lsf.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_LSF_H #ifndef __iLBC_LSF_H
#define __iLBC_LSF_H #define __iLBC_LSF_H
void a2lsf( void a2lsf(
float *freq,/* (o) lsf coefficients */ float *freq,/* (o) lsf coefficients */
float *a /* (i) lpc coefficients */ float *a /* (i) lpc coefficients */
); );
void lsf2a( void lsf2a(
float *a_coef, /* (o) lpc coefficients */ float *a_coef, /* (o) lpc coefficients */
float *freq /* (i) lsf coefficients */ float *freq /* (i) lsf coefficients */
); );
#endif #endif

349
libs/codec/ilbc/packing.c
View File

@ -1,175 +1,174 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
packing.c packing.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include "iLBC_define.h" #include "iLBC_define.h"
#include "constants.h" #include "constants.h"
#include "helpfun.h" #include "helpfun.h"
#include "packing.h" #include "string.h"
#include "string.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * splitting an integer into first most significant bits and
* splitting an integer into first most significant bits and * remaining least significant bits
* remaining least significant bits *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void packsplit(
void packsplit( int *index, /* (i) the value to split */
int *index, /* (i) the value to split */ int *firstpart, /* (o) the value specified by most
int *firstpart, /* (o) the value specified by most significant bits */
significant bits */ int *rest, /* (o) the value specified by least
int *rest, /* (o) the value specified by least significant bits */
significant bits */ int bitno_firstpart, /* (i) number of bits in most
int bitno_firstpart, /* (i) number of bits in most significant part */
significant part */ int bitno_total /* (i) number of bits in full range
int bitno_total /* (i) number of bits in full range of value */
of value */ ){
){ int bitno_rest = bitno_total-bitno_firstpart;
int bitno_rest = bitno_total-bitno_firstpart;
*firstpart = *index>>(bitno_rest);
*firstpart = *index>>(bitno_rest); *rest = *index-(*firstpart<<(bitno_rest));
*rest = *index-(*firstpart<<(bitno_rest)); }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * combining a value corresponding to msb's with a value
* combining a value corresponding to msb's with a value * corresponding to lsb's
* corresponding to lsb's *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void packcombine(
void packcombine( int *index, /* (i/o) the msb value in the
int *index, /* (i/o) the msb value in the combined value out */
combined value out */ int rest, /* (i) the lsb value */
int rest, /* (i) the lsb value */ int bitno_rest /* (i) the number of bits in the
int bitno_rest /* (i) the number of bits in the lsb part */
lsb part */ ){
){ *index = *index<<bitno_rest;
*index = *index<<bitno_rest; *index += rest;
*index += rest; }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * packing of bits into bitstream, i.e., vector of bytes
* packing of bits into bitstream, i.e., vector of bytes *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void dopack(
void dopack( unsigned char **bitstream, /* (i/o) on entrance pointer to
unsigned char **bitstream, /* (i/o) on entrance pointer to place in bitstream to pack
place in bitstream to pack new data, on exit pointer
new data, on exit pointer to place in bitstream to
to place in bitstream to pack future data */
pack future data */ int index, /* (i) the value to pack */
int index, /* (i) the value to pack */ int bitno, /* (i) the number of bits that the
int bitno, /* (i) the number of bits that the value will fit within */
value will fit within */ int *pos /* (i/o) write position in the
int *pos /* (i/o) write position in the current byte */
current byte */ ){
){ int posLeft;
int posLeft;
/* Clear the bits before starting in a new byte */
/* Clear the bits before starting in a new byte */
if ((*pos)==0) {
if ((*pos)==0) { **bitstream=0;
**bitstream=0; }
}
while (bitno>0) {
while (bitno>0) {
/* Jump to the next byte if end of this byte is reached*/
/* Jump to the next byte if end of this byte is reached*/
if (*pos==8) {
if (*pos==8) { *pos=0;
*pos=0; (*bitstream)++;
(*bitstream)++; **bitstream=0;
**bitstream=0; }
}
posLeft=8-(*pos);
posLeft=8-(*pos);
/* Insert index into the bitstream */
/* Insert index into the bitstream */
if (bitno <= posLeft) {
if (bitno <= posLeft) { **bitstream |= (unsigned char)(index<<(posLeft-bitno));
**bitstream |= (unsigned char)(index<<(posLeft-bitno)); *pos+=bitno;
*pos+=bitno; bitno=0;
bitno=0; } else {
} else { **bitstream |= (unsigned char)(index>>(bitno-posLeft));
**bitstream |= (unsigned char)(index>>(bitno-posLeft));
*pos=8;
*pos=8; index-=((index>>(bitno-posLeft))<<(bitno-posLeft));
index-=((index>>(bitno-posLeft))<<(bitno-posLeft));
bitno-=posLeft;
bitno-=posLeft; }
} }
} }
}
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * unpacking of bits from bitstream, i.e., vector of bytes
* unpacking of bits from bitstream, i.e., vector of bytes *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void unpack(
void unpack( unsigned char **bitstream, /* (i/o) on entrance pointer to
unsigned char **bitstream, /* (i/o) on entrance pointer to place in bitstream to
place in bitstream to unpack new data from, on
unpack new data from, on exit pointer to place in
exit pointer to place in bitstream to unpack future
bitstream to unpack future data from */
data from */ int *index, /* (o) resulting value */
int *index, /* (o) resulting value */ int bitno, /* (i) number of bits used to
int bitno, /* (i) number of bits used to represent the value */
represent the value */ int *pos /* (i/o) read position in the
int *pos /* (i/o) read position in the current byte */
current byte */ ){
){ int BitsLeft;
int BitsLeft;
*index=0;
*index=0;
while (bitno>0) {
while (bitno>0) {
/* move forward in bitstream when the end of the
/* move forward in bitstream when the end of the byte is reached */
byte is reached */
if (*pos==8) {
if (*pos==8) { *pos=0;
*pos=0; (*bitstream)++;
(*bitstream)++; }
}
BitsLeft=8-(*pos);
BitsLeft=8-(*pos);
/* Extract bits to index */
/* Extract bits to index */
if (BitsLeft>=bitno) {
if (BitsLeft>=bitno) { *index+=((((**bitstream)<<(*pos)) & 0xFF)>>(8-bitno));
*index+=((((**bitstream)<<(*pos)) & 0xFF)>>(8-bitno));
*pos+=bitno;
*pos+=bitno; bitno=0;
bitno=0; } else {
} else {
if ((8-bitno)>0) {
if ((8-bitno)>0) { *index+=((((**bitstream)<<(*pos)) & 0xFF)>>
*index+=((((**bitstream)<<(*pos)) & 0xFF)>> (8-bitno));
(8-bitno)); *pos=8;
*pos=8; } else {
} else { *index+=(((int)(((**bitstream)<<(*pos)) & 0xFF))<<
*index+=(((int)(((**bitstream)<<(*pos)) & 0xFF))<< (bitno-8));
(bitno-8)); *pos=8;
*pos=8; }
} bitno-=BitsLeft;
bitno-=BitsLeft; }
} }
} }
}

134
libs/codec/ilbc/packing.h
View File

@ -1,67 +1,67 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
packing.h packing.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __PACKING_H #ifndef __PACKING_H
#define __PACKING_H #define __PACKING_H
void packsplit( void packsplit(
int *index, /* (i) the value to split */ int *index, /* (i) the value to split */
int *firstpart, /* (o) the value specified by most int *firstpart, /* (o) the value specified by most
significant bits */ significant bits */
int *rest, /* (o) the value specified by least int *rest, /* (o) the value specified by least
significant bits */ significant bits */
int bitno_firstpart, /* (i) number of bits in most int bitno_firstpart, /* (i) number of bits in most
significant part */ significant part */
int bitno_total /* (i) number of bits in full range int bitno_total /* (i) number of bits in full range
of value */ of value */
); );
void packcombine( void packcombine(
int *index, /* (i/o) the msb value in the int *index, /* (i/o) the msb value in the
combined value out */ combined value out */
int rest, /* (i) the lsb value */ int rest, /* (i) the lsb value */
int bitno_rest /* (i) the number of bits in the int bitno_rest /* (i) the number of bits in the
lsb part */ lsb part */
); );
void dopack( void dopack(
unsigned char **bitstream, /* (i/o) on entrance pointer to unsigned char **bitstream, /* (i/o) on entrance pointer to
place in bitstream to pack place in bitstream to pack
new data, on exit pointer new data, on exit pointer
to place in bitstream to to place in bitstream to
pack future data */ pack future data */
int index, /* (i) the value to pack */ int index, /* (i) the value to pack */
int bitno, /* (i) the number of bits that the int bitno, /* (i) the number of bits that the
value will fit within */ value will fit within */
int *pos /* (i/o) write position in the int *pos /* (i/o) write position in the
current byte */ current byte */
); );
void unpack( void unpack(
unsigned char **bitstream, /* (i/o) on entrance pointer to unsigned char **bitstream, /* (i/o) on entrance pointer to
place in bitstream to place in bitstream to
unpack new data from, on unpack new data from, on
exit pointer to place in exit pointer to place in
bitstream to unpack future bitstream to unpack future
data from */ data from */
int *index, /* (o) resulting value */ int *index, /* (o) resulting value */
int bitno, /* (i) number of bits used to int bitno, /* (i) number of bits used to
represent the value */ represent the value */
int *pos /* (i/o) read position in the int *pos /* (i/o) read position in the
current byte */ current byte */
); );
#endif #endif

133
libs/codec/ilbc/syntFilter.c
View File

@ -1,70 +1,68 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
syntFilter.c syntFilter.c
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#include "iLBC_define.h" #include "iLBC_define.h"
#include "syntFilter.h"
/*----------------------------------------------------------------*
/*----------------------------------------------------------------* * LP synthesis filter.
* LP synthesis filter. *---------------------------------------------------------------*/
*---------------------------------------------------------------*/
void syntFilter(
void syntFilter( float *Out, /* (i/o) Signal to be filtered */
float *Out, /* (i/o) Signal to be filtered */ float *a, /* (i) LP parameters */
float *a, /* (i) LP parameters */ int len, /* (i) Length of signal */
int len, /* (i) Length of signal */ float *mem /* (i/o) Filter state */
float *mem /* (i/o) Filter state */ ){
){ int i, j;
int i, j; float *po, *pi, *pa, *pm;
float *po, *pi, *pa, *pm;
po=Out;
po=Out;
/* Filter first part using memory from past */
/* Filter first part using memory from past */
for (i=0; i<LPC_FILTERORDER; i++) {
for (i=0; i<LPC_FILTERORDER; i++) { pi=&Out[i-1];
pi=&Out[i-1]; pa=&a[1];
pa=&a[1]; pm=&mem[LPC_FILTERORDER-1];
pm=&mem[LPC_FILTERORDER-1]; for (j=1; j<=i; j++) {
for (j=1; j<=i; j++) { *po-=(*pa++)*(*pi--);
*po-=(*pa++)*(*pi--); }
} for (j=i+1; j<LPC_FILTERORDER+1; j++) {
for (j=i+1; j<LPC_FILTERORDER+1; j++) { *po-=(*pa++)*(*pm--);
*po-=(*pa++)*(*pm--); }
} po++;
po++; }
}
/* Filter last part where the state is entierly in
/* Filter last part where the state is entierly in the output vector */
the output vector */
for (i=LPC_FILTERORDER; i<len; i++) {
for (i=LPC_FILTERORDER; i<len; i++) {
pi=&Out[i-1];
pi=&Out[i-1]; pa=&a[1];
pa=&a[1]; for (j=1; j<LPC_FILTERORDER+1; j++) {
for (j=1; j<LPC_FILTERORDER+1; j++) { *po-=(*pa++)*(*pi--);
*po-=(*pa++)*(*pi--); }
} po++;
po++; }
}
/* Update state vector */
/* Update state vector */
memcpy(mem, &Out[len-LPC_FILTERORDER],
memcpy(mem, &Out[len-LPC_FILTERORDER], LPC_FILTERORDER*sizeof(float));
LPC_FILTERORDER*sizeof(float)); }
}
@ -105,4 +103,5 @@ void syntFilter(

54
libs/codec/ilbc/syntFilter.h
View File

@ -1,27 +1,27 @@
/****************************************************************** /******************************************************************
iLBC Speech Coder ANSI-C Source Code iLBC Speech Coder ANSI-C Source Code
syntFilter.h syntFilter.h
Copyright (C) The Internet Society (2004). Copyright (C) The Internet Society (2004).
All Rights Reserved. All Rights Reserved.
******************************************************************/ ******************************************************************/
#ifndef __iLBC_SYNTFILTER_H #ifndef __iLBC_SYNTFILTER_H
#define __iLBC_SYNTFILTER_H #define __iLBC_SYNTFILTER_H
void syntFilter( void syntFilter(
float *Out, /* (i/o) Signal to be filtered */ float *Out, /* (i/o) Signal to be filtered */
float *a, /* (i) LP parameters */ float *a, /* (i) LP parameters */
int len, /* (i) Length of signal */ int len, /* (i) Length of signal */
float *mem /* (i/o) Filter state */ float *mem /* (i/o) Filter state */
); );
#endif #endif

85
libs/codec/lpc10/Makefile
View File

@ -3,7 +3,7 @@
# #
# default C compiler # default C compiler
CC?= gcc CC= gcc
# #
# These definitions for CFLAGS and LIB_TARGET_DIR are used when one # These definitions for CFLAGS and LIB_TARGET_DIR are used when one
@ -14,62 +14,57 @@ CC?= gcc
# definitions. # definitions.
# #
LIB_TARGET_DIR = . LIB_TARGET_DIR = ..
# #
# -I$(LIB_TARGET_DIR) option needed so that #include "machine.h" # -I$(LIB_TARGET_DIR) option needed so that #include "machine.h"
# directives can find the machine.h file. # directives can find the machine.h file.
# #
WARNINGS = -Wall -Wno-comment -Wno-error WARNINGS = -Wall
CFLAGS += $(OPTIMIZE) -I$(LIB_TARGET_DIR) $(WARNINGS) CFLAGS = -O3 -I$(LIB_TARGET_DIR) $(WARNINGS)
ifneq (${OSARCH},CYGWIN)
CFLAGS += -fPIC
endif
#CFLAGS+= $(shell if uname -m | grep -q 86; then echo "-mpentium" ; fi)
#fix for PPC processors and ALPHA, And UltraSparc too
ifneq ($(OSARCH),Darwin)
ifneq ($(findstring BSD,${OSARCH}),BSD)
ifneq ($(PROC),ppc)
ifneq ($(PROC),x86_64)
ifneq ($(PROC),alpha)
#The problem with sparc is the best stuff is in newer versions of gcc (post 3.0) only.
#This works for even old (2.96) versions of gcc and provides a small boost either way.
#A ultrasparc cpu is really v9 but the stock debian stable 3.0 gcc doesn.t support it.
#So we go lowest common available by gcc and go a step down, still a step up from
#the default as we now have a better instruction set to work with. - Belgarath
ifeq ($(PROC),ultrasparc)
CFLAGS+= -mtune=$(PROC) -mcpu=v8 -O3 -fomit-frame-pointer
else
ifneq ($(OSARCH),SunOS)
ifneq ($(OSARCH),arm)
# CFLAGS+= -march=$(PROC)
endif
endif
endif
endif
endif
endif
endif
endif
LIB = $(LIB_TARGET_DIR)/liblpc10.a LIB = $(LIB_TARGET_DIR)/liblpc10.a
.PHONY: all clean .PHONY: all clean
all: $(LIB) all: $(LIB)
ranlib $(LIB)
OBJ= f2clib.o analys.o bsynz.o chanwr.o dcbias.o decode.o \ $(LIB): $(LIB)(f2clib.o) \
deemp.o difmag.o dyptrk.o encode.o energy.o ham84.o \ $(LIB)(analys.o) \
hp100.o invert.o irc2pc.o ivfilt.o lpcdec.o lpcenc.o \ $(LIB)(bsynz.o) \
lpcini.o lpfilt.o median.o mload.o onset.o pitsyn.o \ $(LIB)(chanwr.o) \
placea.o placev.o preemp.o prepro.o random.o rcchk.o \ $(LIB)(dcbias.o) \
synths.o tbdm.o voicin.o vparms.o $(LIB)(decode.o) \
$(LIB)(deemp.o) \
$(LIB): $(OBJ) $(LIB)(difmag.o) \
$(AR) cr $@ $(OBJ) $(LIB)(dyptrk.o) \
ranlib $@ $(LIB)(encode.o) \
$(LIB)(energy.o) \
$(LIB)(ham84.o) \
$(LIB)(hp100.o) \
$(LIB)(invert.o) \
$(LIB)(irc2pc.o) \
$(LIB)(ivfilt.o) \
$(LIB)(lpcdec.o) \
$(LIB)(lpcenc.o) \
$(LIB)(lpcini.o) \
$(LIB)(lpfilt.o) \
$(LIB)(median.o) \
$(LIB)(mload.o) \
$(LIB)(onset.o) \
$(LIB)(pitsyn.o) \
$(LIB)(placea.o) \
$(LIB)(placev.o) \
$(LIB)(preemp.o) \
$(LIB)(prepro.o) \
$(LIB)(random.o) \
$(LIB)(rcchk.o) \
$(LIB)(synths.o) \
$(LIB)(tbdm.o) \
$(LIB)(voicin.o) \
$(LIB)(vparms.o)
clean: clean:
-rm -f *.o $(LIB) -rm -f *.o

100
libs/codec/lpc10/analys.c
View File

@ -1,20 +1,14 @@
/* /*
$Log$ $Log: analys.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/09/19 01:20:22 markster Revision 1.2 2002/02/15 03:57:55 yurik
Code cleanups (bug #66) Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster Revision 1.1 2000/06/05 04:45:12 robertj
Code cleanups (bug #66) Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:16:01 jaf * Revision 1.2 1996/08/20 20:16:01 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,8 +24,6 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S #ifdef P_R_O_T_O_T_Y_P_E_S
extern int analys_(real *speech, integer *voice, integer *pitch, real *rms, real *rc, struct lpc10_encoder_state *st); extern int analys_(real *speech, integer *voice, integer *pitch, real *rms, real *rc, struct lpc10_encoder_state *st);
/* comlen contrl_ 12 */ /* comlen contrl_ 12 */
@ -60,6 +52,8 @@ extern int analys_(real *speech, integer *voice, integer *pitch, real *rms, real
-lf2c -lm (in that order) -lf2c -lm (in that order)
*/ */
#include "f2c.h"
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -87,21 +81,15 @@ static integer c__1 = 1;
/* ANALYS Version 55 */ /* ANALYS Version 55 */
/* $Log$ /* $Log: analys.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:16:01 jaf * Revision 1.2 1996/08/20 20:16:01 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -240,7 +228,11 @@ static integer c__1 = 1;
extern /* Subroutine */ int onset_(real *, integer *, integer *, integer * extern /* Subroutine */ int onset_(real *, integer *, integer *, integer *
, integer *, integer *, integer *, struct lpc10_encoder_state *); , integer *, integer *, integer *, struct lpc10_encoder_state *);
integer *osptr; integer *osptr;
extern int dcbias_(integer *, real *, real *); extern /* Subroutine */ placea_(integer *, integer *
, integer *, integer *, integer *, integer *, integer *, integer *
, integer *), dcbias_(integer *, real *, real *), placev_(integer
*, integer *, integer *, integer *, integer *, integer *, integer
*, integer *, integer *, integer *, integer *);
integer ipitch; integer ipitch;
integer *obound; integer *obound;
extern /* Subroutine */ int preemp_(real *, real *, integer *, real *, extern /* Subroutine */ int preemp_(real *, real *, integer *, real *,
@ -259,21 +251,15 @@ static integer c__1 = 1;
*, integer *, integer *, struct lpc10_encoder_state *); *, integer *, integer *, struct lpc10_encoder_state *);
real phi[100] /* was [10][10] */, psi[10]; real phi[100] /* was [10][10] */, psi[10];
/* $Log$ /* $Log: analys.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:16:01 jaf * Revision 1.2 1996/08/20 20:16:01 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -299,21 +285,15 @@ static integer c__1 = 1;
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* Arguments to ANALYS */ /* Arguments to ANALYS */
/* $Log$ /* $Log: analys.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:16:01 jaf * Revision 1.2 1996/08/20 20:16:01 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -508,10 +488,10 @@ static integer c__1 = 1;
voibuf[0] = voibuf[2]; voibuf[0] = voibuf[2];
voibuf[1] = voibuf[3]; voibuf[1] = voibuf[3];
for (i__ = 1; i__ <= 2; ++i__) { for (i__ = 1; i__ <= 2; ++i__) {
vwin[(i__ << 1) - 2] = vwin[((i__ + 1) << 1) - 2] - contrl_1.lframe; vwin[(i__ << 1) - 2] = vwin[(i__ + (1 << 1)) - 2] - contrl_1.lframe;
vwin[(i__ << 1) - 1] = vwin[((i__ + 1) << 1) - 1] - contrl_1.lframe; vwin[(i__ << 1) - 1] = vwin[(i__ + (1 << 1)) - 1] - contrl_1.lframe;
awin[(i__ << 1) - 2] = awin[((i__ + 1) << 1) - 2] - contrl_1.lframe; awin[(i__ << 1) - 2] = awin[(i__ + (1 << 1)) - 2] - contrl_1.lframe;
awin[(i__ << 1) - 1] = awin[((i__ + 1) << 1) - 1] - contrl_1.lframe; awin[(i__ << 1) - 1] = awin[(i__ + (1 << 1)) - 1] - contrl_1.lframe;
/* EWIN(*,J) is unused for J .NE. AF, so the following shift is /* EWIN(*,J) is unused for J .NE. AF, so the following shift is
*/ */
/* unnecessary. It also causes error messages when the C versio /* unnecessary. It also causes error messages when the C versio
@ -524,7 +504,7 @@ n */
/* EWIN(2,I) = EWIN(2,I+1) - LFRAME */ /* EWIN(2,I) = EWIN(2,I+1) - LFRAME */
obound[i__ - 1] = obound[i__]; obound[i__ - 1] = obound[i__];
voibuf[i__ * 2] = voibuf[(i__ + 1) * 2]; voibuf[i__ * 2] = voibuf[(i__ + 1) * 2];
voibuf[(i__ << 1) + 1] = voibuf[((i__ + 1) << 1) + 1]; voibuf[(i__ << 1) + 1] = voibuf[(i__ + (1 << 1)) + 1];
rmsbuf[i__ - 1] = rmsbuf[i__]; rmsbuf[i__ - 1] = rmsbuf[i__];
i__1 = contrl_1.order; i__1 = contrl_1.order;
for (j = 1; j <= i__1; ++j) { for (j = 1; j <= i__1; ++j) {

80
libs/codec/lpc10/bsynz.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: bsynz.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:14 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:14 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:18:55 jaf * Revision 1.2 1996/08/20 20:18:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -27,6 +24,12 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int bsynz_(real *coef, integer *ip, integer *iv, real *sout, real *rms, real *ratio, real *g2pass, struct lpc10_decoder_state *st);
/* comlen contrl_ 12 */
/*:ref: random_ 4 0 */
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -34,12 +37,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int bsynz_(real *coef, integer *ip, integer *iv, real *sout, real *rms, real *ratio, real *g2pass, struct lpc10_decoder_state *st);
/* comlen contrl_ 12 */
/*:ref: random_ 4 0 */
#endif
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -53,18 +50,15 @@ extern struct {
/* BSYNZ Version 54 */ /* BSYNZ Version 54 */
/* $Log$ /* $Log: bsynz.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.2 1996/08/20 20:18:55 jaf * Revision 1.2 1996/08/20 20:18:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -155,18 +149,15 @@ extern struct {
real xy, sum, ssq; real xy, sum, ssq;
real lpi0, hpi0; real lpi0, hpi0;
/* $Log$ /* $Log: bsynz.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.2 1996/08/20 20:18:55 jaf * Revision 1.2 1996/08/20 20:18:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -192,18 +183,15 @@ extern struct {
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: bsynz.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.2 1996/08/20 20:18:55 jaf * Revision 1.2 1996/08/20 20:18:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

37
libs/codec/lpc10/chanwr.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: chanwr.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:14 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:20:24 jaf * Revision 1.2 1996/08/20 20:20:24 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -24,6 +18,11 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int chanwr_(integer *order, integer *ipitv, integer *irms, integer *irc, integer *ibits, struct lpc10_encoder_state *st);
extern int chanrd_(integer *order, integer *ipitv, integer *irms, integer *irc, integer *ibits);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -35,18 +34,12 @@ Some OSS fixes and a few lpc changes to make it actually work
/* CHANL Version 49 */ /* CHANL Version 49 */
/* $Log$ /* $Log: chanwr.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:20:24 jaf * Revision 1.2 1996/08/20 20:20:24 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

40
libs/codec/lpc10/dcbias.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: dcbias.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:14 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:40:23 jaf * Revision 1.1 1996/08/19 22:40:23 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int dcbias_(integer *len, real *speech, real *sigout);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int dcbias_(integer *len, real *speech, real *sigout);
#endif
/* ********************************************************************* */ /* ********************************************************************* */
/* DCBIAS Version 50 */ /* DCBIAS Version 50 */
/* $Log$ /* $Log: dcbias.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:40:23 jaf * Revision 1.1 1996/08/19 22:40:23 jaf
* Initial revision * Initial revision

98
libs/codec/lpc10/decode.c
View File

@ -1,20 +1,14 @@
/* /*
$Log$ $Log: decode_.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/09/19 01:20:22 markster Revision 1.2 2002/02/15 03:57:55 yurik
Code cleanups (bug #66) Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster Revision 1.1 2000/06/05 04:45:12 robertj
Code cleanups (bug #66) Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:22:39 jaf * Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,13 +24,6 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S #ifdef P_R_O_T_O_T_Y_P_E_S
extern int decode_(integer *ipitv, integer *irms, integer *irc, integer *voice, integer *pitch, real *rms, real *rc, struct lpc10_decoder_state *st); extern int decode_(integer *ipitv, integer *irms, integer *irc, integer *voice, integer *pitch, real *rms, real *rc, struct lpc10_decoder_state *st);
/* comlen contrl_ 12 */ /* comlen contrl_ 12 */
@ -44,6 +31,13 @@ extern int decode_(integer *ipitv, integer *irms, integer *irc, integer *voice,
/*:ref: median_ 4 3 4 4 4 */ /*:ref: median_ 4 3 4 4 4 */
#endif #endif
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -61,21 +55,15 @@ static integer c__2 = 2;
/* DECODE Version 54 */ /* DECODE Version 54 */
/* $Log$ /* $Log: decode_.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:22:39 jaf * Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -205,21 +193,15 @@ static integer c__2 = 2;
extern integer median_(integer *, integer *, integer *); extern integer median_(integer *, integer *, integer *);
integer ishift, errcnt, lsb; integer ishift, errcnt, lsb;
/* $Log$ /* $Log: decode_.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:22:39 jaf * Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -245,21 +227,15 @@ static integer c__2 = 2;
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: decode_.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:22:39 jaf * Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -542,9 +518,9 @@ static integer c__2 = 2;
} }
for (i__ = 1; i__ <= 6; ++i__) { for (i__ = 1; i__ <= 6; ++i__) {
if ((i__1 = drc[i__ * 3 - 2] - drc[i__ * 3 - 3], (real) abs(i__1)) if ((i__1 = drc[i__ * 3 - 2] - drc[i__ * 3 - 3], (real) abs(i__1))
>= corth[ixcor + ((i__ + 2) << 2) - 5] && (i__2 = drc[i__ * >= corth[ixcor + (i__ + (2 << 2)) - 5] && (i__2 = drc[i__ *
3 - 2] - drc[i__ * 3 - 1], (real) abs(i__2)) >= corth[ 3 - 2] - drc[i__ * 3 - 1], (real) abs(i__2)) >= corth[
ixcor + ((i__ + 2) << 2) - 5]) { ixcor + (i__ + (2 << 2)) - 5]) {
irc[i__] = median_(&drc[i__ * 3 - 1], &drc[i__ * 3 - 2], &drc[ irc[i__] = median_(&drc[i__ * 3 - 1], &drc[i__ * 3 - 2], &drc[
i__ * 3 - 3]); i__ * 3 - 3]);
} }

40
libs/codec/lpc10/deemp.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: deemp.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:14 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:23:46 jaf * Revision 1.2 1996/08/20 20:23:46 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -27,6 +21,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int deemp_(real *x, integer *n, struct lpc10_decoder_state *st);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -34,26 +32,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int deemp_(real *x, integer *n, struct lpc10_decoder_state *st);
#endif
/* ***************************************************************** */ /* ***************************************************************** */
/* DEEMP Version 48 */ /* DEEMP Version 48 */
/* $Log$ /* $Log: deemp.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:23:46 jaf * Revision 1.2 1996/08/20 20:23:46 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

40
libs/codec/lpc10/difmag.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: difmag.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:14 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:32:31 jaf * Revision 1.1 1996/08/19 22:32:31 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int difmag_(real *speech, integer *lpita, integer *tau, integer *ltau, integer *maxlag, real *amdf, integer *minptr, integer *maxptr);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int difmag_(real *speech, integer *lpita, integer *tau, integer *ltau, integer *maxlag, real *amdf, integer *minptr, integer *maxptr);
#endif
/* ********************************************************************** */ /* ********************************************************************** */
/* DIFMAG Version 49 */ /* DIFMAG Version 49 */
/* $Log$ /* $Log: difmag.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:32:31 jaf * Revision 1.1 1996/08/19 22:32:31 jaf
* Initial revision * Initial revision

58
libs/codec/lpc10/dyptrk.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: dyptrk.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:25:29 jaf * Revision 1.2 1996/08/20 20:25:29 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -27,6 +21,11 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int dyptrk_(real *amdf, integer *ltau, integer *minptr, integer *voice, integer *pitch, integer *midx, struct lpc10_encoder_state *st);
/* comlen contrl_ 12 */
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -34,11 +33,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int dyptrk_(real *amdf, integer *ltau, integer *minptr, integer *voice, integer *pitch, integer *midx, struct lpc10_encoder_state *st);
/* comlen contrl_ 12 */
#endif
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -52,18 +46,12 @@ extern struct {
/* DYPTRK Version 52 */ /* DYPTRK Version 52 */
/* $Log$ /* $Log: dyptrk.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:25:29 jaf * Revision 1.2 1996/08/20 20:25:29 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -147,18 +135,12 @@ extern struct {
real alpha, minsc, maxsc; real alpha, minsc, maxsc;
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: dyptrk.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:25:29 jaf * Revision 1.2 1996/08/20 20:25:29 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

78
libs/codec/lpc10/encode.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: encode_.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:32:21 jaf * Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision * Initial revision
@ -19,6 +16,11 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int encode_(integer *voice, integer *pitch, real *rms, real *rc, integer *ipitch, integer *irms, integer *irc);
/* comlen contrl_ 12 */
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,11 +28,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int encode_(integer *voice, integer *pitch, real *rms, real *rc, integer *ipitch, integer *irms, integer *irc);
/* comlen contrl_ 12 */
#endif
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -48,18 +45,15 @@ static integer c__2 = 2;
/* ENCODE Version 54 */ /* ENCODE Version 54 */
/* $Log$ /* $Log: encode_.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:32:21 jaf * Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision * Initial revision
@ -139,18 +133,15 @@ static integer c__2 = 2;
/* Local variables */ /* Local variables */
integer idel, nbit, i__, j, i2, i3, mrk; integer idel, nbit, i__, j, i2, i3, mrk;
/* $Log$ /* $Log: encode_.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:32:21 jaf * Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision * Initial revision
@ -168,18 +159,15 @@ static integer c__2 = 2;
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: encode_.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:32:21 jaf * Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision * Initial revision

42
libs/codec/lpc10/energy.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: energy.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:32:17 jaf * Revision 1.1 1996/08/19 22:32:17 jaf
* Initial revision * Initial revision
@ -19,6 +16,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int energy_(integer *len, real *speech, real *rms);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +27,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int energy_(integer *len, real *speech, real *rms);
#endif
/* ********************************************************************* */ /* ********************************************************************* */
/* ENERGY Version 50 */ /* ENERGY Version 50 */
/* $Log$ /* $Log: energy.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:32:17 jaf * Revision 1.1 1996/08/19 22:32:17 jaf
* Initial revision * Initial revision

105
libs/codec/lpc10/f2c.h
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: f2c.h,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:26:28 jaf * Revision 1.2 1996/08/20 20:26:28 jaf
* Any typedef defining a type that was used in lpc10_encoder_state or * Any typedef defining a type that was used in lpc10_encoder_state or
@ -215,17 +209,17 @@ typedef shortlogical (*K_fp)(...);
typedef /* Character */ VOID (*H_fp)(...); typedef /* Character */ VOID (*H_fp)(...);
typedef /* Subroutine */ int (*S_fp)(...); typedef /* Subroutine */ int (*S_fp)(...);
#else #else
typedef int /* Unknown procedure type */ (*U_fp)(VOID); typedef int /* Unknown procedure type */ (*U_fp)();
typedef shortint (*J_fp)(VOID); typedef shortint (*J_fp)();
typedef integer (*I_fp)(VOID); typedef integer (*I_fp)();
typedef real (*R_fp)(VOID); typedef real (*R_fp)();
typedef doublereal (*D_fp)(VOID), (*E_fp)(VOID); typedef doublereal (*D_fp)(), (*E_fp)();
typedef /* Complex */ VOID (*C_fp)(VOID); typedef /* Complex */ VOID (*C_fp)();
typedef /* Double Complex */ VOID (*Z_fp)(VOID); typedef /* Double Complex */ VOID (*Z_fp)();
typedef logical (*L_fp)(VOID); typedef logical (*L_fp)();
typedef shortlogical (*K_fp)(VOID); typedef shortlogical (*K_fp)();
typedef /* Character */ VOID (*H_fp)(VOID); typedef /* Character */ VOID (*H_fp)();
typedef /* Subroutine */ int (*S_fp)(VOID); typedef /* Subroutine */ int (*S_fp)();
#endif #endif
/* E_fp is for real functions when -R is not specified */ /* E_fp is for real functions when -R is not specified */
typedef VOID C_f; /* complex function */ typedef VOID C_f; /* complex function */
@ -255,71 +249,4 @@ typedef doublereal E_f; /* real function with -R not specified */
#undef unix #undef unix
#undef vax #undef vax
#endif #endif
#ifdef KR_headers
extern integer pow_ii(ap, bp);
extern double r_sign(a,b);
extern integer i_nint(x);
#else
extern integer pow_ii(integer *ap, integer *bp);
extern double r_sign(real *a, real *b);
extern integer i_nint(real *x);
#endif #endif
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int bsynz_(real *coef, integer *ip, integer *iv,
real *sout, real *rms, real *ratio, real *g2pass,
struct lpc10_decoder_state *st);
extern int chanwr_(integer *order, integer *ipitv, integer *irms,
integer *irc, integer *ibits, struct lpc10_encoder_state *st);
extern int chanrd_(integer *order, integer *ipitv, integer *irms,
integer *irc, integer *ibits);
extern int chanwr_0_(int n__, integer *order, integer *ipitv,
integer *irms, integer *irc, integer *ibits,
struct lpc10_encoder_state *st);
extern int dcbias_(integer *len, real *speech, real *sigout);
extern int decode_(integer *ipitv, integer *irms, integer *irc,
integer *voice, integer *pitch, real *rms,
real *rc, struct lpc10_decoder_state *st);
extern int deemp_(real *x, integer *n, struct lpc10_decoder_state *st);
extern int difmag_(real *speech, integer *lpita, integer *tau, integer *ltau,
integer *maxlag, real *amdf, integer *minptr, integer *maxptr);
extern int dyptrk_(real *amdf, integer *ltau, integer *
minptr, integer *voice, integer *pitch, integer *midx,
struct lpc10_encoder_state *st);
extern int encode_(integer *voice, integer *pitch, real *rms, real *rc,
integer *ipitch, integer *irms, integer *irc);
extern int energy_(integer *len, real *speech, real *rms);
extern int ham84_(integer *input, integer *output, integer *errcnt);
extern int hp100_(real *speech, integer *start, integer *end,
struct lpc10_encoder_state *st);
extern int inithp100_(void);
extern int invert_(integer *order, real *phi, real *psi, real *rc);
extern int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pass);
extern int ivfilt_(real *lpbuf, real *ivbuf, integer *len, integer *nsamp, real *ivrc);
extern int lpcdec_(integer *bits, real *speech);
extern int initlpcdec_(void);
extern int lpcenc_(real *speech, integer *bits);
extern int initlpcenc_(void);
extern int lpfilt_(real *inbuf, real *lpbuf, integer *len, integer *nsamp);
extern integer median_(integer *d1, integer *d2, integer *d3);
extern int mload_(integer *order, integer *awins, integer *awinf, real *speech, real *phi, real *psi);
extern int onset_(real *pebuf, integer *osbuf, integer *osptr, integer *oslen, integer *sbufl, integer *sbufh, integer *lframe, struct lpc10_encoder_state *st);
extern int pitsyn_(integer *order, integer *voice, integer *pitch, real *rms, real *rc, integer *lframe, integer *ivuv, integer *ipiti, real *rmsi, real *rci, integer *nout, real *ratio, struct lpc10_decoder_state *st);
extern int placea_(integer *ipitch, integer *voibuf, integer *obound, integer *af, integer *vwin, integer *awin, integer *ewin, integer *lframe, integer *maxwin);
extern int placev_(integer *osbuf, integer *osptr, integer *oslen, integer *obound, integer *vwin, integer *af, integer *lframe, integer *minwin, integer *maxwin, integer *dvwinl, integer *dvwinh);
extern int preemp_(real *inbuf, real *pebuf, integer *nsamp, real *coef, real *z__);
extern int prepro_(real *speech, integer *length,
struct lpc10_encoder_state *st);
extern int decode_(integer *ipitv, integer *irms, integer *irc, integer *voice, integer *pitch, real *rms, real *rc, struct lpc10_decoder_state *st);
extern integer random_(struct lpc10_decoder_state *st);
extern int rcchk_(integer *order, real *rc1f, real *rc2f);
extern int synths_(integer *voice, integer *pitch, real *rms, real *rc, real *speech, integer *k, struct lpc10_decoder_state *st);
extern int tbdm_(real *speech, integer *lpita, integer *tau, integer *ltau, real *amdf, integer *minptr, integer *maxptr, integer *mintau);
extern int voicin_(integer *vwin, real *inbuf, real *lpbuf, integer *buflim, integer *half, real *minamd, real *maxamd, integer *mintau, real *ivrc, integer *obound, integer *voibuf, integer *af, struct lpc10_encoder_state *st);
extern int vparms_(integer *vwin, real *inbuf, real *lpbuf, integer *buflim, integer *half, real *dither, integer *mintau, integer *zc, integer *lbe, integer *fbe, real *qs, real *rc1, real *ar_b__, real *ar_f__);
#endif
#endif /* ! defined F2C_INCLUDE */

26
libs/codec/lpc10/f2clib.c
View File

@ -1,14 +1,20 @@
/* /*
$Log$ $Log: f2clib.c,v $
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2004/05/05 13:25:38 rjongbloed
mer feb 12 14:56:57 CET 2003 Fixed clearly incorrect code (dived by zero) found with an MSVC warning
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2004/05/04 11:16:42 csoutheren
mer feb 12 14:56:57 CET 2003 Initial version
Revision 1.2 2000/01/05 08:20:39 markster Revision 1.3 2004/02/17 09:21:45 csoutheren
Some OSS fixes and a few lpc changes to make it actually work Fix for GM bug 134591
Revision 1.2 2002/02/15 03:57:55 yurik
Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:32:10 jaf * Revision 1.1 1996/08/19 22:32:10 jaf
* Initial revision * Initial revision
@ -40,7 +46,7 @@ integer pow_ii(integer *ap, integer *bp)
if (n == 0 || x == 1) if (n == 0 || x == 1)
return 1; return 1;
if (x != -1) if (x != -1)
return x == 0 ? 0 : 1/x; return x != 0 ? 1/x : 0;
n = -n; n = -n;
} }
u = n; u = n;
@ -80,6 +86,6 @@ integer i_nint(x) real *x;
integer i_nint(real *x) integer i_nint(real *x)
#endif #endif
{ {
return( (integer)((*x)>=0 ? return (integer)( (*x)>=0 ?
floor(*x + .5) : -floor(.5 - *x)) ); floor(*x + .5) : -(floor(.5 - *x)) );
} }

40
libs/codec/lpc10/ham84.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: ham84.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:32:07 jaf * Revision 1.1 1996/08/19 22:32:07 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int ham84_(integer *input, integer *output, integer *errcnt);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int ham84_(integer *input, integer *output, integer *errcnt);
#endif
/* ***************************************************************** */ /* ***************************************************************** */
/* HAM84 Version 45G */ /* HAM84 Version 45G */
/* $Log$ /* $Log: ham84.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:32:07 jaf * Revision 1.1 1996/08/19 22:32:07 jaf
* Initial revision * Initial revision

44
libs/codec/lpc10/hp100.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: hp100.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:28:05 jaf * Revision 1.2 1996/08/20 20:28:05 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -27,6 +21,12 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int hp100_(real *speech, integer *start, integer *end,
struct lpc10_encoder_state *st);
extern int inithp100_(void);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -34,28 +34,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int hp100_(real *speech, integer *start, integer *end,
struct lpc10_encoder_state *st);
extern int inithp100_(void);
#endif
/* ********************************************************************* */ /* ********************************************************************* */
/* HP100 Version 55 */ /* HP100 Version 55 */
/* $Log$ /* $Log: hp100.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:28:05 jaf * Revision 1.2 1996/08/20 20:28:05 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

56
libs/codec/lpc10/invert.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: invert.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:42 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:32:00 jaf * Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int invert_(integer *order, real *phi, real *psi, real *rc);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int invert_(integer *order, real *phi, real *psi, real *rc);
#endif
/* **************************************************************** */ /* **************************************************************** */
/* INVERT Version 45G */ /* INVERT Version 45G */
/* $Log$ /* $Log: invert.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:32:00 jaf * Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision * Initial revision
@ -102,18 +90,12 @@ extern int invert_(integer *order, real *phi, real *psi, real *rc);
real v[100] /* was [10][10] */; real v[100] /* was [10][10] */;
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: invert.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:42 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:32:00 jaf * Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision * Initial revision

61
libs/codec/lpc10/irc2pc.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: irc2pc.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:56 jaf * Revision 1.1 1996/08/19 22:31:56 jaf
* Initial revision * Initial revision
@ -19,6 +16,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pass);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +27,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pass);
#endif
/* ***************************************************************** */ /* ***************************************************************** */
/* IRC2PC Version 48 */ /* IRC2PC Version 48 */
/* $Log$ /* $Log: irc2pc.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:31:56 jaf * Revision 1.1 1996/08/19 22:31:56 jaf
* Initial revision * Initial revision
@ -93,18 +87,15 @@ extern int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pas
integer i__, j; integer i__, j;
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: irc2pc.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:31:56 jaf * Revision 1.1 1996/08/19 22:31:56 jaf
* Initial revision * Initial revision
@ -132,7 +123,7 @@ extern int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pas
for (i__ = 1; i__ <= i__1; ++i__) { for (i__ = 1; i__ <= i__1; ++i__) {
*g2pass *= 1.f - rc[i__] * rc[i__]; *g2pass *= 1.f - rc[i__] * rc[i__];
} }
*g2pass = *gprime * (real)sqrt(*g2pass); *g2pass = (real)(*gprime * sqrt(*g2pass));
pc[1] = rc[1]; pc[1] = rc[1];
i__1 = *order; i__1 = *order;
for (i__ = 2; i__ <= i__1; ++i__) { for (i__ = 2; i__ <= i__1; ++i__) {

50
libs/codec/lpc10/ivfilt.c
View File

@ -1,20 +1,14 @@
/* /*
$Log$ $Log: ivfilt.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/09/19 01:20:22 markster Revision 1.2 2002/02/15 03:57:55 yurik
Code cleanups (bug #66) Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster Revision 1.1 2000/06/05 04:45:12 robertj
Code cleanups (bug #66) Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:53 jaf * Revision 1.1 1996/08/19 22:31:53 jaf
* Initial revision * Initial revision
@ -22,6 +16,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int ivfilt_(real *lpbuf, real *ivbuf, integer *len, integer *nsamp, real *ivrc);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -29,29 +27,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int ivfilt_(real *lpbuf, real *ivbuf, integer *len, integer *nsamp, real *ivrc);
#endif
/* ********************************************************************* */ /* ********************************************************************* */
/* IVFILT Version 48 */ /* IVFILT Version 48 */
/* $Log$ /* $Log: ivfilt.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2002/02/15 03:57:55 yurik
/* Code cleanups (bug #66) /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:31:53 jaf * Revision 1.1 1996/08/19 22:31:53 jaf
* Initial revision * Initial revision
@ -109,7 +97,7 @@ extern int ivfilt_(real *lpbuf, real *ivbuf, integer *len, integer *nsamp, real
/* Function Body */ /* Function Body */
for (i__ = 1; i__ <= 3; ++i__) { for (i__ = 1; i__ <= 3; ++i__) {
r__[i__ - 1] = 0.f; r__[i__ - 1] = 0.f;
k = (i__ - 1) << 2; k = i__ - (1 << 2);
i__1 = *len; i__1 = *len;
for (j = (i__ << 2) + *len - *nsamp; j <= i__1; j += 2) { for (j = (i__ << 2) + *len - *nsamp; j <= i__1; j += 2) {
r__[i__ - 1] += lpbuf[j] * lpbuf[j - k]; r__[i__ - 1] += lpbuf[j] * lpbuf[j - k];

5
libs/codec/lpc10/liblpc10.vcproj
View File

@ -4,6 +4,7 @@
Version="8.00" Version="8.00"
Name="liblpc10" Name="liblpc10"
ProjectGUID="{FF1D238A-9D59-4850-838E-78182E05736B}" ProjectGUID="{FF1D238A-9D59-4850-838E-78182E05736B}"
RootNamespace="liblpc10"
Keyword="Win32Proj" Keyword="Win32Proj"
> >
<Platforms> <Platforms>
@ -38,7 +39,7 @@
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB;P_R_O_T_O_T_Y_P_E_S" PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
MinimalRebuild="true" MinimalRebuild="true"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
RuntimeLibrary="3" RuntimeLibrary="3"
@ -98,7 +99,7 @@
/> />
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB;P_R_O_T_O_T_Y_P_E_S" PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
RuntimeLibrary="2" RuntimeLibrary="2"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
WarningLevel="3" WarningLevel="3"

59
libs/codec/lpc10/lpc10.h
View File

@ -1,26 +1,11 @@
/* /*
$Log$ $Log: lpc10.h,v $
Revision 1.18 2004/08/31 13:32:11 markster Revision 1.1 2004/05/04 11:30:49 csoutheren
Merge NetBSD and Courtesty tone with modifications (bug #2329) Initial version
Revision 1.17 2003/10/26 18:50:49 markster Revision 1.1 2000/06/05 04:45:11 robertj
Make it build and run on MacOS X Added LPC-10 2400bps codec
Revision 1.3 2003/10/26 18:50:49 markster
Make it build and run on MacOS X
Revision 1.2 2003/04/23 19:13:35 markster
More OpenBSD patches
Revision 1.1.1.2 2003/03/16 22:37:30 matteo
dom mar 16 23:37:23 CET 2003
Revision 1.2 2003/03/16 16:09:48 markster
Mere James's cleanups for fewer build warnings
Revision 1.1 2000/01/05 00:20:06 markster
Add broken lpc10 code... It's not too far from working I don't think...
* Revision 1.1 1996/08/19 22:47:31 jaf * Revision 1.1 1996/08/19 22:47:31 jaf
* Initial revision * Initial revision
@ -35,36 +20,8 @@ Add broken lpc10 code... It's not too far from working I don't think...
#define LPC10_BITS_IN_COMPRESSED_FRAME 54 #define LPC10_BITS_IN_COMPRESSED_FRAME 54
/*
The "#if defined"'s in this file are by no means intended to be
complete. They are what Nautilus uses, which has been successfully
compiled under DOS with the Microsoft C compiler, and under a few
versions of Unix with the GNU C compiler.
*/
#if defined(unix) || defined(__unix__) || defined(__NetBSD__)
typedef short INT16; typedef short INT16;
typedef int INT32; typedef int INT32;
#endif
#if defined(__MSDOS__) || defined(MSDOS)
typedef int INT16;
typedef long INT32;
#endif
#if defined(__APPLE__)
typedef short INT16;
typedef int INT32;
#endif
#if defined(WIN32) && defined(_MSC_VER)
typedef __int16 INT16;
typedef __int32 INT32;
#pragma warning(disable: 4005)
#endif
/* The initial values for every member of this structure is 0, except /* The initial values for every member of this structure is 0, except
@ -243,11 +200,11 @@ struct lpc10_decoder_state {
*/ */
struct lpc10_encoder_state * create_lpc10_encoder_state (void); struct lpc10_encoder_state * create_lpc10_encoder_state ();
void init_lpc10_encoder_state (struct lpc10_encoder_state *st); void init_lpc10_encoder_state (struct lpc10_encoder_state *st);
int lpc10_encode (real *speech, INT32 *bits, struct lpc10_encoder_state *st); int lpc10_encode (real *speech, INT32 *bits, struct lpc10_encoder_state *st);
struct lpc10_decoder_state * create_lpc10_decoder_state (void); struct lpc10_decoder_state * create_lpc10_decoder_state ();
void init_lpc10_decoder_state (struct lpc10_decoder_state *st); void init_lpc10_decoder_state (struct lpc10_decoder_state *st);
int lpc10_decode (INT32 *bits, real *speech, struct lpc10_decoder_state *st); int lpc10_decode (INT32 *bits, real *speech, struct lpc10_decoder_state *st);

78
libs/codec/lpc10/lpcdec.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: lpcdec.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:30:11 jaf * Revision 1.2 1996/08/20 20:30:11 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,13 +24,6 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S #ifdef P_R_O_T_O_T_Y_P_E_S
extern int lpcdec_(integer *bits, real *speech); extern int lpcdec_(integer *bits, real *speech);
extern int initlpcdec_(void); extern int initlpcdec_(void);
@ -48,6 +35,13 @@ extern int initlpcdec_(void);
/*:ref: initsynths_ 14 0 */ /*:ref: initsynths_ 14 0 */
#endif #endif
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -63,18 +57,12 @@ static integer c__10 = 10;
/* ***************************************************************** */ /* ***************************************************************** */
/* $Log$ /* $Log: lpcdec.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:30:11 jaf * Revision 1.2 1996/08/20 20:30:11 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -124,18 +112,12 @@ static integer c__10 = 10;
integer irc[10], len; integer irc[10], len;
real rms; real rms;
/* $Log$ /* $Log: lpcdec.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:30:11 jaf * Revision 1.2 1996/08/20 20:30:11 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -164,18 +146,12 @@ static integer c__10 = 10;
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: lpcdec.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:30:11 jaf * Revision 1.2 1996/08/20 20:30:11 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

62
libs/codec/lpc10/lpcenc.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: lpcenc.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:31:21 jaf * Revision 1.2 1996/08/20 20:31:21 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,13 +24,6 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S #ifdef P_R_O_T_O_T_Y_P_E_S
extern int lpcenc_(real *speech, integer *bits); extern int lpcenc_(real *speech, integer *bits);
extern int initlpcenc_(void); extern int initlpcenc_(void);
@ -48,6 +35,13 @@ extern int initlpcenc_(void);
/*:ref: initanalys_ 14 0 */ /*:ref: initanalys_ 14 0 */
#endif #endif
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
/* Table of constant values */ /* Table of constant values */
static integer c__180 = 180; static integer c__180 = 180;
@ -55,18 +49,12 @@ static integer c__10 = 10;
/* ***************************************************************** */ /* ***************************************************************** */
/* $Log$ /* $Log: lpcenc.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:31:21 jaf * Revision 1.2 1996/08/20 20:31:21 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -120,18 +108,12 @@ static integer c__10 = 10;
real rms; real rms;
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: lpcenc.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:31:21 jaf * Revision 1.2 1996/08/20 20:31:21 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

108
libs/codec/lpc10/lpcini.c
View File

@ -1,23 +1,17 @@
/* /*
$Log$ $Log: lpcini.c,v $
Revision 1.18 2003/10/21 18:08:11 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Fix include order Initial version
Revision 1.5 2003/10/21 18:08:11 markster Revision 1.3 2002/10/10 05:29:04 robertj
Fix include order Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
Revision 1.4 2003/10/21 02:57:29 markster Revision 1.2 2001/02/24 14:00:10 rogerh
FreeBSD patch, take 2 Select the correct header file for malloc (stdlib.h or malloc.h)
Revision 1.3 2003/10/16 21:11:30 martinp Revision 1.1 2000/06/05 04:45:12 robertj
Revert the previous patch since it's braking compilation Added LPC-10 2400bps codec
Revision 1.1 2003/02/12 13:59:15 matteo
Initial revision
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:35:41 jaf * Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state * Added functions for allocating and initializing lpc10_encoder_state
@ -41,9 +35,19 @@ extern int lpcini_(void);
-lf2c -lm (in that order) -lf2c -lm (in that order)
*/ */
#include <stdlib.h>
#include "f2c.h" #include "f2c.h"
/* malloc is now defined in stdlib.h in serveral systems */
#ifdef HAS_STDLIB_H
# include <stdlib.h>
#else
# ifdef HAS_MALLOC_H
# include <malloc.h>
# else
extern char * malloc();
# endif
#endif
/* Common Block Declarations */ /* Common Block Declarations */
struct { struct {
@ -55,24 +59,18 @@ struct {
/* ***************************************************************** */ /* ***************************************************************** */
/* $Log$ /* $Log: lpcini.c,v $
* Revision 1.18 2003/10/21 18:08:11 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Fix include order /* Initial version
*
/* Revision 1.5 2003/10/21 18:08:11 markster
/* Fix include order
/* /*
/* Revision 1.4 2003/10/21 02:57:29 markster /* Revision 1.3 2002/10/10 05:29:04 robertj
/* FreeBSD patch, take 2 /* Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
/* /*
/* Revision 1.3 2003/10/16 21:11:30 martinp /* Revision 1.2 2001/02/24 14:00:10 rogerh
/* Revert the previous patch since it's braking compilation /* Select the correct header file for malloc (stdlib.h or malloc.h)
/* /*
/* Revision 1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Initial revision /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:35:41 jaf * Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state * Added functions for allocating and initializing lpc10_encoder_state
@ -93,24 +91,18 @@ struct {
/* Subroutine */ int lpcini_(void) /* Subroutine */ int lpcini_(void)
{ {
/* $Log$ /* $Log: lpcini.c,v $
* Revision 1.18 2003/10/21 18:08:11 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Fix include order /* Initial version
*
/* Revision 1.5 2003/10/21 18:08:11 markster
/* Fix include order
/* /*
/* Revision 1.4 2003/10/21 02:57:29 markster /* Revision 1.3 2002/10/10 05:29:04 robertj
/* FreeBSD patch, take 2 /* Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
/* /*
/* Revision 1.3 2003/10/16 21:11:30 martinp /* Revision 1.2 2001/02/24 14:00:10 rogerh
/* Revert the previous patch since it's braking compilation /* Select the correct header file for malloc (stdlib.h or malloc.h)
/* /*
/* Revision 1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Initial revision /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:35:41 jaf * Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state * Added functions for allocating and initializing lpc10_encoder_state
@ -131,24 +123,18 @@ struct {
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* $Log$ /* $Log: lpcini.c,v $
* Revision 1.18 2003/10/21 18:08:11 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Fix include order /* Initial version
*
/* Revision 1.5 2003/10/21 18:08:11 markster
/* Fix include order
/* /*
/* Revision 1.4 2003/10/21 02:57:29 markster /* Revision 1.3 2002/10/10 05:29:04 robertj
/* FreeBSD patch, take 2 /* Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
/* /*
/* Revision 1.3 2003/10/16 21:11:30 martinp /* Revision 1.2 2001/02/24 14:00:10 rogerh
/* Revert the previous patch since it's braking compilation /* Select the correct header file for malloc (stdlib.h or malloc.h)
/* /*
/* Revision 1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Initial revision /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:35:41 jaf * Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state * Added functions for allocating and initializing lpc10_encoder_state

40
libs/codec/lpc10/lpfilt.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: lpfilt.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:35 jaf * Revision 1.1 1996/08/19 22:31:35 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int lpfilt_(real *inbuf, real *lpbuf, integer *len, integer *nsamp);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int lpfilt_(real *inbuf, real *lpbuf, integer *len, integer *nsamp);
#endif
/* *********************************************************************** */ /* *********************************************************************** */
/* LPFILT Version 55 */ /* LPFILT Version 55 */
/* $Log$ /* $Log: lpfilt.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:31:35 jaf * Revision 1.1 1996/08/19 22:31:35 jaf
* Initial revision * Initial revision

40
libs/codec/lpc10/median.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: median.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:31 jaf * Revision 1.1 1996/08/19 22:31:31 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern integer median_(integer *d1, integer *d2, integer *d3);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern integer median_(integer *d1, integer *d2, integer *d3);
#endif
/* ********************************************************************* */ /* ********************************************************************* */
/* MEDIAN Version 45G */ /* MEDIAN Version 45G */
/* $Log$ /* $Log: median.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:31:31 jaf * Revision 1.1 1996/08/19 22:31:31 jaf
* Initial revision * Initial revision

40
libs/codec/lpc10/mload.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: mload.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:25 jaf * Revision 1.1 1996/08/19 22:31:25 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int mload_(integer *order, integer *awins, integer *awinf, real *speech, real *phi, real *psi);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int mload_(integer *order, integer *awins, integer *awinf, real *speech, real *phi, real *psi);
#endif
/* ***************************************************************** */ /* ***************************************************************** */
/* MLOAD Version 48 */ /* MLOAD Version 48 */
/* $Log$ /* $Log: mload.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:31:25 jaf * Revision 1.1 1996/08/19 22:31:25 jaf
* Initial revision * Initial revision

59
libs/codec/lpc10/onset.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: onset.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:37:55 jaf * Revision 1.2 1996/08/20 20:37:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -27,6 +24,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int onset_(real *pebuf, integer *osbuf, integer *osptr, integer *oslen, integer *sbufl, integer *sbufh, integer *lframe, struct lpc10_encoder_state *st);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -34,10 +35,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int onset_(real *pebuf, integer *osbuf, integer *osptr, integer *oslen, integer *sbufl, integer *sbufh, integer *lframe, struct lpc10_encoder_state *st);
#endif
/* Table of constant values */ /* Table of constant values */
static real c_b2 = 1.f; static real c_b2 = 1.f;
@ -46,18 +43,15 @@ static real c_b2 = 1.f;
/* ONSET Version 49 */ /* ONSET Version 49 */
/* $Log$ /* $Log: onset.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.2 1996/08/20 20:37:55 jaf * Revision 1.2 1996/08/20 20:37:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -154,18 +148,15 @@ static real c_b2 = 1.f;
real *fpc; real *fpc;
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: onset.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:39 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.2 1996/08/20 20:37:55 jaf * Revision 1.2 1996/08/20 20:37:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

70
libs/codec/lpc10/pitsyn.c
View File

@ -1,20 +1,14 @@
/* /*
$Log$ $Log: pitsyn.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/11/23 22:14:32 markster Revision 1.2 2002/02/15 03:57:55 yurik
Various warning cleanups Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:40:12 jaf * Revision 1.2 1996/08/20 20:40:12 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,6 +24,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int pitsyn_(integer *order, integer *voice, integer *pitch, real *rms, real *rc, integer *lframe, integer *ivuv, integer *ipiti, real *rmsi, real *rci, integer *nout, real *ratio, struct lpc10_decoder_state *st);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -37,29 +35,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int pitsyn_(integer *order, integer *voice, integer *pitch, real *rms, real *rc, integer *lframe, integer *ivuv, integer *ipiti, real *rmsi, real *rci, integer *nout, real *ratio, struct lpc10_decoder_state *st);
#endif
/* ***************************************************************** */ /* ***************************************************************** */
/* PITSYN Version 53 */ /* PITSYN Version 53 */
/* $Log$ /* $Log: pitsyn.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* /*
/* Revision 1.14 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:40:12 jaf * Revision 1.2 1996/08/20 20:40:12 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -140,7 +128,7 @@ extern int pitsyn_(integer *order, integer *voice, integer *pitch, real *rms, re
logical *first; logical *first;
/* System generated locals */ /* System generated locals */
integer rci_dim1 = 0, rci_offset, i__1, i__2; integer rci_dim1, rci_offset, i__1, i__2;
real r__1; real r__1;
/* Builtin functions */ /* Builtin functions */
@ -160,21 +148,15 @@ extern int pitsyn_(integer *order, integer *voice, integer *pitch, real *rms, re
real xxy; real xxy;
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: pitsyn.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* /*
/* Revision 1.14 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:40:12 jaf * Revision 1.2 1996/08/20 20:40:12 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

56
libs/codec/lpc10/placea.c
View File

@ -1,23 +1,14 @@
/* /*
$Log$ $Log: placea.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/09/19 01:20:22 markster Revision 1.2 2001/10/16 21:21:14 yurik
Code cleanups (bug #66) Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster Revision 1.1 2000/06/05 04:45:12 robertj
Code cleanups (bug #66) Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.3 2001/04/12 21:27:53 markh
app_record now supports wildcards of sort so your output file is not overwritten every time it's run. File.h got a documentation update on the ast_fileexists to include the return call. Watch out for the placea.c placev.c code, it's updates have not been tested yet. Just a few parenthesis to make it compile nicer on newer gcc versions with all the -W flags set.
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:07 jaf * Revision 1.1 1996/08/19 22:31:07 jaf
* Initial revision * Initial revision
@ -25,6 +16,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int placea_(integer *ipitch, integer *voibuf, integer *obound, integer *af, integer *vwin, integer *awin, integer *ewin, integer *lframe, integer *maxwin);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -32,32 +27,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int placea_(integer *ipitch, integer *voibuf, integer *obound, integer *af, integer *vwin, integer *awin, integer *ewin, integer *lframe, integer *maxwin);
#endif
/* *********************************************************************** */ /* *********************************************************************** */
/* PLACEA Version 48 */ /* PLACEA Version 48 */
/* $Log$ /* $Log: placea.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* /*
/* Revision 1.2 2003/09/19 01:20:22 markster /* Revision 1.2 2001/10/16 21:21:14 yurik
/* Code cleanups (bug #66) /* Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.3 2001/04/12 21:27:53 markh
/* app_record now supports wildcards of sort so your output file is not overwritten every time it's run. File.h got a documentation update on the ast_fileexists to include the return call. Watch out for the placea.c placev.c code, it's updates have not been tested yet. Just a few parenthesis to make it compile nicer on newer gcc versions with all the -W flags set.
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:31:07 jaf * Revision 1.1 1996/08/19 22:31:07 jaf
* Initial revision * Initial revision
@ -170,7 +152,7 @@ extern int placea_(integer *ipitch, integer *voibuf, integer *obound, integer *a
allv = allv && voibuf[(*af << 1) + 1] == 1; allv = allv && voibuf[(*af << 1) + 1] == 1;
allv = allv && voibuf[(*af << 1) + 2] == 1; allv = allv && voibuf[(*af << 1) + 2] == 1;
winv = voibuf[(*af << 1) + 1] == 1 || voibuf[(*af << 1) + 2] == 1; winv = voibuf[(*af << 1) + 1] == 1 || voibuf[(*af << 1) + 2] == 1;
if (allv || (winv && *obound == 0)) { if (allv || winv && *obound == 0) {
/* APHASE: Phase synchronous window placement. */ /* APHASE: Phase synchronous window placement. */
/* Get minimum lower index of the window. */ /* Get minimum lower index of the window. */
i__ = (lrange + *ipitch - 1 - awin[((*af - 1) << 1) + 1]) / *ipitch; i__ = (lrange + *ipitch - 1 - awin[((*af - 1) << 1) + 1]) / *ipitch;

48
libs/codec/lpc10/placev.c
View File

@ -1,20 +1,14 @@
/* /*
$Log$ $Log: placev.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2001/10/16 21:21:14 yurik
mer feb 12 14:56:57 CET 2003 Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.3 2001/04/12 21:27:53 markh
app_record now supports wildcards of sort so your output file is not overwritten every time it's run. File.h got a documentation update on the ast_fileexists to include the return call. Watch out for the placea.c placev.c code, it's updates have not been tested yet. Just a few parenthesis to make it compile nicer on newer gcc versions with all the -W flags set.
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:31:02 jaf * Revision 1.1 1996/08/19 22:31:02 jaf
* Initial revision * Initial revision
@ -22,6 +16,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int placev_(integer *osbuf, integer *osptr, integer *oslen, integer *obound, integer *vwin, integer *af, integer *lframe, integer *minwin, integer *maxwin, integer *dvwinl, integer *dvwinh);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -29,29 +27,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int placev_(integer *osbuf, integer *osptr, integer *oslen, integer *obound, integer *vwin, integer *af, integer *lframe, integer *minwin, integer *maxwin, integer *dvwinl, integer *dvwinh);
#endif
/* ****************************************************************** */ /* ****************************************************************** */
/* PLACEV Version 48 */ /* PLACEV Version 48 */
/* $Log$ /* $Log: placev.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2001/10/16 21:21:14 yurik
/* mer feb 12 14:56:57 CET 2003 /* Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.3 2001/04/12 21:27:53 markh /* Revision 1.1 2000/06/05 04:45:12 robertj
/* app_record now supports wildcards of sort so your output file is not overwritten every time it's run. File.h got a documentation update on the ast_fileexists to include the return call. Watch out for the placea.c placev.c code, it's updates have not been tested yet. Just a few parenthesis to make it compile nicer on newer gcc versions with all the -W flags set. /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:31:02 jaf * Revision 1.1 1996/08/19 22:31:02 jaf
* Initial revision * Initial revision

40
libs/codec/lpc10/preemp.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: preemp.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:30:58 jaf * Revision 1.1 1996/08/19 22:30:58 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int preemp_(real *inbuf, real *pebuf, integer *nsamp, real *coef, real *z__);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int preemp_(real *inbuf, real *pebuf, integer *nsamp, real *coef, real *z__);
#endif
/* ******************************************************************* */ /* ******************************************************************* */
/* PREEMP Version 55 */ /* PREEMP Version 55 */
/* $Log$ /* $Log: preemp.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:30:58 jaf * Revision 1.1 1996/08/19 22:30:58 jaf
* Initial revision * Initial revision

49
libs/codec/lpc10/prepro.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: prepro.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:40:51 jaf * Revision 1.2 1996/08/20 20:40:51 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -24,7 +18,15 @@ Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:30:54 jaf * Revision 1.1 1996/08/19 22:30:54 jaf
* Initial revision * Initial revision
* *
*/
*/
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int prepro_(real *speech, integer *length,
struct lpc10_encoder_state *st)
/*:ref: hp100_ 14 3 6 4 4 */
/*:ref: inithp100_ 14 0 */
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
@ -33,13 +35,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int prepro_(real *speech, integer *length,
struct lpc10_encoder_state *st);
/*:ref: hp100_ 14 3 6 4 4 */
/*:ref: inithp100_ 14 0 */
#endif
/* Table of constant values */ /* Table of constant values */
static integer c__1 = 1; static integer c__1 = 1;
@ -48,18 +43,12 @@ static integer c__1 = 1;
/* PREPRO Version 48 */ /* PREPRO Version 48 */
/* $Log$ /* $Log: prepro.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:40:51 jaf * Revision 1.2 1996/08/20 20:40:51 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

40
libs/codec/lpc10/random.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: random.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:41:32 jaf * Revision 1.2 1996/08/20 20:41:32 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -27,6 +21,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern integer random_(struct lpc10_decoder_state *st);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -34,26 +32,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern integer random_(struct lpc10_decoder_state *st);
#endif
/* ********************************************************************** */ /* ********************************************************************** */
/* RANDOM Version 49 */ /* RANDOM Version 49 */
/* $Log$ /* $Log: random.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:41:32 jaf * Revision 1.2 1996/08/20 20:41:32 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

40
libs/codec/lpc10/rcchk.c
View File

@ -1,17 +1,11 @@
/* /*
$Log$ $Log: rcchk.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:30:41 jaf * Revision 1.1 1996/08/19 22:30:41 jaf
* Initial revision * Initial revision
@ -19,6 +13,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int rcchk_(integer *order, real *rc1f, real *rc2f);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,26 +24,16 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int rcchk_(integer *order, real *rc1f, real *rc2f);
#endif
/* ********************************************************************* */ /* ********************************************************************* */
/* RCCHK Version 45G */ /* RCCHK Version 45G */
/* $Log$ /* $Log: rcchk.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.1 1996/08/19 22:30:41 jaf * Revision 1.1 1996/08/19 22:30:41 jaf
* Initial revision * Initial revision

93
libs/codec/lpc10/synths.c
View File

@ -1,20 +1,11 @@
/* /*
$Log$ $Log: synths.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/09/27 02:45:37 markster Revision 1.1 2000/06/05 04:45:12 robertj
Fix various compiler warnings (bug #322) Added LPC-10 2400bps codec
Revision 1.2 2003/09/27 02:45:37 markster
Fix various compiler warnings (bug #322)
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:39 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:42:59 jaf * Revision 1.2 1996/08/20 20:42:59 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,13 +21,6 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S #ifdef P_R_O_T_O_T_Y_P_E_S
extern int synths_(integer *voice, integer *pitch, real *rms, real *rc, real *speech, integer *k, struct lpc10_decoder_state *st); extern int synths_(integer *voice, integer *pitch, real *rms, real *rc, real *speech, integer *k, struct lpc10_decoder_state *st);
/* comlen contrl_ 12 */ /* comlen contrl_ 12 */
@ -49,6 +33,13 @@ extern int synths_(integer *voice, integer *pitch, real *rms, real *rc, real *sp
/*:ref: initdeemp_ 14 0 */ /*:ref: initdeemp_ 14 0 */
#endif #endif
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -66,21 +57,12 @@ static real c_b2 = .7f;
/* SYNTHS Version 54 */ /* SYNTHS Version 54 */
/* $Log$ /* $Log: synths.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/27 02:45:37 markster
/* Fix various compiler warnings (bug #322)
/* /*
/* Revision 1.2 2003/09/27 02:45:37 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Fix various compiler warnings (bug #322) /* Added LPC-10 2400bps codec
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:42:59 jaf * Revision 1.2 1996/08/20 20:42:59 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -185,6 +167,9 @@ static real c_b2 = .7f;
extern /* Subroutine */ int deemp_(real *, integer *, struct lpc10_decoder_state *); extern /* Subroutine */ int deemp_(real *, integer *, struct lpc10_decoder_state *);
real ratio; real ratio;
integer ipiti[16]; integer ipiti[16];
extern /* Subroutine */ bsynz_(real *, integer *,
integer *, real *, real *, real *, real *, struct lpc10_decoder_state *), irc2pc_(real *, real *
, integer *, real *, real *);
real g2pass; real g2pass;
real pc[10]; real pc[10];
extern /* Subroutine */ int pitsyn_(integer *, integer *, integer *, real extern /* Subroutine */ int pitsyn_(integer *, integer *, integer *, real
@ -192,21 +177,12 @@ static real c_b2 = .7f;
integer *, real *, struct lpc10_decoder_state *); integer *, real *, struct lpc10_decoder_state *);
real rci[160] /* was [10][16] */; real rci[160] /* was [10][16] */;
/* $Log$ /* $Log: synths.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/27 02:45:37 markster
/* Fix various compiler warnings (bug #322)
/* /*
/* Revision 1.2 2003/09/27 02:45:37 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Fix various compiler warnings (bug #322) /* Added LPC-10 2400bps codec
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:42:59 jaf * Revision 1.2 1996/08/20 20:42:59 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -232,21 +208,12 @@ static real c_b2 = .7f;
/* LPC Configuration parameters: */ /* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */ /* Frame size, Prediction order, Pitch period */
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: synths.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/09/27 02:45:37 markster
/* Fix various compiler warnings (bug #322)
/* /*
/* Revision 1.2 2003/09/27 02:45:37 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Fix various compiler warnings (bug #322) /* Added LPC-10 2400bps codec
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/*
/* Revision 1.2 2000/01/05 08:20:39 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:42:59 jaf * Revision 1.2 1996/08/20 20:42:59 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

44
libs/codec/lpc10/tbdm.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: tbdm.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:40 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:30:26 jaf * Revision 1.1 1996/08/19 22:30:26 jaf
* Initial revision * Initial revision
@ -19,6 +16,11 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int tbdm_(real *speech, integer *lpita, integer *tau, integer *ltau, real *amdf, integer *minptr, integer *maxptr, integer *mintau);
/*:ref: difmag_ 14 8 6 4 4 4 4 6 4 4 */
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,27 +28,19 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int tbdm_(real *speech, integer *lpita, integer *tau, integer *ltau, real *amdf, integer *minptr, integer *maxptr, integer *mintau);
/*:ref: difmag_ 14 8 6 4 4 4 4 6 4 4 */
#endif
/* ********************************************************************** */ /* ********************************************************************** */
/* TBDM Version 49 */ /* TBDM Version 49 */
/* $Log$ /* $Log: tbdm.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:40 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:30:26 jaf * Revision 1.1 1996/08/19 22:30:26 jaf
* Initial revision * Initial revision

74
libs/codec/lpc10/voicin.c
View File

@ -1,20 +1,14 @@
/* /*
$Log$ $Log: voicin.c,v $
Revision 1.16 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.15 2003/11/23 22:14:32 markster Revision 1.2 2002/02/15 03:57:55 yurik
Various warning cleanups Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2000/01/05 08:20:40 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.2 1996/08/20 20:45:00 jaf * Revision 1.2 1996/08/20 20:45:00 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -30,6 +24,12 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int voicin_(integer *vwin, real *inbuf, real *lpbuf, integer *buflim, integer *half, real *minamd, real *maxamd, integer *mintau, real *ivrc, integer *obound, integer *voibuf, integer *af, struct lpc10_encoder_state *st);
/* comlen contrl_ 12 */
/*:ref: vparms_ 14 14 4 6 6 4 4 6 4 4 4 4 6 6 6 6 */
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -37,12 +37,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int voicin_(integer *vwin, real *inbuf, real *lpbuf, integer *buflim, integer *half, real *minamd, real *maxamd, integer *mintau, real *ivrc, integer *obound, integer *voibuf, integer *af, struct lpc10_encoder_state *st);
/* comlen contrl_ 12 */
/*:ref: vparms_ 14 14 4 6 6 4 4 6 4 4 4 4 6 6 6 6 */
#endif
/* Common Block Declarations */ /* Common Block Declarations */
extern struct { extern struct {
@ -56,21 +50,15 @@ extern struct {
/* VOICIN Version 52 */ /* VOICIN Version 52 */
/* $Log$ /* $Log: voicin.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* /*
/* Revision 1.14 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:40 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:45:00 jaf * Revision 1.2 1996/08/20 20:45:00 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran
@ -277,7 +265,7 @@ s*/
; ;
/* System generated locals */ /* System generated locals */
integer inbuf_offset = 0, lpbuf_offset = 0, i__1, i__2; integer inbuf_offset, lpbuf_offset, i__1, i__2;
real r__1, r__2; real r__1, r__2;
/* Builtin functions */ /* Builtin functions */
@ -307,21 +295,15 @@ s*/
/* Global Variables: */ /* Global Variables: */
/* Arguments */ /* Arguments */
/* $Log$ /* $Log: voicin.c,v $
* Revision 1.16 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* /*
/* Revision 1.14 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.1 2000/06/05 04:45:12 robertj
/* mer feb 12 14:56:57 CET 2003 /* Added LPC-10 2400bps codec
/*
/* Revision 1.2 2000/01/05 08:20:40 markster
/* Some OSS fixes and a few lpc changes to make it actually work
/* /*
* Revision 1.2 1996/08/20 20:45:00 jaf * Revision 1.2 1996/08/20 20:45:00 jaf
* Removed all static local variables that were SAVE'd in the Fortran * Removed all static local variables that were SAVE'd in the Fortran

42
libs/codec/lpc10/vparms.c
View File

@ -1,17 +1,14 @@
/* /*
$Log$ $Log: vparms.c,v $
Revision 1.15 2004/06/26 03:50:14 markster Revision 1.1 2004/05/04 11:16:43 csoutheren
Merge source cleanups (bug #1911) Initial version
Revision 1.14 2003/02/12 13:59:15 matteo Revision 1.2 2002/02/15 03:57:55 yurik
mer feb 12 14:56:57 CET 2003 Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.1.1.1 2003/02/12 13:59:15 matteo Revision 1.1 2000/06/05 04:45:12 robertj
mer feb 12 14:56:57 CET 2003 Added LPC-10 2400bps codec
Revision 1.2 2000/01/05 08:20:40 markster
Some OSS fixes and a few lpc changes to make it actually work
* Revision 1.1 1996/08/19 22:30:04 jaf * Revision 1.1 1996/08/19 22:30:04 jaf
* Initial revision * Initial revision
@ -19,6 +16,10 @@ Some OSS fixes and a few lpc changes to make it actually work
*/ */
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int vparms_(integer *vwin, real *inbuf, real *lpbuf, integer *buflim, integer *half, real *dither, integer *mintau, integer *zc, integer *lbe, integer *fbe, real *qs, real *rc1, real *ar_b__, real *ar_f__);
#endif
/* -- translated by f2c (version 19951025). /* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries: You must link the resulting object file with the libraries:
-lf2c -lm (in that order) -lf2c -lm (in that order)
@ -26,10 +27,6 @@ Some OSS fixes and a few lpc changes to make it actually work
#include "f2c.h" #include "f2c.h"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int vparms_(integer *vwin, real *inbuf, real *lpbuf, integer *buflim, integer *half, real *dither, integer *mintau, integer *zc, integer *lbe, integer *fbe, real *qs, real *rc1, real *ar_b__, real *ar_f__);
#endif
/* Table of constant values */ /* Table of constant values */
static real c_b2 = 1.f; static real c_b2 = 1.f;
@ -38,18 +35,15 @@ static real c_b2 = 1.f;
/* VPARMS Version 50 */ /* VPARMS Version 50 */
/* $Log$ /* $Log: vparms.c,v $
* Revision 1.15 2004/06/26 03:50:14 markster /* Revision 1.1 2004/05/04 11:16:43 csoutheren
* Merge source cleanups (bug #1911) /* Initial version
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* /*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo /* Revision 1.2 2002/02/15 03:57:55 yurik
/* mer feb 12 14:56:57 CET 2003 /* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/* /*
/* Revision 1.2 2000/01/05 08:20:40 markster /* Revision 1.1 2000/06/05 04:45:12 robertj
/* Some OSS fixes and a few lpc changes to make it actually work /* Added LPC-10 2400bps codec
/* /*
* Revision 1.1 1996/08/19 22:30:04 jaf * Revision 1.1 1996/08/19 22:30:04 jaf
* Initial revision * Initial revision