/*-----------------------------------------------------------*
* procedure dec_cng: *
* ~~~~~~~~ *
* Receives frame type *
* 0 : for untransmitted frames *
* 2 : for SID frames *
* Decodes SID frames *
* Computes current frame excitation *
* Computes current frame LSPs
*-----------------------------------------------------------*/
void dec_cng(
int past_ftyp, /* (i) : past frame type */
FLOAT sid_sav, /* (i) : energy to recover SID gain */
int *parm, /* (i) : coded SID parameters */
FLOAT *exc, /* (i/o) : excitation array */
FLOAT *lsp_old, /* (i/o) : previous lsp */
FLOAT *A_t, /* (o) : set of interpolated LPC coefficients */
INT16 *seed, /* (i/o) : random generator seed */
FLOAT freq_prev[MA_NP][M] /* (i/o) : previous LPS for quantization */
)
{
FLOAT temp;
int ind;
/* SID Frame */
/*************/
if(parm[0] != 0) {
sid_gain = tab_Sidgain[parm[4]];
/* Inverse quantization of the LSP */
sid_lsfq_decode(&parm[1], lspSid, freq_prev);
}
/* non SID Frame */
/*****************/
else {
/* Case of 1st SID frame erased : quantize-decode */
/* energy estimate stored in sid_gain */
if(past_ftyp > 1) {
qua_Sidgain(&sid_sav, 0, &temp, &ind);
sid_gain = tab_Sidgain[ind];
}
}
if(past_ftyp > 1) {
cur_gain = sid_gain;
}
else {
cur_gain *= A_GAIN0;
cur_gain += A_GAIN1 * sid_gain;
}
calc_exc_rand(cur_gain, exc, seed, FLAG_DEC);
/* Interpolate the Lsp vectors */
int_qlpc(lsp_old, lspSid, A_t);
copy(lspSid, lsp_old, M);
return;
}
/*--------------------------------------------------------------------------
* decod_ld8k - decoder
*--------------------------------------------------------------------------
*/
void decod_ld8k(
int parm[], /* input : synthesis parameters (parm[0] = bfi) */
int voicing, /* input : voicing decision from previous frame */
FLOAT synth[], /* output: synthesized speech */
FLOAT A_t[], /* output: two sets of A(z) coefficients length=2*MP1 */
int *t0_first /* output: integer delay of first subframe */
)
{
FLOAT *Az; /* Pointer to A_t (LPC coefficients) */
FLOAT lsp_new[M]; /* LSPs */
FLOAT code[L_SUBFR]; /* algebraic codevector */
/* Scalars */
int i, i_subfr;
int t0, t0_frac, index;
int bfi;
int bad_pitch;
/* Test bad frame indicator (bfi) */
bfi = *parm++;
/* Decode the LSPs */
d_lsp(parm, lsp_new, bfi);
parm += 2; /* Advance synthesis parameters pointer */
/* Interpolation of LPC for the 2 subframes */
int_qlpc(lsp_old, lsp_new, A_t);
/* update the LSFs for the next frame */
copy(lsp_new, lsp_old, M);
/*------------------------------------------------------------------------*
* Loop for every subframe in the analysis frame *
*------------------------------------------------------------------------*
* The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR *
* times *
* - decode the pitch delay *
* - decode algebraic code *
* - decode pitch and codebook gains *
* - find the excitation and compute synthesis speech *
*------------------------------------------------------------------------*/
Az = A_t; /* pointer to interpolated LPC parameters */
for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) {
index = *parm++; /* pitch index */
if (i_subfr == 0) { /* if first subframe */
i = *parm++; /* get parity check result */
bad_pitch = bfi+ i;
if( bad_pitch == 0)
{
dec_lag3(index, PIT_MIN, PIT_MAX, i_subfr, &t0, &t0_frac);
old_t0 = t0;
}
else /* Bad frame, or parity error */
{
t0 = old_t0;
t0_frac = 0;
old_t0++;
if( old_t0> PIT_MAX) {
old_t0 = PIT_MAX;
}
}
*t0_first = t0; /* If first frame */
}
else /* second subframe */
{
if( bfi == 0)
{
dec_lag3(index, PIT_MIN, PIT_MAX, i_subfr, &t0, &t0_frac);
old_t0 = t0;
}
else
{
t0 = old_t0;
t0_frac = 0;
old_t0++;
if( old_t0 >PIT_MAX) {
old_t0 = PIT_MAX;
}
}
}
/*-------------------------------------------------*
* - Find the adaptive codebook vector. *
*--------------------------------------------------*/
pred_lt_3(&exc[i_subfr], t0, t0_frac, L_SUBFR);
/*-------------------------------------------------------*
* - Decode innovative codebook. *
* - Add the fixed-gain pitch contribution to code[]. *
*-------------------------------------------------------*/
if(bfi != 0) { /* Bad Frame Error Concealment */
parm[0] = (int) (random_g729() & 0x1fff); /* 13 bits random*/
parm[1]= (int) (random_g729() & 0x000f); /* 4 bits random */
}
decod_ACELP(parm[1], parm[0], code);
parm +=2;
for (i = t0; i < L_SUBFR; i++) code[i] += sharp * code[i-t0];
/*-------------------------------------------------*
* - Decode pitch and codebook gains. *
*-------------------------------------------------*/
index = *parm++; /* index of energy VQ */
dec_gain(index, code, L_SUBFR, bfi, &gain_pitch, &gain_code);
/*-------------------------------------------------------------*
* - Update pitch sharpening "sharp" with quantized gain_pitch *
*-------------------------------------------------------------*/
sharp = gain_pitch;
if (sharp > SHARPMAX) sharp = SHARPMAX;
if (sharp < SHARPMIN) sharp = SHARPMIN;
/*-------------------------------------------------------*
* - Find the total excitation. *
*-------------------------------------------------------*/
if(bfi != 0 ) {
if(voicing == 0) { /* for unvoiced frame */
for (i = 0; i < L_SUBFR; i++) {
exc[i+i_subfr] = gain_code*code[i];
}
} else { /* for voiced frame */
for (i = 0; i < L_SUBFR; i++) {
exc[i+i_subfr] = gain_pitch*exc[i+i_subfr];
}
}
} else { /* No frame errors */
for (i = 0; i < L_SUBFR; i++) {
exc[i+i_subfr] = gain_pitch*exc[i+i_subfr] + gain_code*code[i];
}
}
/*-------------------------------------------------------*
* - Find synthesis speech corresponding to exc[]. *
*-------------------------------------------------------*/
syn_filt(Az, &exc[i_subfr], &synth[i_subfr], L_SUBFR, mem_syn, 1);
Az += MP1; /* interpolated LPC parameters for next subframe */
}
/*--------------------------------------------------*
* Update signal for next frame. *
* -> shift to the left by L_FRAME exc[] *
*--------------------------------------------------*/
copy(&old_exc[L_FRAME], &old_exc[0], PIT_MAX+L_INTERPOL);
return;
}
/*-----------------------------------------------------------*
* procedure cod_cng: *
* ~~~~~~~~ *
* computes DTX decision *
* encodes SID frames *
* computes CNG excitation for encoder update *
*-----------------------------------------------------------*/
void cod_cng(float * exc, /* (i/o) : excitation array */
int pastVad, /* (i) : previous VAD decision */
float * lsp_old_q, /* (i/o) : previous quantized lsp */
float * old_A, /* (i/o) : last stable filter LPC coefficients */
float * old_rc, /* (i/o) : last stable filter Reflection coefficients. */
float * Aq, /* (o) : set of interpolated LPC coefficients */
int *ana, /* (o) : coded SID parameters */
float freq_prev[MA_NP][M], /* (i/o) : previous LPS for quantization */
int16_t * seed /* (i/o) : random generator seed */
)
{
int i;
float curAcf[MP1];
float bid[MP1];
float curCoeff[MP1];
float lsp_new[M];
float *lpcCoeff;
int cur_igain;
float energyq;
/* Update Ener */
for (i = NB_GAIN - 1; i >= 1; i--) {
ener[i] = ener[i - 1];
}
/* Compute current Acfs */
calc_sum_acf(Acf, curAcf, NB_CURACF);
/* Compute LPC coefficients and residual energy */
if (curAcf[0] == (float) 0.) {
ener[0] = (float) 0.; /* should not happen */
} else {
ener[0] = levinsone(M, curAcf, curCoeff, bid, old_A, old_rc);
}
/* if first frame of silence => SID frame */
if (pastVad != 0) {
ana[0] = 1;
count_fr0 = 0;
nb_ener = 1;
qua_Sidgain(ener, nb_ener, &energyq, &cur_igain);
} else {
nb_ener++;
if (nb_ener > NB_GAIN)
nb_ener = NB_GAIN;
qua_Sidgain(ener, nb_ener, &energyq, &cur_igain);
/* Compute stationarity of current filter */
/* versus reference filter */
if (cmp_filt(RCoeff, curAcf, ener[0], THRESH1) != 0) {
flag_chang = 1;
}
/* compare energy difference between current frame and last frame */
if ((float) fabs(prev_energy - energyq) > (float) 2.0)
flag_chang = 1;
count_fr0++;
if (count_fr0 < FR_SID_MIN) {
ana[0] = 0; /* no transmission */
} else {
if (flag_chang != 0) {
ana[0] = 1; /* transmit SID frame */
} else {
ana[0] = 0;
}
count_fr0 = FR_SID_MIN; /* to avoid overflow */
}
}
if (ana[0] == 1) {
/* Reset frame count and change flag */
count_fr0 = 0;
flag_chang = 0;
/* Compute past average filter */
calc_pastfilt(pastCoeff, old_A, old_rc);
calc_RCoeff(pastCoeff, RCoeff);
/* Compute stationarity of current filter */
/* versus past average filter */
/* if stationary */
/* transmit average filter => new ref. filter */
if (cmp_filt(RCoeff, curAcf, ener[0], THRESH2) == 0) {
lpcCoeff = pastCoeff;
}
/* else */
/* transmit current filter => new ref. filter */
else {
lpcCoeff = curCoeff;
calc_RCoeff(curCoeff, RCoeff);
}
/* Compute SID frame codes */
az_lsp(lpcCoeff, lsp_new, lsp_old_q); /* From A(z) to lsp */
/* LSP quantization */
lsfq_noise(lsp_new, lspSid_q, freq_prev, &ana[1]);
prev_energy = energyq;
ana[4] = cur_igain;
sid_gain = tab_Sidgain[cur_igain];
}
/* end of SID frame case */
/* Compute new excitation */
if (pastVad != 0) {
cur_gain = sid_gain;
} else {
cur_gain *= A_GAIN0;
cur_gain += A_GAIN1 * sid_gain;
}
calc_exc_rand(cur_gain, exc, seed, FLAG_COD);
int_qlpc(lsp_old_q, lspSid_q, Aq);
for (i = 0; i < M; i++) {
lsp_old_q[i] = lspSid_q[i];
}
/* Update sumAcf if fr_cur = 0 */
if (fr_cur == 0) {
update_sumAcf();
}
return;
}
void decod_ld8a(struct dec_state_t * state,
int parm[], /* (i) : vector of synthesis parameters
parm[0] = bad frame indicator (bfi) */
GFLOAT synth[], /* (o) : synthesis speech */
GFLOAT A_t[], /* (o) : decoded LP filter in 2 subframes */
int *T2, /* (o) : decoded pitch lag in 2 subframes */
int *Vad /* (o) : decoded frame type */
)
{
GFLOAT *Az; /* Pointer on A_t */
GFLOAT lsp_new[M]; /* Decoded LSP's */
GFLOAT code[L_SUBFR]; /* ACELP codevector */
/* Scalars */
int i, i_subfr;
int t0, t0_frac, index;
int bfi, bad_pitch;
/* for G.729B */
int ftyp;
GFLOAT lsfq_mem[MA_NP][M];
/* Test bad frame indicator (bfi) */
bfi = *parm++;
/* for G.729B */
ftyp = *parm;
if (bfi)
{
if(state->past_ftyp == 1)
ftyp = 1;
else
ftyp = 0;
*parm = ftyp; /* modification introduced in version V1.3 */
}
*Vad = ftyp;
/* Processing non active frames (SID & not transmitted) */
if(ftyp != 1)
{
get_freq_prev((const GFLOAT (*)[M]) state->lsp_s.freq_prev, lsfq_mem);
dec_cng(&state->cng_s, state->past_ftyp, state->sid_sav, parm, state->exc, state->lsp_old,
A_t, &state->seed, lsfq_mem);
update_freq_prev(state->lsp_s.freq_prev, (const GFLOAT (*)[M]) lsfq_mem);
Az = A_t;
for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
{
syn_filt(Az, &state->exc[i_subfr], &synth[i_subfr], L_SUBFR, state->mem_syn, 0);
copy(&synth[i_subfr+L_SUBFR-M], state->mem_syn, M);
Az += MP1;
*T2++ = state->old_t0;
}
state->sharp = SHARPMIN;
}
else /* Processing active frame */
{
state->seed = INIT_SEED;
parm++;
/* Decode the LSPs */
d_lsp(&state->lsp_s, parm, lsp_new, bfi+state->bad_lsf );
parm += 2; /* Advance synthesis parameters pointer */
/*
Note: "bad_lsf" is introduce in case the standard is used with
channel protection.
*/
/* Interpolation of LPC for the 2 subframes */
int_qlpc(state->lsp_old, lsp_new, A_t);
/* update the LSFs for the next frame */
copy(lsp_new, state->lsp_old, M);
/*------------------------------------------------------------------------*
* Loop for every subframe in the analysis frame *
*------------------------------------------------------------------------*
* The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR *
* times *
* - decode the pitch delay *
* - decode algebraic code *
* - decode pitch and codebook gains *
* - find the excitation and compute synthesis speech *
*------------------------------------------------------------------------*/
Az = A_t; /* pointer to interpolated LPC parameters */
for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
{
/*-------------------------------------------------*
* - Find the adaptive codebook vector. *
*--------------------------------------------------*/
index = *parm++; /* pitch index */
if (i_subfr == 0)
{
i = *parm++; /* get parity check result */
bad_pitch = bfi + i;
if( bad_pitch == 0)
{
dec_lag3(index, PIT_MIN, PIT_MAX, i_subfr, &t0, &t0_frac);
state->old_t0 = t0;
}
else /* Bad frame, or parity error */
{
t0 = state->old_t0;
t0_frac = 0;
state->old_t0++;
if( (state->old_t0 - PIT_MAX) > 0)
state->old_t0 = PIT_MAX;
}
}
else /* second subframe */
{
if( bfi == 0)
{
dec_lag3(index, PIT_MIN, PIT_MAX, i_subfr, &t0, &t0_frac);
state->old_t0 = t0;
}
else
{
t0 = state->old_t0;
t0_frac = 0;
state->old_t0++;
if( (state->old_t0 - PIT_MAX) > 0)
state->old_t0 = PIT_MAX;
}
}
*T2++ = t0;
/*-------------------------------------------------*
* - Find the adaptive codebook vector. *
*-------------------------------------------------*/
pred_lt_3(&state->exc[i_subfr], t0, t0_frac, L_SUBFR);
/*-------------------------------------------------------*
* - Decode innovative codebook. *
* - Add the fixed-gain pitch contribution to code[]. *
*-------------------------------------------------------*/
if(bfi != 0) /* Bad frame */
{
parm[0] = random_g729(&state->seed_fer) & (INT16)0x1fff; /* 13 bits random */
parm[1] = random_g729(&state->seed_fer) & (INT16)0x000f; /* 4 bits random */
}
decod_ACELP(parm[1], parm[0], code);
parm +=2;
for (i = t0; i < L_SUBFR; i++) code[i] += state->sharp * code[i-t0];
/*-------------------------------------------------*
* - Decode pitch and codebook gains. *
*-------------------------------------------------*/
index = *parm++; /* index of energy VQ */
dec_gain(&state->gain_s, index, code, L_SUBFR, bfi, &state->gain_pitch, &state->gain_code);
/*-------------------------------------------------------------*
* - Update pitch sharpening "sharp" with quantized gain_pitch *
*-------------------------------------------------------------*/
state->sharp = state->gain_pitch;
if (state->sharp > SHARPMAX) state->sharp = SHARPMAX;
if (state->sharp < SHARPMIN) state->sharp = SHARPMIN;
/*-------------------------------------------------------*
* - Find the total excitation. *
* - Find synthesis speech corresponding to exc[]. *
*-------------------------------------------------------*/
for (i = 0; i < L_SUBFR; i++)
state->exc[i+i_subfr] = state->gain_pitch*state->exc[i+i_subfr] + state->gain_code*code[i];
syn_filt(Az, &state->exc[i_subfr], &synth[i_subfr], L_SUBFR, state->mem_syn, 1);
Az += MP1; /* interpolated LPC parameters for next subframe */
}
}
/*------------*
* For G729b
*-----------*/
if (bfi == 0)
{
state->sid_sav = (F)0.0;
for (i=0; i<L_FRAME; i++)
state->sid_sav += state->exc[i] * state->exc[i];
}
state->past_ftyp = ftyp;
/*--------------------------------------------------*
* Update signal for next frame. *
* -> shift to the left by L_FRAME exc[] *
*--------------------------------------------------*/
copy(&state->old_exc[L_FRAME], &state->old_exc[0], PIT_MAX+L_INTERPOL);
}
void coder_ld8a(
int ana[] /* output: analysis parameters */
)
{
/* LPC coefficients */
FLOAT Aq_t[(MP1)*2]; /* A(z) quantized for the 2 subframes */
FLOAT Ap_t[(MP1)*2]; /* A(z) with spectral expansion */
FLOAT *Aq, *Ap; /* Pointer on Aq_t and Ap_t */
/* Other vectors */
FLOAT h1[L_SUBFR]; /* Impulse response h1[] */
FLOAT xn[L_SUBFR]; /* Target vector for pitch search */
FLOAT xn2[L_SUBFR]; /* Target vector for codebook search */
FLOAT code[L_SUBFR]; /* Fixed codebook excitation */
FLOAT y1[L_SUBFR]; /* Filtered adaptive excitation */
FLOAT y2[L_SUBFR]; /* Filtered fixed codebook excitation */
FLOAT g_coeff[5]; /* Correlations between xn, y1, & y2:
<y1,y1>, <xn,y1>, <y2,y2>, <xn,y2>,<y1,y2>*/
/* Scalars */
int i, j, i_subfr;
int T_op, T0, T0_min, T0_max, T0_frac;
int index;
FLOAT gain_pit, gain_code;
int taming;
/*------------------------------------------------------------------------*
* - Perform LPC analysis: *
* * autocorrelation + lag windowing *
* * Levinson-durbin algorithm to find a[] *
* * convert a[] to lsp[] *
* * quantize and code the LSPs *
* * find the interpolated LSPs and convert to a[] for the 2 *
* subframes (both quantized and unquantized) *
*------------------------------------------------------------------------*/
{
/* Temporary vectors */
FLOAT r[MP1]; /* Autocorrelations */
FLOAT rc[M]; /* Reflexion coefficients */
FLOAT lsp_new[M]; /* lsp coefficients */
FLOAT lsp_new_q[M]; /* Quantized lsp coeff. */
/* LP analysis */
autocorr(p_window, M, r); /* Autocorrelations */
lag_window(M, r); /* Lag windowing */
levinson(r, Ap_t, rc); /* Levinson Durbin */
az_lsp(Ap_t, lsp_new, lsp_old); /* Convert A(z) to lsp */
/* LSP quantization */
qua_lsp(lsp_new, lsp_new_q, ana);
ana += 2; /* Advance analysis parameters pointer */
/*--------------------------------------------------------------------*
* Find interpolated LPC parameters in all subframes *
* The interpolated parameters are in array Aq_t[]. *
*--------------------------------------------------------------------*/
int_qlpc(lsp_old_q, lsp_new_q, Aq_t);
/* Compute A(z/gamma) */
weight_az(&Aq_t[0], GAMMA1, M, &Ap_t[0]);
weight_az(&Aq_t[MP1], GAMMA1, M, &Ap_t[MP1]);
/* update the LSPs for the next frame */
copy(lsp_new, lsp_old, M);
copy(lsp_new_q, lsp_old_q, M);
}
/*----------------------------------------------------------------------*
* - Find the weighted input speech w_sp[] for the whole speech frame *
* - Find the open-loop pitch delay for the whole speech frame *
* - Set the range for searching closed-loop pitch in 1st subframe *
*----------------------------------------------------------------------*/
residu(&Aq_t[0], &speech[0], &exc[0], L_SUBFR);
residu(&Aq_t[MP1], &speech[L_SUBFR], &exc[L_SUBFR], L_SUBFR);
{
FLOAT Ap1[MP1];
Ap = Ap_t;
Ap1[0] = (F)1.0;
for(i=1; i<=M; i++)
Ap1[i] = Ap[i] - (F)0.7 * Ap[i-1];
syn_filt(Ap1, &exc[0], &wsp[0], L_SUBFR, mem_w, 1);
Ap += MP1;
for(i=1; i<=M; i++)
Ap1[i] = Ap[i] - (F)0.7 * Ap[i-1];
syn_filt(Ap1, &exc[L_SUBFR], &wsp[L_SUBFR], L_SUBFR, mem_w, 1);
}
/* Find open loop pitch lag for whole speech frame */
T_op = pitch_ol_fast(wsp, L_FRAME);
/* Range for closed loop pitch search in 1st subframe */
T0_min = T_op - 3;
if (T0_min < PIT_MIN) T0_min = PIT_MIN;
T0_max = T0_min + 6;
if (T0_max > PIT_MAX)
{
T0_max = PIT_MAX;
T0_min = T0_max - 6;
}
/*------------------------------------------------------------------------*
* Loop for every subframe in the analysis frame *
*------------------------------------------------------------------------*
* To find the pitch and innovation parameters. The subframe size is *
* L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times. *
* - find the weighted LPC coefficients *
* - find the LPC residual signal *
* - compute the target signal for pitch search *
* - compute impulse response of weighted synthesis filter (h1[]) *
* - find the closed-loop pitch parameters *
* - encode the pitch delay *
* - find target vector for codebook search *
* - codebook search *
* - VQ of pitch and codebook gains *
* - update states of weighting filter *
*------------------------------------------------------------------------*/
Aq = Aq_t; /* pointer to interpolated quantized LPC parameters */
Ap = Ap_t; /* pointer to weighted LPC coefficients */
for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
{
/*---------------------------------------------------------------*
* Compute impulse response, h1[], of weighted synthesis filter *
*---------------------------------------------------------------*/
h1[0] = (F)1.0;
set_zero(&h1[1], L_SUBFR-1);
syn_filt(Ap, h1, h1, L_SUBFR, &h1[1], 0);
/*-----------------------------------------------*
* Find the target vector for pitch search: *
*----------------------------------------------*/
syn_filt(Ap, &exc[i_subfr], xn, L_SUBFR, mem_w0, 0);
/*-----------------------------------------------------------------*
* Closed-loop fractional pitch search *
*-----------------------------------------------------------------*/
T0 = pitch_fr3_fast(&exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max,
i_subfr, &T0_frac);
index = enc_lag3(T0, T0_frac, &T0_min, &T0_max, PIT_MIN, PIT_MAX,
i_subfr);
*ana++ = index;
if (i_subfr == 0)
*ana++ = parity_pitch(index);
/*-----------------------------------------------------------------*
* - find filtered pitch exc *
* - compute pitch gain and limit between 0 and 1.2 *
* - update target vector for codebook search *
* - find LTP residual. *
*-----------------------------------------------------------------*/
syn_filt(Ap, &exc[i_subfr], y1, L_SUBFR, mem_zero, 0);
gain_pit = g_pitch(xn, y1, g_coeff, L_SUBFR);
/* clip pitch gain if taming is necessary */
taming = test_err(T0, T0_frac);
if( taming == 1){
if (gain_pit > GPCLIP) {
gain_pit = GPCLIP;
}
}
for (i = 0; i < L_SUBFR; i++)
xn2[i] = xn[i] - y1[i]*gain_pit;
/*-----------------------------------------------------*
* - Innovative codebook search. *
*-----------------------------------------------------*/
index = ACELP_code_A(xn2, h1, T0, sharp, code, y2, &i);
*ana++ = index; /* Positions index */
*ana++ = i; /* Signs index */
/*------------------------------------------------------*
* - Compute the correlations <y2,y2>, <xn,y2>, <y1,y2>*
* - Vector quantize gains. *
*------------------------------------------------------*/
corr_xy2(xn, y1, y2, g_coeff);
*ana++ =qua_gain(code, g_coeff, L_SUBFR, &gain_pit, &gain_code,
taming);
/*------------------------------------------------------------*
* - Update pitch sharpening "sharp" with quantized gain_pit *
*------------------------------------------------------------*/
sharp = gain_pit;
if (sharp > SHARPMAX) sharp = SHARPMAX;
if (sharp < SHARPMIN) sharp = SHARPMIN;
/*------------------------------------------------------*
* - Find the total excitation *
* - update filters' memories for finding the target *
* vector in the next subframe (mem_w0[]) *
*------------------------------------------------------*/
for (i = 0; i < L_SUBFR; i++)
exc[i+i_subfr] = gain_pit*exc[i+i_subfr] + gain_code*code[i];
update_exc_err(gain_pit, T0);
for (i = L_SUBFR-M, j = 0; i < L_SUBFR; i++, j++)
mem_w0[j] = xn[i] - gain_pit*y1[i] - gain_code*y2[i];
Aq += MP1; /* interpolated LPC parameters for next subframe */
Ap += MP1;
}
/*--------------------------------------------------*
* Update signal for next frame. *
* -> shift to the left by L_FRAME: *
* speech[], wsp[] and exc[] *
*--------------------------------------------------*/
copy(&old_speech[L_FRAME], &old_speech[0], L_TOTAL-L_FRAME);
copy(&old_wsp[L_FRAME], &old_wsp[0], PIT_MAX);
copy(&old_exc[L_FRAME], &old_exc[0], PIT_MAX+L_INTERPOL);
return;
}
/*--------------------------------------------------------------------------
* decod_ld8c - decoder
*--------------------------------------------------------------------------
*/
void decod_ld8c(
int parm[], /* (i) : vector of synthesis parameters
parm[0] = bad frame indicator (bfi) */
int voicing, /* (i) : voicing decision from previous frame */
FLOAT synth_buf[], /* (i/o) : synthesis speech */
FLOAT Az_dec[], /* (o) : decoded LP filter in 2 subframes */
int *t0_first, /* (o) : decoded pitch lag in first subframe */
int *bwd_dominant,/* (o) : bwd dominant indicator */
int *m_pst, /* (o) : LPC order for postfilter */
int *Vad /* output: decoded frame type */
)
{
/* Scalars */
int i, j, i_subfr;
int t0, t0_frac, index;
int bfi;
int lp_mode; /* Backward / Forward mode indication */
FLOAT g_p, g_c; /* fixed and adaptive codebook gain */
int bad_pitch; /* bad pitch indicator */
FLOAT tmp;
FLOAT energy;
int rate;
/* Tables */
FLOAT A_t_bwd[2*M_BWDP1]; /* LPC Backward filter */
FLOAT A_t_fwd[2*MP1]; /* LPC Forward filter */
FLOAT rc_bwd[M_BWD]; /* LPC backward reflection coefficients */
FLOAT r_bwd[M_BWDP1]; /* Autocorrelations (backward) */
FLOAT lsp_new[M]; /* LSPs */
FLOAT code[L_SUBFR]; /* ACELP codevector */
FLOAT exc_phdisp[L_SUBFR]; /* excitation after phase dispersion */
FLOAT *pA_t; /* Pointer on A_t */
int stationnary;
int m_aq;
FLOAT *synth;
int sat_filter;
/* for G.729B */
int ftyp;
FLOAT lsfq_mem[MA_NP][M];
synth = synth_buf + MEM_SYN_BWD;
/* Test bad frame indicator (bfi) */
bfi = *parm++;
/* Test frame type */
ftyp = *parm++;
if(bfi == 1) {
ftyp = past_ftyp;
if(ftyp == 1) ftyp = 0;
if(ftyp > 2) { /* G.729 maintenance */
if(ftyp == 3) parm[4] = 1;
else {
if(prev_lp_mode == 0) parm[5] = 1;
else parm[3] = 1;
}
}
parm[-1] = ftyp;
}
*Vad = ftyp;
rate = ftyp - 2;
/* Decoding the Backward/Forward LPC decision */
/* ------------------------------------------ */
if( rate != G729E) lp_mode = 0;
else {
if (bfi != 0) {
lp_mode = prev_lp_mode; /* Frame erased => lp_mode = previous lp_mode */
*parm++ = lp_mode;
}
else {
lp_mode = *parm++;
}
if(prev_bfi != 0) voicing = prev_voicing;
}
if( bfi == 0) {
c_muting = (F)1.;
count_bfi = 0;
}
/* -------------------- */
/* Backward LP analysis */
/* -------------------- */
if (rate == G729E) {
/* LPC recursive Window as in G728 */
autocorr_hyb_window(synth_buf, r_bwd, rexp); /* Autocorrelations */
lag_window_bwd(r_bwd); /* Lag windowing */
/* Levinson (as in G729) */
levinsone(M_BWD, r_bwd, &A_t_bwd[M_BWDP1], rc_bwd,
old_A_bwd, old_rc_bwd );
/* Tests saturation of A_t_bwd */
sat_filter = 0;
for (i=M_BWDP1; i<2*M_BWDP1; i++) if (A_t_bwd[i] >= (F)8.) sat_filter = 1;
if (sat_filter == 1) copy(A_t_bwd_mem, &A_t_bwd[M_BWDP1], M_BWDP1);
else copy(&A_t_bwd[M_BWDP1], A_t_bwd_mem, M_BWDP1);
/* Additional bandwidth expansion on backward filter */
weight_az(&A_t_bwd[M_BWDP1], GAMMA_BWD, M_BWD, &A_t_bwd[M_BWDP1]);
}
/*--------------------------------------------------*
* Update synthesis signal for next frame. *
*--------------------------------------------------*/
copy(&synth_buf[L_FRAME], &synth_buf[0], MEM_SYN_BWD);
if(lp_mode == 1) {
if ((c_fe != (F)0.)) {
/* Interpolation of the backward filter after a bad frame */
/* A_t_bwd(z) = c_fe . A_bwd_mem(z) + (1 - c_fe) . A_t_bwd(z) */
/* ---------------------------------------------------------- */
tmp = (F)1. - c_fe;
pA_t = A_t_bwd + M_BWDP1;
for (i=0; i<M_BWDP1; i++) {
pA_t[i] *= tmp;
pA_t[i] += c_fe * A_bwd_mem[i];
}
}
}
/* Memorize the last good backward filter when the frame is erased */
if ((bfi != 0)&&(prev_bfi == 0) && (past_ftyp >3))
copy(&A_t_bwd[M_BWDP1], A_bwd_mem, M_BWDP1);
/* for G.729B */
/* Processing non active frames (SID & not transmitted: ftyp = 1 or 0) */
if(ftyp < 2) {
/* get_decfreq_prev(lsfq_mem); */
for (i=0; i<MA_NP; i++)
copy(&freq_prev[i][0], &lsfq_mem[i][0], M);
dec_cng(past_ftyp, sid_sav, &parm[-1], exc, lsp_old,
A_t_fwd, &seed, lsfq_mem);
/* update_decfreq_prev(lsfq_mem); */
for (i=0; i<MA_NP; i++)
copy(&lsfq_mem[i][0], &freq_prev[i][0], M);
pA_t = A_t_fwd;
for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) {
syn_filte(M, pA_t, &exc[i_subfr], &synth[i_subfr], L_SUBFR, &mem_syn[M_BWD-M], 0);
copy(&synth[i_subfr+L_SUBFR-M_BWD], mem_syn, M_BWD);
*t0_first = prev_t0;
pA_t += MP1;
}
sharp = SHARPMIN;
c_int = (F)1.1;
/* for gain decoding in case of frame erasure */
stat_bwd = 0;
stationnary = 0;
/* for pitch tracking in case of frame erasure */
stat_pitch = 0;
/* update the previous filter for the next frame */
copy(&A_t_fwd[MP1], prev_filter, MP1);
for(i=MP1; i<M_BWDP1; i++) prev_filter[i] = (F)0.;
}
/***************************/
/* Processing active frame */
/***************************/
else {
seed = INIT_SEED;
/* ---------------------------- */
/* LPC decoding in forward mode */
/* ---------------------------- */
if (lp_mode == 0) {
/* Decode the LSPs */
d_lspe(parm, lsp_new, bfi, freq_prev, prev_lsp, &prev_ma);
parm += 2;
if( prev_lp_mode == 0) { /* Interpolation of LPC for the 2 subframes */
int_qlpc(lsp_old, lsp_new, A_t_fwd);
}
else {
/* no interpolation */
lsp_az(lsp_new, A_t_fwd); /* Subframe 1*/
copy(A_t_fwd, &A_t_fwd[MP1], MP1); /* Subframe 2 */
}
/* update the LSFs for the next frame */
copy(lsp_new, lsp_old, M);
c_int = (F)1.1;
pA_t = A_t_fwd;
m_aq = M;
/* update the previous filter for the next frame */
copy(&A_t_fwd[MP1], prev_filter, MP1);
for(i=MP1; i<M_BWDP1; i++) prev_filter[i] = (F)0.;
}
else {
int_bwd(A_t_bwd, prev_filter, &c_int);
pA_t = A_t_bwd;
m_aq = M_BWD;
/* update the previous filter for the next frame */
copy(&A_t_bwd[M_BWDP1], prev_filter, M_BWDP1);
}
/*------------------------------------------------------------------------*
* Loop for every subframe in the analysis frame *
*------------------------------------------------------------------------*
* The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR *
* times *
* - decode the pitch delay *
* - decode algebraic code *
* - decode pitch and codebook gains *
* - find the excitation and compute synthesis speech *
*------------------------------------------------------------------------*/
for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) {
index = *parm++; /* pitch index */
if(i_subfr == 0) {
if (rate == G729D)
i = 0; /* no pitch parity at 6.4 kb/s */
else
i = *parm++; /* get parity check result */
bad_pitch = bfi + i;
if( bad_pitch == 0) {
dec_lag3cp(index, PIT_MIN, PIT_MAX, i_subfr, &t0, &t0_frac, rate);
prev_t0 = t0;
prev_t0_frac = t0_frac;
}
else { /* Bad frame, or parity error */
if (bfi == 0) printf(" ! Wrong Pitch 1st subfr. ! ");
t0 = prev_t0;
if (rate == G729E) {
t0_frac = prev_t0_frac;
}
else {
t0_frac = 0;
prev_t0++;
if(prev_t0 > PIT_MAX) {
prev_t0 = PIT_MAX;
}
}
}
*t0_first = t0; /* If first frame */
}
else { /* second subframe */
if( bfi == 0) {
dec_lag3cp(index, PIT_MIN, PIT_MAX, i_subfr, &t0, &t0_frac, rate);
prev_t0 = t0;
prev_t0_frac = t0_frac;
}
else {
t0 = prev_t0;
if (rate == G729E) {
t0_frac = prev_t0_frac;
}
else {
t0_frac = 0;
prev_t0++;
if(prev_t0 > PIT_MAX) prev_t0 = PIT_MAX;
}
}
}
/*-------------------------------------------------*
* - Find the adaptive codebook vector. *
*-------------------------------------------------*/
pred_lt_3(&exc[i_subfr], t0, t0_frac, L_SUBFR);
/* --------------------------------- */
/* pitch tracking for frame erasures */
/* --------------------------------- */
if( rate == G729E) {
track_pit(&prev_t0, &prev_t0_frac, &prev_pitch, &stat_pitch,
&pitch_sta, &frac_sta);
}
else {
i = prev_t0;
j = prev_t0_frac;
track_pit(&i, &j, &prev_pitch, &stat_pitch,
&pitch_sta, &frac_sta);
}
/*-------------------------------------------------------*
* - Decode innovative codebook. *
*-------------------------------------------------------*/
if(bfi != 0) { /* Bad frame */
parm[0] = (int)random_g729c(&seed_fer);
parm[1] = (int)random_g729c(&seed_fer);
if (rate == G729E) {
parm[2] = (int)random_g729c(&seed_fer);
parm[3] = (int)random_g729c(&seed_fer);
parm[4] = (int)random_g729c(&seed_fer);
}
}
stationnary = 0; /* to avoid visual warning */
if (rate == G729) {
/* case 8 kbps */
decod_ACELP(parm[1], parm[0], code);
parm += 2;
/* for gain decoding in case of frame erasure */
stat_bwd = 0;
stationnary = 0;
}
else if (rate == G729D) {
/* case 8 kbps */
decod_ACELP64(parm[1], parm[0], code);
parm += 2;
/* for gain decoding in case of frame erasure */
stat_bwd = 0;
stationnary = 0;
}
else if (rate == G729E) {
/* case 11.8 kbps */
if (lp_mode == 0) {
dec_ACELP_10i40_35bits(parm, code);
/* for gain decoding in case of frame erasure */
stat_bwd = 0;
stationnary = 0;
}
else {
dec_ACELP_12i40_44bits(parm, code);
/* for gain decoding in case of frame erasure */
stat_bwd++;
if (stat_bwd >= 30) {
stationnary = 1;
stat_bwd = 30;
}
else stationnary = 0;
}
parm += 5;
}
/*-------------------------------------------------------*
* - Add the fixed-gain pitch contribution to code[]. *
*-------------------------------------------------------*/
for (i = t0; i < L_SUBFR; i++) code[i] += sharp * code[i-t0];
/*-------------------------------------------------*
* - Decode pitch and codebook gains. *
*-------------------------------------------------*/
index = *parm++; /* index of energy VQ */
if (rate == G729D)
dec_gain_6k(index, code, L_SUBFR, bfi, &gain_pitch, &gain_code);
else
dec_gaine(index, code, L_SUBFR, bfi, &gain_pitch, &gain_code, rate,
gain_pit_mem, gain_cod_mem, &c_muting, count_bfi, stationnary);
/*-------------------------------------------------------------*
* - Update previous gains
*-------------------------------------------------------------*/
gain_pit_mem = gain_pitch;
gain_cod_mem = gain_code;
/*-------------------------------------------------------------*
* - Update pitch sharpening "sharp" with quantized gain_pitch *
*-------------------------------------------------------------*/
sharp = gain_pitch;
if (sharp > SHARPMAX) sharp = SHARPMAX;
if (sharp < SHARPMIN) sharp = SHARPMIN;
/*-------------------------------------------------------*
* - Find the total excitation. *
* - Find synthesis speech corresponding to exc[]. *
*-------------------------------------------------------*/
if(bfi != 0) { /* Bad frame */
count_bfi++;
if (voicing == 0 ) {
g_p = (F)0.;
g_c = gain_code;
}
else {
g_p = gain_pitch;
g_c = (F)0.;
}
}
else {
g_p = gain_pitch;
g_c = gain_code;
}
for (i = 0; i < L_SUBFR; i++) {
exc[i+i_subfr] = g_p * exc[i+i_subfr] + g_c * code[i];
}
if (rate == G729D) {
PhDisp(&exc[i_subfr], exc_phdisp, gain_code, gain_pitch, code);
syn_filte(m_aq, pA_t, exc_phdisp, &synth[i_subfr], L_SUBFR,
&mem_syn[M_BWD-m_aq], 0);
}
else {
syn_filte(m_aq, pA_t, &exc[i_subfr], &synth[i_subfr], L_SUBFR,
&mem_syn[M_BWD-m_aq], 0);
/* Updates state machine for phase dispersion in
6.4 kbps mode, if running at other rate */
Update_PhDisp(gain_pitch, gain_code);
}
copy(&synth[i_subfr+L_SUBFR-M_BWD], mem_syn, M_BWD);
pA_t += m_aq+1; /* interpolated LPC parameters for next subframe */
}
}
/*------------*
* For G729b
*-----------*/
if(bfi == 0) {
sid_sav = (FLOAT)0.0;
for(i=0; i<L_FRAME; i++) {
sid_sav += exc[i] * exc[i];
}
}
past_ftyp = ftyp;
/*------------*
* For G729E
*-----------*/
energy = ener_dB(synth, L_FRAME);
if (energy >= (F)40.) tst_bwd_dominant(bwd_dominant, lp_mode);
/*--------------------------------------------------*
* Update signal for next frame. *
* -> shift to the left by L_FRAME exc[] *
*--------------------------------------------------*/
copy(&old_exc[L_FRAME], &old_exc[0], PIT_MAX+L_INTERPOL);
if( lp_mode == 0) {
copy(A_t_fwd, Az_dec, 2*MP1);
*m_pst = M;
}
else {
copy(A_t_bwd, Az_dec, 2*M_BWDP1);
*m_pst = M_BWD;
}
prev_bfi = bfi;
prev_lp_mode = lp_mode;
prev_voicing = voicing;
if (bfi != 0) c_fe = (F)1.;
else {
if (lp_mode == 0) c_fe = 0;
else {
if (*bwd_dominant == 1) c_fe -= (F)0.1;
else c_fe -= (F)0.5;
if (c_fe < 0) c_fe= 0;
}
}
return;
}
