/*-----------------------------------------------------------* * 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; }