public void dec_gain(
int index, /* input : quantizer index */
float code[], /* input : fixed code book vector */
int l_subfr, /* input : subframe size */
int bfi, /* input : bad frame indicator good = 0 */
FloatPointer gain_pit, /* output: quantized acb gain */
FloatPointer gain_code /* output: quantized fcb gain */) {
int index1, index2;
float g_code;
FloatPointer gcode0 = new FloatPointer();
/*----------------- Test erasure ---------------*/
if (bfi != 0) {
gain_pit.value *= (float) 0.9;
if (gain_pit.value > (float) 0.9) gain_pit.value = (float) 0.9;
gain_code.value *= (float) 0.98;
/*----------------------------------------------*
* update table of past quantized energies *
* (frame erasure) *
*----------------------------------------------*/
GainPred.gain_update_erasure(past_qua_en);
return;
}
/*-------------- Decode pitch gain ---------------*/
index1 = TabLD8k.imap1[index / LD8KConstants.NCODE2];
index2 = TabLD8k.imap2[index % LD8KConstants.NCODE2];
gain_pit.value = TabLD8k.gbk1[index1][0] + TabLD8k.gbk2[index2][0];
/*-------------- Decode codebook gain ---------------*/
/*---------------------------------------------------*
*- energy due to innovation -*
*- predicted energy -*
*- predicted codebook gain => gcode0[exp_gcode0] -*
*---------------------------------------------------*/
GainPred.gain_predict(past_qua_en, code, l_subfr, gcode0);
/*-----------------------------------------------------------------*
* *gain_code = (gbk1[indice1][1]+gbk2[indice2][1]) * gcode0; *
*-----------------------------------------------------------------*/
g_code = TabLD8k.gbk1[index1][1] + TabLD8k.gbk2[index2][1];
gain_code.value = g_code * gcode0.value;
/*----------------------------------------------*
* update table of past quantized energies *
*----------------------------------------------*/
GainPred.gain_update(past_qua_en, g_code);
return;
}
/*----------------------------------------------------------------------------
* qua_gain - Quantization of pitch and codebook gains
*----------------------------------------------------------------------------
*/
int qua_gain(
/* output: quantizer index */
float code[], /* input : fixed codebook vector */
float[] g_coeff, /* input : correlation factors */
int l_subfr, /* input : fcb vector length */
FloatPointer gain_pit, /* output: quantized acb gain */
FloatPointer gain_code, /* output: quantized fcb gain */
int tameflag /* input : flag set to 1 if taming is needed */) {
/*
* MA prediction is performed on the innovation energy (in dB with mean *
* removed). *
* An initial predicted gain, g_0, is first determined and the correction *
* factor alpha = gain / g_0 is quantized. *
* The pitch gain and the correction factor are vector quantized and the *
* mean-squared weighted error criterion is used in the quantizer search. *
* CS Codebook , fast pre-selection version *
*/
int i, j, index1 = 0, index2 = 0;
IntegerPointer cand1 = new IntegerPointer(0), cand2 = new IntegerPointer(0);
FloatPointer gcode0 = new FloatPointer((float) 0);
float dist = 0;
float dist_min = 0;
float g_pitch = 0;
float g_code = 0;
float best_gain[] = new float[2], tmp;
/*---------------------------------------------------*
*- energy due to innovation -*
*- predicted energy -*
*- predicted codebook gain => gcode0[exp_gcode0] -*
*---------------------------------------------------*/
GainPred.gain_predict(past_qua_en, code, l_subfr, gcode0);
/*-- pre-selection --*/
tmp = (float) -1. / ((float) 4. * g_coeff[0] * g_coeff[2] - g_coeff[4] * g_coeff[4]);
best_gain[0] = ((float) 2. * g_coeff[2] * g_coeff[1] - g_coeff[3] * g_coeff[4]) * tmp;
best_gain[1] = ((float) 2. * g_coeff[0] * g_coeff[3] - g_coeff[1] * g_coeff[4]) * tmp;
if (tameflag == 1) {
if (best_gain[0] > LD8KConstants.GPCLIP2) best_gain[0] = LD8KConstants.GPCLIP2;
}
/*----------------------------------------------*
* - presearch for gain codebook - *
*----------------------------------------------*/
gbk_presel(best_gain, cand1, cand2, gcode0.value);
/*-- selection --*/
dist_min = LD8KConstants.FLT_MAX_G729;
if (tameflag == 1) {
for (i = 0; i < LD8KConstants.NCAN1; i++) {
for (j = 0; j < LD8KConstants.NCAN2; j++) {
g_pitch = TabLD8k.gbk1[cand1.value + i][0] + TabLD8k.gbk2[cand2.value + j][0];
if (g_pitch < LD8KConstants.GP0999) {
g_code =
gcode0.value
* (TabLD8k.gbk1[cand1.value + i][1] + TabLD8k.gbk2[cand2.value + j][1]);
dist =
g_pitch * g_pitch * g_coeff[0]
+ g_pitch * g_coeff[1]
+ g_code * g_code * g_coeff[2]
+ g_code * g_coeff[3]
+ g_pitch * g_code * g_coeff[4];
if (dist < dist_min) {
dist_min = dist;
index1 = cand1.value + i;
index2 = cand2.value + j;
}
}
}
}
} else {
for (i = 0; i < LD8KConstants.NCAN1; i++) {
for (j = 0; j < LD8KConstants.NCAN2; j++) {
g_pitch = TabLD8k.gbk1[cand1.value + i][0] + TabLD8k.gbk2[cand2.value + j][0];
g_code =
gcode0.value * (TabLD8k.gbk1[cand1.value + i][1] + TabLD8k.gbk2[cand2.value + j][1]);
dist =
g_pitch * g_pitch * g_coeff[0]
+ g_pitch * g_coeff[1]
+ g_code * g_code * g_coeff[2]
+ g_code * g_coeff[3]
+ g_pitch * g_code * g_coeff[4];
if (dist < dist_min) {
dist_min = dist;
index1 = cand1.value + i;
index2 = cand2.value + j;
}
}
}
}
gain_pit.value = TabLD8k.gbk1[index1][0] + TabLD8k.gbk2[index2][0];
g_code = TabLD8k.gbk1[index1][1] + TabLD8k.gbk2[index2][1];
gain_code.value = g_code * gcode0.value;
/*----------------------------------------------*
* update table of past quantized energies *
*----------------------------------------------*/
GainPred.gain_update(past_qua_en, g_code);
return (TabLD8k.map1[index1] * LD8KConstants.NCODE2 + TabLD8k.map2[index2]);
}