📄 ilbc_encoder.java
字号:
for (i=gain_index[gain_index_idx + 0]; i<32; i++) {
ftmp=cene*ilbc_constants.gain_sq5Tbl[i]*ilbc_constants.gain_sq5Tbl[i];
if ((ftmp<(tene*gains[0]*gains[0])) &&
(ilbc_constants.gain_sq5Tbl[j]<(2.0f*gains[0]))) {
j=i;
}
}
gain_index[gain_index_idx + 0]=j;
}
public void index_conv_enc(int index[]) /* (i/o) Codebook indexes */
{
int k;
for (k=1; k < ilbc_constants.CB_NSTAGES; k++) {
if ((index[k]>=108)&&(index[k]<172)) {
index[k]-=64;
} else if (index[k]>=236) {
index[k]-=128;
} else {
/* ERROR */
}
}
}
public 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;
int pi, po;
/* all-zero section*/
// pi = &In[0];
pi = 0;
// po = &Out[0];
po = 0;
for (i=0; i<len; i++) {
// System.out.println(Out[po] + " + " + ilbc_constants.hpi_zero_coefsTbl[0] + " * " + In[pi] + "((" + ilbc_constants.hpi_zero_coefsTbl[0] * In[pi]);
Out[po] = ilbc_constants.hpi_zero_coefsTbl[0] * (In[pi]);
// System.out.println("then *po=" + Out[po]);
// System.out.println(Out[po] + " + " + ilbc_constants.hpi_zero_coefsTbl[1] +" * "+ mem[0] + "((" + ilbc_constants.hpi_zero_coefsTbl[1] * mem[0]);
Out[po] += ilbc_constants.hpi_zero_coefsTbl[1] * mem[0];
// System.out.println("then *po=" + Out[po]);
// System.out.println(Out[po] + " + " + ilbc_constants.hpi_zero_coefsTbl[2] + " * " + mem[1] + "((" + ilbc_constants.hpi_zero_coefsTbl[2] * mem[1]);
Out[po] += ilbc_constants.hpi_zero_coefsTbl[2] * mem[1];
// System.out.println("then *po=" + Out[po]);
mem[1] = mem[0];
mem[0] = In[pi];
po++;
pi++;
}
/* all-pole section*/
// po = &Out[0];
po = 0;
for (i=0; i<len; i++) {
// System.out.println("(part 2-"+i+") *po=" + Out[po]);
// System.out.println(Out[po] + " - " + ilbc_constants.hpi_pole_coefsTbl[1] + " * " + mem[2] + " ((" + ilbc_constants.hpi_pole_coefsTbl[1] * mem[2]);
Out[po] -= ilbc_constants.hpi_pole_coefsTbl[1] * mem[2];
// System.out.println("then *po=" + Out[po]);
// System.out.println(Out[po] + " - " + ilbc_constants.hpi_pole_coefsTbl[2] + " * " + mem[3] + " ((" + ilbc_constants.hpi_pole_coefsTbl[2] * mem[3]);
Out[po] -= ilbc_constants.hpi_pole_coefsTbl[2] * mem[3];
// System.out.println("2then *po=" + Out[po]);
mem[3] = mem[2];
mem[2] = Out[po];
po++;
}
}
/*----------------------------------------------------------------*
* calculation of auto correlation
*---------------------------------------------------------------*/
public void autocorr(
float r[], /* (o) autocorrelation vector */
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
*---------------------------------------------------------------*/
public void window(
float z[], /* (o) the windowed data */
float x[], /* (i) the original data vector */
float y[], /* (i) the window */
int y_idx,
int N) /* (i) length of all vectors */
{
int i;
for (i = 0; i < N; i++) {
z[i] = x[i] * y[i+y_idx];
}
}
/*----------------------------------------------------------------*
* levinson-durbin solution for lpc coefficients
*---------------------------------------------------------------*/
public void levdurb(
float a[], /* (o) lpc coefficient vector starting
with 1.0f */
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.0f;
if (r[0] < ilbc_constants.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];
}
}
}
/*----------------------------------------------------------------*
* vector quantization
*---------------------------------------------------------------*/
public void vq(
float Xq[], /* (o) the quantized vector */
int Xq_idx,
int index[], /* (o) the quantization index */
int index_idx,
float CB[],/* (i) the vector quantization codebook */
int CB_idx,
float X[], /* (i) the vector to quantize */
int X_idx,
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 = ilbc_constants.DOUBLE_MAX;
minindex = 0;
for (j = 0; j < n_cb; j++) {
dist = X[X_idx] - CB[pos+CB_idx];
dist *= dist;
for (i = 1; i < dim; i++) {
tmp = X[i+X_idx] - CB[pos + i + CB_idx];
dist += tmp*tmp;
}
if (dist < mindist) {
mindist = dist;
minindex = j;
}
pos += dim;
}
for (i = 0; i < dim; i++) {
Xq[i+Xq_idx] = CB[minindex*dim + i+CB_idx];
}
index[index_idx] = minindex;
}
/*----------------------------------------------------------------*
* split vector quantization
*---------------------------------------------------------------*/
public void SplitVQ(
float qX[], /* (o) the quantized vector */
int qX_idx,
int index[], /* (o) a vector of indexes for all vector
codebooks in the split */
int index_idx,
float X[], /* (i) the vector to quantize */
int X_idx,
float CB[],/* (i) the quantizer codebook */
int nsplit, /* the number of vector splits */
int dim[], /* the dimension of X and qX */
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 + qX_idx, index, i + index_idx, CB, cb_pos, X, X_pos + X_idx, cbsize[i], dim[i]);
X_pos += dim[i];
cb_pos += dim[i] * cbsize[i];
}
}
/*----------------------------------------------------------------*
* scalar quantization
*---------------------------------------------------------------*/
public float sort_sq( /* on renvoie xq et on modifie index par effet de bord */
// float *xq, /* (o) the quantized value */
int index[], /* (o) the quantization index */
int index_idx,
float x, /* (i) the value to quantize */
float cb[],/* (i) the quantization codebook */
int cb_size) /* (i) the size of the quantization codebook */
{
int i;
float xq;
if (x <= cb[0]) {
// *index = 0;
index[index_idx] = 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[index_idx] = i;
xq = cb[i];
} else {
index[index_idx] = i - 1;
xq = cb[i - 1];
}
}
return xq;
}
/*---------------------------------------------------------------*
* Classification of subframes to localize start state
*--------------------------------------------------------------*/
int FrameClassify( /* index to the max-energy sub-frame */
float residual[]) /* (i) lpc residual signal */
{
float max_ssqEn;
float [] fssqEn = new float[ilbc_constants.NSUB_MAX];
float [] bssqEn = new float[ilbc_constants.NSUB_MAX];
int pp;
int n, l, max_ssqEn_n;
// float [] ssqEn_win[NSUB_MAX-1]={(float)0.8,(float)0.9,
float [] ssqEn_win = { (float)0.8,
(float)0.9,
(float)1.0f,
(float)0.9,
(float)0.8 };
float [] sampEn_win = { (float)1.0f/(float)6.0,
(float)2.0f/(float)6.0,
(float)3.0f/(float)6.0,
(float)4.0f/(float)6.0,
(float)5.0f/(float)6.0 };
/* init the front and back energies to zero */
for (int li = 0; li < ilbc_constants.NSUB_MAX; li++)
fssqEn[li] = 0.0f;
// memset(fssqEn, 0, NSUB_MAX*sizeof(float));
for (int li = 0; li < ilbc_constants.NSUB_MAX; li++)
bssqEn[li] = 0.0f;
// memset(bssqEn, 0, NSUB_MAX*sizeof(float));
/* Calculate front of first seqence */
n=0;
// pp=residual;
pp = 0;
for (l=0; l<5; l++) {
fssqEn[n] += sampEn_win[l] * (residual[pp]) * (residual[pp]);
pp++;
}
for (l=5; l<ilbc_constants.SUBL; l++) {
fssqEn[n] += (residual[pp]) * (residual[pp]);
pp++;
}
/* Calculate front and back of all middle sequences */
for (n=1; n < this.ULP_inst.nsub - 1; n++) {
// pp=residual+n*SUBL;
pp = n * ilbc_constants.SUBL;
for (l=0; l < 5; l++) {
fssqEn[n] += sampEn_win[l] * (residual[pp]) * (residual[pp]);
bssqEn[n] += (residual[pp]) * (residual[pp]);
pp++;
}
for (l=5; l<ilbc_constants.SUBL-5; l++) {
fssqEn[n] += (residual[pp]) * (residual[pp]);
bssqEn[n] += (residual[pp]) * (residual[pp]);
pp++;
}
for (l=ilbc_constants.SUBL-5; l<ilbc_constants.SUBL; l++) {
fssqEn[n] += (residual[pp]) * (residual[pp]);
bssqEn[n] += sampEn_win[ilbc_constants.SUBL-l-1] * (residual[pp]) * (residual[pp]);
pp++;
}
}
/* Calculate back of last seqence */
n=this.ULP_inst.nsub-1;
pp=n*ilbc_constants.SUBL;
for (l=0; l < ilbc_constants.SUBL-5; l++) {
bssqEn[n] += (residual[pp]) * (residual[pp]);
pp++;
}
for (l=ilbc_constants.SUBL-5; l<ilbc_constants.SUBL; l++) {
bssqEn[n] += sampEn_win[ilbc_constants.SUBL-l-1] * (residual[pp]) * (residual[pp]);
pp++;
}
/* find the index to the weighted 80 sample with
most energy */
if (this.ULP_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< this.ULP_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;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -