kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

update ilbc and lpc10 codecs from openh323 sources. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

85
libs/codec/lpc10/Makefile
View File

@ -3,7 +3,7 @@
#
# default C compiler
CC?= gcc
CC= gcc
#
# These definitions for CFLAGS and LIB_TARGET_DIR are used when one
@ -14,62 +14,57 @@ CC?= gcc
# definitions.
#
LIB_TARGET_DIR = .
LIB_TARGET_DIR = ..
#
# -I$(LIB_TARGET_DIR) option needed so that #include "machine.h"
# directives can find the machine.h file.
#
WARNINGS = -Wall -Wno-comment -Wno-error
CFLAGS += $(OPTIMIZE) -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
WARNINGS = -Wall
CFLAGS = -O3 -I$(LIB_TARGET_DIR) $(WARNINGS)
LIB = $(LIB_TARGET_DIR)/liblpc10.a
.PHONY: all clean
all: $(LIB)
ranlib $(LIB)
OBJ= f2clib.o analys.o bsynz.o chanwr.o dcbias.o decode.o \
deemp.o difmag.o dyptrk.o encode.o energy.o ham84.o \
hp100.o invert.o irc2pc.o ivfilt.o lpcdec.o lpcenc.o \
lpcini.o lpfilt.o median.o mload.o onset.o pitsyn.o \
placea.o placev.o preemp.o prepro.o random.o rcchk.o \
synths.o tbdm.o voicin.o vparms.o
$(LIB): $(OBJ)
$(AR) cr $@ $(OBJ)
ranlib $@
$(LIB): $(LIB)(f2clib.o) \
$(LIB)(analys.o) \
$(LIB)(bsynz.o) \
$(LIB)(chanwr.o) \
$(LIB)(dcbias.o) \
$(LIB)(decode.o) \
$(LIB)(deemp.o) \
$(LIB)(difmag.o) \
$(LIB)(dyptrk.o) \
$(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:
-rm -f *.o $(LIB)
-rm -f *.o

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

@ -1,20 +1,14 @@
/*
$Log$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: analys.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
Initial version
Revision 1.15 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
Revision 1.2 2002/02/15 03:57:55 yurik
Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:16:01 jaf
* 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
extern int analys_(real *speech, integer *voice, integer *pitch, real *rms, real *rc, struct lpc10_encoder_state *st);
/* comlen contrl_ 12 */
@ -60,6 +52,8 @@ extern int analys_(real *speech, integer *voice, integer *pitch, real *rms, real
-lf2c -lm (in that order)
*/
#include "f2c.h"
/* Common Block Declarations */
extern struct {
@ -87,21 +81,15 @@ static integer c__1 = 1;
/* ANALYS Version 55 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: analys.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:16:01 jaf
* 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 *
, integer *, integer *, integer *, struct lpc10_encoder_state *);
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 *obound;
extern /* Subroutine */ int preemp_(real *, real *, integer *, real *,
@ -259,21 +251,15 @@ static integer c__1 = 1;
*, integer *, integer *, struct lpc10_encoder_state *);
real phi[100] /* was [10][10] */, psi[10];
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: analys.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:16:01 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -299,21 +285,15 @@ static integer c__1 = 1;
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments to ANALYS */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: analys.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:16:01 jaf
* 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[1] = voibuf[3];
for (i__ = 1; i__ <= 2; ++i__) {
vwin[(i__ << 1) - 2] = vwin[((i__ + 1) << 1) - 2] - 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) - 1] = awin[((i__ + 1) << 1) - 1] - 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;
awin[(i__ << 1) - 2] = awin[(i__ + (1 << 1)) - 2] - 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
*/
/* unnecessary. It also causes error messages when the C versio
@ -524,7 +504,7 @@ n */
/* EWIN(2,I) = EWIN(2,I+1) - LFRAME */
obound[i__ - 1] = obound[i__];
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__];
i__1 = contrl_1.order;
for (j = 1; j <= i__1; ++j) {

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

@ -1,17 +1,14 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: bsynz.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:14 matteo
mer feb 12 14:56:57 CET 2003
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.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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:18:55 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
extern struct {
@ -53,18 +50,15 @@ extern struct {
/* BSYNZ Version 54 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: bsynz.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:18:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -155,18 +149,15 @@ extern struct {
real xy, sum, ssq;
real lpi0, hpi0;
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: bsynz.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:18:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -192,18 +183,15 @@ extern struct {
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: bsynz.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:18:55 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: chanwr.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:20:24 jaf
* 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).
You must link the resulting object file with the libraries:
-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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: chanwr.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:20:24 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: dcbias.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:40:23 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int dcbias_(integer *len, real *speech, real *sigout);
#endif
/* ********************************************************************* */
/* DCBIAS Version 50 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: dcbias.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:40:23 jaf
* Initial revision

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

@ -1,20 +1,14 @@
/*
$Log$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: decode_.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
Initial version
Revision 1.15 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
Revision 1.2 2002/02/15 03:57:55 yurik
Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:22:39 jaf
* 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
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 */
@ -44,6 +31,13 @@ extern int decode_(integer *ipitv, integer *irms, integer *irc, integer *voice,
/*:ref: median_ 4 3 4 4 4 */
#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 */
extern struct {
@ -61,21 +55,15 @@ static integer c__2 = 2;
/* DECODE Version 54 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: decode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:22:39 jaf
* 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 *);
integer ishift, errcnt, lsb;
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: decode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -245,21 +227,15 @@ static integer c__2 = 2;
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: decode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:22:39 jaf
* 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__) {
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[
ixcor + ((i__ + 2) << 2) - 5]) {
ixcor + (i__ + (2 << 2)) - 5]) {
irc[i__] = median_(&drc[i__ * 3 - 1], &drc[i__ * 3 - 2], &drc[
i__ * 3 - 3]);
}

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: deemp.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:23:46 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: deemp.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:23:46 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: difmag.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:32:31 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:14 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: difmag.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:31 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: dyptrk.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:25:29 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
extern struct {
@ -52,18 +46,12 @@ extern struct {
/* DYPTRK Version 52 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: dyptrk.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:25:29 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -147,18 +135,12 @@ extern struct {
real alpha, minsc, maxsc;
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: dyptrk.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:25:29 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: encode_.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
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.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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:32:21 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
extern struct {
@ -48,18 +45,15 @@ static integer c__2 = 2;
/* ENCODE Version 54 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: encode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision
@ -139,18 +133,15 @@ static integer c__2 = 2;
/* Local variables */
integer idel, nbit, i__, j, i2, i3, mrk;
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: encode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision
@ -168,18 +159,15 @@ static integer c__2 = 2;
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: encode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision

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

@ -1,17 +1,14 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: energy.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
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.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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:32:17 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int energy_(integer *len, real *speech, real *rms);
#endif
/* ********************************************************************* */
/* ENERGY Version 50 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: energy.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:17 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: f2c.h,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:26:28 jaf
* 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 /* Subroutine */ int (*S_fp)(...);
#else
typedef int /* Unknown procedure type */ (*U_fp)(VOID);
typedef shortint (*J_fp)(VOID);
typedef integer (*I_fp)(VOID);
typedef real (*R_fp)(VOID);
typedef doublereal (*D_fp)(VOID), (*E_fp)(VOID);
typedef /* Complex */ VOID (*C_fp)(VOID);
typedef /* Double Complex */ VOID (*Z_fp)(VOID);
typedef logical (*L_fp)(VOID);
typedef shortlogical (*K_fp)(VOID);
typedef /* Character */ VOID (*H_fp)(VOID);
typedef /* Subroutine */ int (*S_fp)(VOID);
typedef int /* Unknown procedure type */ (*U_fp)();
typedef shortint (*J_fp)();
typedef integer (*I_fp)();
typedef real (*R_fp)();
typedef doublereal (*D_fp)(), (*E_fp)();
typedef /* Complex */ VOID (*C_fp)();
typedef /* Double Complex */ VOID (*Z_fp)();
typedef logical (*L_fp)();
typedef shortlogical (*K_fp)();
typedef /* Character */ VOID (*H_fp)();
typedef /* Subroutine */ int (*S_fp)();
#endif
/* E_fp is for real functions when -R is not specified */
typedef VOID C_f; /* complex function */
@ -255,71 +249,4 @@ typedef doublereal E_f; /* real function with -R not specified */
#undef unix
#undef vax
#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
#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$
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
$Log: f2clib.c,v $
Revision 1.2 2004/05/05 13:25:38 rjongbloed
Fixed clearly incorrect code (dived by zero) found with an MSVC warning
Revision 1.1.1.1 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.1 2004/05/04 11:16:42 csoutheren
Initial version
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.3 2004/02/17 09:21:45 csoutheren
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
* Initial revision
@ -40,7 +46,7 @@ integer pow_ii(integer *ap, integer *bp)
if (n == 0 || x == 1)
return 1;
if (x != -1)
return x == 0 ? 0 : 1/x;
return x != 0 ? 1/x : 0;
n = -n;
}
u = n;
@ -80,6 +86,6 @@ integer i_nint(x) real *x;
integer i_nint(real *x)
#endif
{
return( (integer)((*x)>=0 ?
floor(*x + .5) : -floor(.5 - *x)) );
return (integer)( (*x)>=0 ?
floor(*x + .5) : -(floor(.5 - *x)) );
}

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: ham84.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:32:07 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int ham84_(integer *input, integer *output, integer *errcnt);
#endif
/* ***************************************************************** */
/* HAM84 Version 45G */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: ham84.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:07 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: hp100.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:28:05 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: hp100.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:28:05 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: invert.c,v $
Revision 1.1 2004/05/04 11:16:42 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:32:00 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: invert.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision
@ -102,18 +90,12 @@ extern int invert_(integer *order, real *phi, real *psi, real *rc);
real v[100] /* was [10][10] */;
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: invert.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision

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

@ -1,17 +1,14 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: irc2pc.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
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.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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:56 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: irc2pc.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:56 jaf
* Initial revision
@ -93,18 +87,15 @@ extern int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pas
integer i__, j;
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: irc2pc.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:56 jaf
* 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__) {
*g2pass *= 1.f - rc[i__] * rc[i__];
}
*g2pass = *gprime * (real)sqrt(*g2pass);
*g2pass = (real)(*gprime * sqrt(*g2pass));
pc[1] = rc[1];
i__1 = *order;
for (i__ = 2; i__ <= i__1; ++i__) {

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

@ -1,20 +1,14 @@
/*
$Log$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: ivfilt.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.15 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
Revision 1.2 2002/02/15 03:57:55 yurik
Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:53 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: ivfilt.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:53 jaf
* Initial revision
@ -109,7 +97,7 @@ extern int ivfilt_(real *lpbuf, real *ivbuf, integer *len, integer *nsamp, real
/* Function Body */
for (i__ = 1; i__ <= 3; ++i__) {
r__[i__ - 1] = 0.f;
k = (i__ - 1) << 2;
k = i__ - (1 << 2);
i__1 = *len;
for (j = (i__ << 2) + *len - *nsamp; j <= i__1; j += 2) {
r__[i__ - 1] += lpbuf[j] * lpbuf[j - k];

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

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

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

@ -1,26 +1,11 @@
/*
$Log$
Revision 1.18 2004/08/31 13:32:11 markster
Merge NetBSD and Courtesty tone with modifications (bug #2329)
$Log: lpc10.h,v $
Revision 1.1 2004/05/04 11:30:49 csoutheren
Initial version
Revision 1.17 2003/10/26 18:50:49 markster
Make it build and run on MacOS X
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 2000/06/05 04:45:11 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:47:31 jaf
* 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
/*
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 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
typedef int INT32;
/* 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);
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);
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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: lpcdec.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:30:11 jaf
* 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
extern int lpcdec_(integer *bits, real *speech);
extern int initlpcdec_(void);
@ -48,6 +35,13 @@ extern int initlpcdec_(void);
/*:ref: initsynths_ 14 0 */
#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 */
extern struct {
@ -63,18 +57,12 @@ static integer c__10 = 10;
/* ***************************************************************** */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: lpcdec.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:30:11 jaf
* 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;
real rms;
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: lpcdec.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:30:11 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -164,18 +146,12 @@ static integer c__10 = 10;
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: lpcdec.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:30:11 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: lpcenc.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:31:21 jaf
* 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
extern int lpcenc_(real *speech, integer *bits);
extern int initlpcenc_(void);
@ -48,6 +35,13 @@ extern int initlpcenc_(void);
/*:ref: initanalys_ 14 0 */
#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 */
static integer c__180 = 180;
@ -55,18 +49,12 @@ static integer c__10 = 10;
/* ***************************************************************** */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: lpcenc.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:31:21 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -120,18 +108,12 @@ static integer c__10 = 10;
real rms;
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: lpcenc.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:31:21 jaf
* 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$
Revision 1.18 2003/10/21 18:08:11 markster
Fix include order
$Log: lpcini.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.5 2003/10/21 18:08:11 markster
Fix include order
Revision 1.3 2002/10/10 05:29:04 robertj
Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
Revision 1.4 2003/10/21 02:57:29 markster
FreeBSD patch, take 2
Revision 1.2 2001/02/24 14:00:10 rogerh
Select the correct header file for malloc (stdlib.h or malloc.h)
Revision 1.3 2003/10/16 21:11:30 martinp
Revert the previous patch since it's braking compilation
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.1 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state
@ -41,9 +35,19 @@ extern int lpcini_(void);
-lf2c -lm (in that order)
*/
#include <stdlib.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 */
struct {
@ -55,24 +59,18 @@ struct {
/* ***************************************************************** */
/* $Log$
* Revision 1.18 2003/10/21 18:08:11 markster
* Fix include order
*
/* Revision 1.5 2003/10/21 18:08:11 markster
/* Fix include order
/* $Log: lpcini.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.4 2003/10/21 02:57:29 markster
/* FreeBSD patch, take 2
/* Revision 1.3 2002/10/10 05:29:04 robertj
/* Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
/*
/* Revision 1.3 2003/10/16 21:11:30 martinp
/* Revert the previous patch since it's braking compilation
/* Revision 1.2 2001/02/24 14:00:10 rogerh
/* Select the correct header file for malloc (stdlib.h or malloc.h)
/*
/* 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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state
@ -93,24 +91,18 @@ struct {
/* Subroutine */ int lpcini_(void)
{
/* $Log$
* Revision 1.18 2003/10/21 18:08:11 markster
* Fix include order
*
/* Revision 1.5 2003/10/21 18:08:11 markster
/* Fix include order
/* $Log: lpcini.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.4 2003/10/21 02:57:29 markster
/* FreeBSD patch, take 2
/* Revision 1.3 2002/10/10 05:29:04 robertj
/* Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
/*
/* Revision 1.3 2003/10/16 21:11:30 martinp
/* Revert the previous patch since it's braking compilation
/* Revision 1.2 2001/02/24 14:00:10 rogerh
/* Select the correct header file for malloc (stdlib.h or malloc.h)
/*
/* 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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state
@ -131,24 +123,18 @@ struct {
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* $Log$
* Revision 1.18 2003/10/21 18:08:11 markster
* Fix include order
*
/* Revision 1.5 2003/10/21 18:08:11 markster
/* Fix include order
/* $Log: lpcini.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.4 2003/10/21 02:57:29 markster
/* FreeBSD patch, take 2
/* Revision 1.3 2002/10/10 05:29:04 robertj
/* Removed non-ansi-C comments to maximise portability, thanks Martijn Roest
/*
/* Revision 1.3 2003/10/16 21:11:30 martinp
/* Revert the previous patch since it's braking compilation
/* Revision 1.2 2001/02/24 14:00:10 rogerh
/* Select the correct header file for malloc (stdlib.h or malloc.h)
/*
/* 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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:35:41 jaf
* Added functions for allocating and initializing lpc10_encoder_state

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: lpfilt.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:35 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: lpfilt.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:35 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: median.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:31 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern integer median_(integer *d1, integer *d2, integer *d3);
#endif
/* ********************************************************************* */
/* MEDIAN Version 45G */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: median.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:31 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: mload.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:25 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: mload.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:25 jaf
* Initial revision

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

@ -1,17 +1,14 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: onset.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
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.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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:37:55 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
static real c_b2 = 1.f;
@ -46,18 +43,15 @@ static real c_b2 = 1.f;
/* ONSET Version 49 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: onset.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:37:55 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -154,18 +148,15 @@ static real c_b2 = 1.f;
real *fpc;
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: onset.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:37:55 jaf
* 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$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: pitsyn.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.15 2003/11/23 22:14:32 markster
Various warning cleanups
Revision 1.2 2002/02/15 03:57:55 yurik
Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:40:12 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* $Log: pitsyn.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:40:12 jaf
* 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;
/* 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;
/* Builtin functions */
@ -160,21 +148,15 @@ extern int pitsyn_(integer *order, integer *voice, integer *pitch, real *rms, re
real xxy;
/* Arguments */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* $Log: pitsyn.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* 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.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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:40:12 jaf
* 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$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: placea.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.15 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
Revision 1.2 2001/10/16 21:21:14 yurik
Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
Revision 1.2 2003/09/19 01:20:22 markster
Code cleanups (bug #66)
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:07 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* $Log: placea.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.2 2003/09/19 01:20:22 markster
/* Code cleanups (bug #66)
/* Revision 1.2 2001/10/16 21:21:14 yurik
/* Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:07 jaf
* 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) + 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. */
/* Get minimum lower index of the window. */
i__ = (lrange + *ipitch - 1 - awin[((*af - 1) << 1) + 1]) / *ipitch;

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

@ -1,20 +1,14 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: placev.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
Revision 1.2 2001/10/16 21:21:14 yurik
Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:31:02 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: placev.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2001/10/16 21:21:14 yurik
/* Removed warnings on Windows CE. Submitted by Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:31:02 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: preemp.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:30:58 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: preemp.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:30:58 jaf
* Initial revision

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

@ -1,17 +1,11 @@
/*
$Log$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: prepro.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:40:51 jaf
* 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
* 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).
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"
#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 */
static integer c__1 = 1;
@ -48,18 +43,12 @@ static integer c__1 = 1;
/* PREPRO Version 48 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: prepro.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:40:51 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: random.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:41:32 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern integer random_(struct lpc10_decoder_state *st);
#endif
/* ********************************************************************** */
/* RANDOM Version 49 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: random.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:41:32 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: rcchk.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:30:41 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#ifdef P_R_O_T_O_T_Y_P_E_S
extern int rcchk_(integer *order, real *rc1f, real *rc2f);
#endif
/* ********************************************************************* */
/* RCCHK Version 45G */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: rcchk.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:30:41 jaf
* Initial revision

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

@ -1,20 +1,11 @@
/*
$Log$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: synths.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
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
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.1 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:42:59 jaf
* 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
extern int synths_(integer *voice, integer *pitch, real *rms, real *rc, real *speech, integer *k, struct lpc10_decoder_state *st);
/* comlen contrl_ 12 */
@ -49,6 +33,13 @@ extern int synths_(integer *voice, integer *pitch, real *rms, real *rc, real *sp
/*:ref: initdeemp_ 14 0 */
#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 */
extern struct {
@ -66,21 +57,12 @@ static real c_b2 = .7f;
/* SYNTHS Version 54 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/27 02:45:37 markster
/* Fix various compiler warnings (bug #322)
/* $Log: synths.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:42:59 jaf
* 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 *);
real ratio;
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 pc[10];
extern /* Subroutine */ int pitsyn_(integer *, integer *, integer *, real
@ -192,21 +177,12 @@ static real c_b2 = .7f;
integer *, real *, struct lpc10_decoder_state *);
real rci[160] /* was [10][16] */;
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/27 02:45:37 markster
/* Fix various compiler warnings (bug #322)
/* $Log: synths.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:42:59 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -232,21 +208,12 @@ static real c_b2 = .7f;
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/09/27 02:45:37 markster
/* Fix various compiler warnings (bug #322)
/* $Log: synths.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* 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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:42:59 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: tbdm.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
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.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.1 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:30:26 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: tbdm.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:30:26 jaf
* Initial revision

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

@ -1,20 +1,14 @@
/*
$Log$
Revision 1.16 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: voicin.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.15 2003/11/23 22:14:32 markster
Various warning cleanups
Revision 1.2 2002/02/15 03:57:55 yurik
Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
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
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.1 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.2 1996/08/20 20:45:00 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
extern struct {
@ -56,21 +50,15 @@ extern struct {
/* VOICIN Version 52 */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* $Log: voicin.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* 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.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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:45:00 jaf
* Removed all static local variables that were SAVE'd in the Fortran
@ -277,7 +265,7 @@ s*/
;
/* 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;
/* Builtin functions */
@ -307,21 +295,15 @@ s*/
/* Global Variables: */
/* Arguments */
/* $Log$
* Revision 1.16 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.15 2003/11/23 22:14:32 markster
/* Various warning cleanups
/* $Log: voicin.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* 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.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.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:45:00 jaf
* 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$
Revision 1.15 2004/06/26 03:50:14 markster
Merge source cleanups (bug #1911)
$Log: vparms.c,v $
Revision 1.1 2004/05/04 11:16:43 csoutheren
Initial version
Revision 1.14 2003/02/12 13:59:15 matteo
mer feb 12 14:56:57 CET 2003
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.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.1 2000/06/05 04:45:12 robertj
Added LPC-10 2400bps codec
* Revision 1.1 1996/08/19 22:30:04 jaf
* 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).
You must link the resulting object file with the libraries:
-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"
#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 */
static real c_b2 = 1.f;
@ -38,18 +35,15 @@ static real c_b2 = 1.f;
/* VPARMS Version 50 */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
/* Revision 1.14 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* $Log: vparms.c,v $
/* Revision 1.1 2004/05/04 11:16:43 csoutheren
/* Initial version
/*
/* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
/* mer feb 12 14:56:57 CET 2003
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, jehan@bravobrava.com
/*
/* 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 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.1 1996/08/19 22:30:04 jaf
* Initial revision