void Int_lpc( Word16 lsp_old[], /* input : LSP vector of past frame */ Word16 lsp_new[], /* input : LSP vector of present frame */ Word16 lsf_int[], /* output: interpolated lsf coefficients */ Word16 lsf_new[], Word16 Az[] /* output: interpolated Az() for the 2 subframes */ ) { Word16 i; Word16 lsp[M]; /* lsp[i] = lsp_new[i] * 0.5 + lsp_old[i] * 0.5 */ for (i = 0; i < M; i++) { lsp[i] = add(shr(lsp_new[i], 1), shr(lsp_old[i], 1)); } Lsp_Az(lsp, Az); Lsp_lsf(lsp, lsf_int, M); /* transformation from LSP to LSF (freq.domain) */ Lsp_lsf(lsp_new, lsf_new, M); /* transformation from LSP to LSF (freq.domain) */ return; }
void Int_qlpc( Word16 lsp_old[], /* input : LSP vector of past frame */ Word16 lsp_new[], /* input : LSP vector of present frame */ Word16 Az[] /* output: interpolated Az() for the 2 subframes */ ) { Word16 i; Word16 lsp[M]; /* lsp[i] = lsp_new[i] * 0.5 + lsp_old[i] * 0.5 */ for (i = 0; i < M; i++) { lsp[i] = add(shr(lsp_new[i], 1), shr(lsp_old[i], 1)); } Lsp_Az(lsp, Az); /* Subframe 1 */ Lsp_Az(lsp_new, &Az[MP1]); /* Subframe 2 */ }
void Coder_ld8h( Word16 ana[], /* (o) : analysis parameters */ Word16 rate /* input : rate selector/frame =0 6.4kbps , =1 8kbps,= 2 11.8 kbps*/ ) { /* LPC analysis */ Word16 r_l_fwd[MP1], r_h_fwd[MP1]; /* Autocorrelations low and hi (forward) */ Word32 r_bwd[M_BWDP1]; /* Autocorrelations (backward) */ Word16 r_l_bwd[M_BWDP1]; /* Autocorrelations low (backward) */ Word16 r_h_bwd[M_BWDP1]; /* Autocorrelations high (backward) */ Word16 rc_fwd[M]; /* Reflection coefficients : forward analysis */ Word16 rc_bwd[M_BWD]; /* Reflection coefficients : backward analysis */ Word16 A_t_fwd[MP1*2]; /* A(z) forward unquantized for the 2 subframes */ Word16 A_t_fwd_q[MP1*2]; /* A(z) forward quantized for the 2 subframes */ Word16 A_t_bwd[2*M_BWDP1]; /* A(z) backward for the 2 subframes */ Word16 *Aq; /* A(z) "quantized" for the 2 subframes */ Word16 *Ap; /* A(z) "unquantized" for the 2 subframes */ Word16 *pAp, *pAq; Word16 Ap1[M_BWDP1]; /* A(z) with spectral expansion */ Word16 Ap2[M_BWDP1]; /* A(z) with spectral expansion */ Word16 lsp_new[M], lsp_new_q[M]; /* LSPs at 2th subframe */ Word16 lsf_int[M]; /* Interpolated LSF 1st subframe. */ Word16 lsf_new[M]; Word16 lp_mode; /* Backward / Forward Indication mode */ Word16 m_ap, m_aq, i_gamma; Word16 code_lsp[2]; /* Other vectors */ Word16 h1[L_SUBFR]; /* Impulse response h1[] */ Word16 xn[L_SUBFR]; /* Target vector for pitch search */ Word16 xn2[L_SUBFR]; /* Target vector for codebook search */ Word16 code[L_SUBFR]; /* Fixed codebook excitation */ Word16 y1[L_SUBFR]; /* Filtered adaptive excitation */ Word16 y2[L_SUBFR]; /* Filtered fixed codebook excitation */ Word16 g_coeff[4]; /* Correlations between xn & y1 */ Word16 res2[L_SUBFR]; /* residual after long term prediction*/ Word16 g_coeff_cs[5]; Word16 exp_g_coeff_cs[5]; /* Correlations between xn, y1, & y2 <y1,y1>, -2<xn,y1>, <y2,y2>, -2<xn,y2>, 2<y1,y2> */ /* Scalars */ Word16 i, j, k, i_subfr; Word16 T_op, T0, T0_min, T0_max, T0_frac; Word16 gain_pit, gain_code, index; Word16 taming, pit_sharp; Word16 sat_filter; Word32 L_temp; Word16 freq_cur[M]; Word16 temp; /*------------------------------------------------------------------------* * - 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) * *------------------------------------------------------------------------*/ /* ------------------- */ /* LP Forward analysis */ /* ------------------- */ Autocorr(p_window, M, r_h_fwd, r_l_fwd); /* Autocorrelations */ Lag_window(M, r_h_fwd, r_l_fwd); /* Lag windowing */ Levinsone(M, r_h_fwd, r_l_fwd, &A_t_fwd[MP1], rc_fwd, old_A_fwd, old_rc_fwd); /* Levinson Durbin */ Az_lsp(&A_t_fwd[MP1], lsp_new, lsp_old); /* From A(z) to lsp */ /* -------------------- */ /* LP Backward analysis */ /* -------------------- */ /* -------------------- */ /* LP Backward analysis */ /* -------------------- */ if ( rate== G729E) { /* LPC recursive Window as in G728 */ autocorr_hyb_window(synth, r_bwd, rexp); /* Autocorrelations */ Lag_window_bwd(r_bwd, r_h_bwd, r_l_bwd); /* Lag windowing */ /* Fixed Point Levinson (as in G729) */ Levinsone(M_BWD, r_h_bwd, r_l_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] >= 32767) 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[L_FRAME], &synth[0], MEM_SYN_BWD); /*--------------------------------------------------------------------* * Find interpolated LPC parameters in all subframes (unquantized). * * The interpolated parameters are in array A_t[] of size (M+1)*4 * *--------------------------------------------------------------------*/ if( prev_lp_mode == 0) { Int_lpc(lsp_old, lsp_new, lsf_int, lsf_new, A_t_fwd); } else { /* no interpolation */ /* unquantized */ Lsp_Az(lsp_new, A_t_fwd); /* Subframe 1 */ Lsp_lsf(lsp_new, lsf_new, M); /* transformation from LSP to LSF (freq.domain) */ Copy(lsf_new, lsf_int, M); /* Subframe 1 */ } /* ---------------- */ /* LSP quantization */ /* ---------------- */ Qua_lspe(lsp_new, lsp_new_q, code_lsp, freq_prev, freq_cur); /*--------------------------------------------------------------------* * Find interpolated LPC parameters in all subframes (quantized) * * the quantized interpolated parameters are in array Aq_t[] * *--------------------------------------------------------------------*/ if( prev_lp_mode == 0) { Int_qlpc(lsp_old_q, lsp_new_q, A_t_fwd_q); } else { /* no interpolation */ Lsp_Az(lsp_new_q, &A_t_fwd_q[MP1]); /* Subframe 2 */ Copy(&A_t_fwd_q[MP1], A_t_fwd_q, MP1); /* Subframe 1 */ } /*---------------------------------------------------------------------* * - Decision for the switch Forward / Backward * *---------------------------------------------------------------------*/ if(rate == G729E) { set_lpc_modeg(speech, A_t_fwd_q, A_t_bwd, &lp_mode, lsp_new, lsp_old, &bwd_dominant, prev_lp_mode, prev_filter, &C_int, &glob_stat, &stat_bwd, &val_stat_bwd); } else { update_bwd( &lp_mode, &bwd_dominant, &C_int, &glob_stat); } /* ---------------------------------- */ /* update the LSPs for the next frame */ /* ---------------------------------- */ Copy(lsp_new, lsp_old, M); /*----------------------------------------------------------------------* * - Find the weighted input speech w_sp[] for the whole speech frame * *----------------------------------------------------------------------*/ if(lp_mode == 0) { m_ap = M; if (bwd_dominant == 0) Ap = A_t_fwd; else Ap = A_t_fwd_q; perc_var(gamma1, gamma2, lsf_int, lsf_new, rc_fwd); } else { if (bwd_dominant == 0) { m_ap = M; Ap = A_t_fwd; } else { m_ap = M_BWD; Ap = A_t_bwd; } perc_vare(gamma1, gamma2, bwd_dominant); } pAp = Ap; for (i=0; i<2; i++) { Weight_Az(pAp, gamma1[i], m_ap, Ap1); Weight_Az(pAp, gamma2[i], m_ap, Ap2); Residue(m_ap, Ap1, &speech[i*L_SUBFR], &wsp[i*L_SUBFR], L_SUBFR); Syn_filte(m_ap, Ap2, &wsp[i*L_SUBFR], &wsp[i*L_SUBFR], L_SUBFR, &mem_w[M_BWD-m_ap], 0); for(j=0; j<M_BWD; j++) mem_w[j] = wsp[i*L_SUBFR+L_SUBFR-M_BWD+j]; pAp += m_ap+1; } *ana++ = rate+ (Word16)2; /* bit rate mode */ if(lp_mode == 0) { m_aq = M; Aq = A_t_fwd_q; /* update previous filter for next frame */ Copy(&Aq[MP1], prev_filter, MP1); for(i=MP1; i <M_BWDP1; i++) prev_filter[i] = 0; for(j=MP1; j<M_BWDP1; j++) ai_zero[j] = 0; } else { m_aq = M_BWD; Aq = A_t_bwd; if (bwd_dominant == 0) { for(j=MP1; j<M_BWDP1; j++) ai_zero[j] = 0; } /* update previous filter for next frame */ Copy(&Aq[M_BWDP1], prev_filter, M_BWDP1); } if (rate == G729E) *ana++ = lp_mode; /*----------------------------------------------------------------------* * - Find the weighted input speech w_sp[] for the whole speech frame * * - Find the open-loop pitch delay * *----------------------------------------------------------------------*/ if( lp_mode == 0) { Copy(lsp_new_q, lsp_old_q, M); Lsp_prev_update(freq_cur, freq_prev); *ana++ = code_lsp[0]; *ana++ = code_lsp[1]; } /* Find open loop pitch lag */ T_op = Pitch_ol(wsp, PIT_MIN, PIT_MAX, L_FRAME); /* Range for closed loop pitch search in 1st subframe */ T0_min = sub(T_op, 3); if (sub(T0_min,PIT_MIN)<0) { T0_min = PIT_MIN; } T0_max = add(T0_min, 6); if (sub(T0_max ,PIT_MAX)>0) { T0_max = PIT_MAX; T0_min = sub(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 2 times. * * - find the weighted LPC coefficients * * - find the LPC residual signal res[] * * - 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 * * - update the impulse response h1[] by including fixed-gain pitch * * - find target vector for codebook search * * - codebook search * * - encode codebook address * * - VQ of pitch and codebook gains * * - find synthesis speech * * - update states of weighting filter * *------------------------------------------------------------------------*/ pAp = Ap; /* pointer to interpolated "unquantized"LPC parameters */ pAq = Aq; /* pointer to interpolated "quantized" LPC parameters */ i_gamma = 0; for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { /*---------------------------------------------------------------* * Find the weighted LPC coefficients for the weighting filter. * *---------------------------------------------------------------*/ Weight_Az(pAp, gamma1[i_gamma], m_ap, Ap1); Weight_Az(pAp, gamma2[i_gamma], m_ap, Ap2); /*---------------------------------------------------------------* * Compute impulse response, h1[], of weighted synthesis filter * *---------------------------------------------------------------*/ for (i = 0; i <=m_ap; i++) ai_zero[i] = Ap1[i]; Syn_filte(m_aq, pAq, ai_zero, h1, L_SUBFR, zero, 0); Syn_filte(m_ap, Ap2, h1, h1, L_SUBFR, zero, 0); /*------------------------------------------------------------------------* * * * Find the target vector for pitch search: * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * * * |------| res[n] * * speech[n]---| A(z) |-------- * * |------| | |--------| error[n] |------| * * zero -- (-)--| 1/A(z) |-----------| W(z) |-- target * * exc |--------| |------| * * * * Instead of subtracting the zero-input response of filters from * * the weighted input speech, the above configuration is used to * * compute the target vector. This configuration gives better performance * * with fixed-point implementation. The memory of 1/A(z) is updated by * * filtering (res[n]-exc[n]) through 1/A(z), or simply by subtracting * * the synthesis speech from the input speech: * * error[n] = speech[n] - syn[n]. * * The memory of W(z) is updated by filtering error[n] through W(z), * * or more simply by subtracting the filtered adaptive and fixed * * codebook excitations from the target: * * target[n] - gain_pit*y1[n] - gain_code*y2[n] * * as these signals are already available. * * * *------------------------------------------------------------------------*/ Residue(m_aq, pAq, &speech[i_subfr], &exc[i_subfr], L_SUBFR); /* LPC residual */ for (i=0; i<L_SUBFR; i++) res2[i] = exc[i_subfr+i]; Syn_filte(m_aq, pAq, &exc[i_subfr], error, L_SUBFR, &mem_err[M_BWD-m_aq], 0); Residue(m_ap, Ap1, error, xn, L_SUBFR); Syn_filte(m_ap, Ap2, xn, xn, L_SUBFR, &mem_w0[M_BWD-m_ap], 0); /* target signal xn[]*/ /*----------------------------------------------------------------------* * Closed-loop fractional pitch search * *----------------------------------------------------------------------*/ T0 = Pitch_fr3cp(&exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max, i_subfr, &T0_frac, rate); index = Enc_lag3cp(T0, T0_frac, &T0_min, &T0_max,PIT_MIN,PIT_MAX, i_subfr, rate); *ana++ = index; if ( (i_subfr == 0) && (rate != G729D) ) { *ana = Parity_Pitch(index); if( rate == G729E) { *ana ^= (shr(index, 1) & 0x0001); } ana++; } /*-----------------------------------------------------------------* * - find unity gain pitch excitation (adaptive codebook entry) * * with fractional interpolation. * * - find filtered pitch exc. y1[]=exc[] convolve with h1[]) * * - compute pitch gain and limit between 0 and 1.2 * * - update target vector for codebook search * * - find LTP residual. * *-----------------------------------------------------------------*/ Pred_lt_3(&exc[i_subfr], T0, T0_frac, L_SUBFR); Convolve(&exc[i_subfr], h1, y1, L_SUBFR); 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 (sub(gain_pit, GPCLIP) > 0) { gain_pit = GPCLIP; } } /* xn2[i] = xn[i] - y1[i] * gain_pit */ for (i = 0; i < L_SUBFR; i++) { L_temp = L_mult(y1[i], gain_pit); L_temp = L_shl(L_temp, 1); /* gain_pit in Q14 */ xn2[i] = sub(xn[i], extract_h(L_temp)); } /*-----------------------------------------------------* * - Innovative codebook search. * *-----------------------------------------------------*/ switch (rate) { case G729: /* 8 kbit/s */ { /* case 8 kbit/s */ index = ACELP_Codebook(xn2, h1, T0, sharp, i_subfr, code, y2, &i); *ana++ = index; /* Positions index */ *ana++ = i; /* Signs index */ break; } case G729D: /* 6.4 kbit/s */ { index = ACELP_CodebookD(xn2, h1, T0, sharp, code, y2, &i); *ana++ = index; /* Positions index */ *ana++ = i; /* Signs index */ break; } case G729E: /* 11.8 kbit/s */ { /*-----------------------------------------------------------------* * Include fixed-gain pitch contribution into impulse resp. h[] * *-----------------------------------------------------------------*/ pit_sharp = shl(sharp, 1); /* From Q14 to Q15 */ if(T0 < L_SUBFR) { for (i = T0; i < L_SUBFR; i++){ /* h[i] += pitch_sharp*h[i-T0] */ h1[i] = add(h1[i], mult(h1[i-T0], pit_sharp)); } } /* calculate residual after long term prediction */ /* res2[i] -= exc[i+i_subfr] * gain_pit */ for (i = 0; i < L_SUBFR; i++) { L_temp = L_mult(exc[i+i_subfr], gain_pit); L_temp = L_shl(L_temp, 1); /* gain_pit in Q14 */ res2[i] = sub(res2[i], extract_h(L_temp)); } if (lp_mode == 0) ACELP_10i40_35bits(xn2, res2, h1, code, y2, ana); /* Forward */ else ACELP_12i40_44bits(xn2, res2, h1, code, y2, ana); /* Backward */ ana += 5; /*-----------------------------------------------------------------* * Include fixed-gain pitch contribution into code[]. * *-----------------------------------------------------------------*/ if(T0 < L_SUBFR) { for (i = T0; i < L_SUBFR; i++) { /* code[i] += pitch_sharp*code[i-T0] */ code[i] = add(code[i], mult(code[i-T0], pit_sharp)); } } break; } default : { printf("Unrecognized bit rate\n"); exit(-1); } } /* end of switch */ /*-----------------------------------------------------* * - Quantization of gains. * *-----------------------------------------------------*/ g_coeff_cs[0] = g_coeff[0]; /* <y1,y1> */ exp_g_coeff_cs[0] = negate(g_coeff[1]); /* Q-Format:XXX -> JPN */ g_coeff_cs[1] = negate(g_coeff[2]); /* (xn,y1) -> -2<xn,y1> */ exp_g_coeff_cs[1] = negate(add(g_coeff[3], 1)); /* Q-Format:XXX -> JPN */ Corr_xy2( xn, y1, y2, g_coeff_cs, exp_g_coeff_cs ); /* Q0 Q0 Q12 ^Qx ^Q0 */ /* g_coeff_cs[3]:exp_g_coeff_cs[3] = <y2,y2> */ /* g_coeff_cs[4]:exp_g_coeff_cs[4] = -2<xn,y2> */ /* g_coeff_cs[5]:exp_g_coeff_cs[5] = 2<y1,y2> */ if (rate == G729D) index = Qua_gain_6k(code, g_coeff_cs, exp_g_coeff_cs, L_SUBFR, &gain_pit, &gain_code, taming, past_qua_en); else index = Qua_gain_8k(code, g_coeff_cs, exp_g_coeff_cs, L_SUBFR, &gain_pit, &gain_code, taming, past_qua_en); *ana++ = index; /*------------------------------------------------------------* * - Update pitch sharpening "sharp" with quantized gain_pit * *------------------------------------------------------------*/ sharp = gain_pit; if (sub(sharp, SHARPMAX) > 0) sharp = SHARPMAX; else { if (sub(sharp, SHARPMIN) < 0) sharp = SHARPMIN; } /*------------------------------------------------------* * - Find the total excitation * * - find synthesis speech corresponding to exc[] * * - update filters memories for finding the target * * vector in the next subframe * * (update error[-m..-1] and mem_w_err[]) * * update error function for taming process * *------------------------------------------------------*/ for (i = 0; i < L_SUBFR; i++) { /* exc[i] = gain_pit*exc[i] + gain_code*code[i]; */ /* exc[i] in Q0 gain_pit in Q14 */ /* code[i] in Q13 gain_cod in Q1 */ L_temp = L_mult(exc[i+i_subfr], gain_pit); L_temp = L_mac(L_temp, code[i], gain_code); L_temp = L_shl(L_temp, 1); exc[i+i_subfr] = round(L_temp); } update_exc_err(gain_pit, T0); Syn_filte(m_aq, pAq, &exc[i_subfr], &synth_ptr[i_subfr], L_SUBFR, &mem_syn[M_BWD-m_aq], 0); for(j=0; j<M_BWD; j++) mem_syn[j] = synth_ptr[i_subfr+L_SUBFR-M_BWD+j]; for (i = L_SUBFR-M_BWD, j = 0; i < L_SUBFR; i++, j++) { mem_err[j] = sub(speech[i_subfr+i], synth_ptr[i_subfr+i]); temp = extract_h(L_shl( L_mult(y1[i], gain_pit), 1) ); k = extract_h(L_shl( L_mult(y2[i], gain_code), 2) ); mem_w0[j] = sub(xn[i], add(temp, k)); } pAp += m_ap+1; pAq += m_aq+1; i_gamma = add(i_gamma,1); } /*--------------------------------------------------* * 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); prev_lp_mode = lp_mode; return; }
void Decod_ld8c ( Word16 parm[], /* (i) : vector of synthesis parameters parm[0] = bad frame indicator (bfi) */ Word16 voicing, /* (i) : voicing decision from previous frame */ Word16 synth_buf[], /* (i/o) : synthesis speech */ Word16 Az_dec[], /* (o) : decoded LP filter in 2 subframes */ Word16 *T0_first, /* (o) : decoded pitch lag in first subframe */ Word16 *bwd_dominant, /* (o) : */ Word16 *m_pst, /* (o) : LPC order for postfilter */ Word16 *Vad ) { /* Scalars */ Word16 i, j, i_subfr; Word16 T0, T0_frac, index; Word16 bfi; Word16 lp_mode; /* Backward / Forward mode indication */ Word16 g_p, g_c; /* fixed and adaptive codebook gain */ Word16 bad_pitch; /* bad pitch indicator */ Word16 tmp, tmp1, tmp2; Word16 sat_filter; Word32 L_temp; Word32 energy; Word16 temp; /* Tables */ Word16 A_t_bwd[2*M_BWDP1]; /* LPC Backward filter */ Word16 A_t_fwd[2*MP1]; /* LPC Forward filter */ Word16 rc_bwd[M_BWD]; /* LPC backward reflection coefficients */ Word32 r_bwd[M_BWDP1]; /* Autocorrelations (backward) */ Word16 r_l_bwd[M_BWDP1]; /* Autocorrelations low (backward) */ Word16 r_h_bwd[M_BWDP1]; /* Autocorrelations high (backward) */ Word16 lsp_new[M]; /* LSPs */ Word16 code[L_SUBFR]; /* ACELP codevector */ Word16 *pA_t; /* Pointer on A_t */ Word16 stationnary; Word16 m_aq; Word16 *synth; Word16 exc_phdisp[L_SUBFR]; /* excitation after phase dispersion */ extern Flag Overflow; Word16 rate; /* for G.729B */ Word16 ftyp; Word16 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 - (Word16)2; /* Decoding the Backward/Forward LPC decision */ /* ------------------------------------------ */ if( rate != G729E) lp_mode = 0; else { if (bfi != 0) { lp_mode = prev_lp_mode; /* Frame erased => mode = previous mode */ *parm++ = lp_mode; } else { lp_mode = *parm++; } if(prev_bfi != 0) voicing = prev_voicing; } if( bfi == 0) { c_muting = 32767; 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, r_h_bwd, r_l_bwd); /* Lag windowing */ /* Fixed Point Levinson (as in G729) */ Levinsoncp(M_BWD, r_h_bwd, r_l_bwd, &A_t_bwd[M_BWDP1], rc_bwd, old_A_bwd, old_rc_bwd, &temp); /* Tests saturation of A_t_bwd */ sat_filter = 0; for (i=M_BWDP1; i<2*M_BWDP1; i++) if (A_t_bwd[i] >= 32767) 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_fix != 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 = sub(4096, C_fe_fix); pA_t = A_t_bwd + M_BWDP1; for (i=0; i<M_BWDP1; i++) { L_temp = L_mult(pA_t[i], tmp); L_temp = L_shr(L_temp, 13); tmp1 = extract_l(L_temp); L_temp = L_mult(A_bwd_mem[i], C_fe_fix); L_temp = L_shr(L_temp, 13); tmp2 = extract_l(L_temp); pA_t[i] = add(tmp1, tmp2); } } } /* Memorize the last good backward filter when the frame is erased */ if ((bfi != 0)&&(prev_bfi == 0) && (past_ftyp >3)) for (i=0; i<M_BWDP1; i++) A_bwd_mem[i] = A_t_bwd[i+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, sh_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) { Overflow = 0; Syn_filte(M, pA_t, &exc[i_subfr], &synth[i_subfr], L_SUBFR, &mem_syn[M_BWD-M], 0); if(Overflow != 0) { /* In case of overflow in the synthesis */ /* -> Scale down vector exc[] and redo synthesis */ for(i=0; i<PIT_MAX+L_INTERPOL+L_FRAME; i++) old_exc[i] = shr(old_exc[i], 2); 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); pA_t += MP1; } *T0_first = prev_T0; sharp = SHARPMIN; C_int = 4506; /* 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] = 0; } else { /***************************/ /* Processing active frame */ /***************************/ 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 = 4506; 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] = 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 = add(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 = add( prev_T0, 1); if( sub(prev_T0, PIT_MAX) > 0) { 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 = add( prev_T0, 1); if( sub(prev_T0, PIT_MAX) > 0) 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] = Random_g729cp(&seed_fer); parm[1] = Random_g729cp(&seed_fer); if (rate == G729E) { parm[2] = Random_g729cp(&seed_fer); parm[3] = Random_g729cp(&seed_fer); parm[4] = Random_g729cp(&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 6.4 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 = add(stat_bwd,1); if (sub(stat_bwd,30) >= 0) { stationnary = 1; stat_bwd = 30; } else stationnary = 0; } parm += 5; } /*-------------------------------------------------------* * - Add the fixed-gain pitch contribution to code[]. * *-------------------------------------------------------*/ j = shl(sharp, 1); /* From Q14 to Q15 */ if(sub(T0, L_SUBFR) <0 ) { for (i = T0; i < L_SUBFR; i++) { code[i] = add(code[i], mult(code[i-T0], j)); } } /*-------------------------------------------------* * - 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 (sub(sharp, SHARPMAX) > 0) sharp = SHARPMAX; if (sub(sharp, SHARPMIN) < 0) sharp = SHARPMIN; /*-------------------------------------------------------* * - Find the total excitation. * * - Find synthesis speech corresponding to exc[]. * *-------------------------------------------------------*/ if(bfi != 0) { /* Bad frame */ count_bfi = add(count_bfi,1); if (voicing == 0 ) { g_p = 0; g_c = gain_code; } else { g_p = gain_pitch; g_c = 0; } } else { g_p = gain_pitch; g_c = gain_code; } for (i = 0; i < L_SUBFR; i++) { /* exc[i] = g_p*exc[i] + g_c*code[i]; */ /* exc[i] in Q0 g_p in Q14 */ /* code[i] in Q13 g_code in Q1 */ L_temp = L_mult(exc[i+i_subfr], g_p); L_temp = L_mac(L_temp, code[i], g_c); L_temp = L_shl(L_temp, 1); exc[i+i_subfr] = round(L_temp); } /* Test whether synthesis yields overflow or not */ Overflow = 0; Syn_filte(m_aq, pA_t, &exc[i_subfr], &synth[i_subfr], L_SUBFR, &mem_syn[M_BWD-m_aq], 0); /* In case of overflow in the synthesis */ /* -> Scale down vector exc[] and redo synthesis */ if(Overflow != 0) { for(i=0; i<PIT_MAX+L_INTERPOL+L_FRAME; i++) old_exc[i] = shr(old_exc[i], 2); } 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); } pA_t += m_aq+1; /* interpolated LPC parameters for next subframe */ Copy(&synth[i_subfr+L_SUBFR-M_BWD], mem_syn, M_BWD); } } /*------------* * For G729b *-----------*/ if(bfi == 0) { L_temp = 0L; for(i=0; i<L_FRAME; i++) { L_temp = L_mac(L_temp, exc[i], exc[i]); } /* may overflow => last level of SID quantizer */ sh_sid_sav = norm_l(L_temp); sid_sav = round(L_shl(L_temp, sh_sid_sav)); sh_sid_sav = sub(16, sh_sid_sav); } past_ftyp = ftyp; /*------------* * For G729E *-----------*/ energy = ener_dB(synth, L_FRAME); if (energy >= 8192) 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_fix = 4096; else { if (lp_mode == 0) C_fe_fix = 0; else { if (*bwd_dominant == 1) C_fe_fix = sub(C_fe_fix, 410); else C_fe_fix = sub(C_fe_fix, 2048); if (C_fe_fix < 0) C_fe_fix= 0; } } return; }
/* ************************************************************************** * * Function : dtx_dec * ************************************************************************** */ int dtx_dec( dtx_decState *st, /* i/o : State struct */ Word16 mem_syn[], /* i/o : AMR decoder state */ D_plsfState* lsfState, /* i/o : decoder lsf states */ gc_predState* predState, /* i/o : prediction states */ Cb_gain_averageState* averState, /* i/o : CB gain average states */ enum DTXStateType new_state, /* i : new DTX state */ enum Mode mode, /* i : AMR mode */ Word16 parm[], /* i : Vector of synthesis parameters */ Word16 synth[], /* o : synthesised speech */ Word16 A_t[] /* o : decoded LP filter in 4 subframes*/ ) { Word16 log_en_index; Word16 i, j; Word16 int_fac; Word32 L_log_en_int; Word16 lsp_int[M]; Word16 log_en_int_e; Word16 log_en_int_m; Word16 level; Word16 acoeff[M + 1]; Word16 refl[M]; Word16 pred_err; Word16 ex[L_SUBFR]; Word16 ma_pred_init; Word16 log_pg_e, log_pg_m; Word16 log_pg; Flag negative; Word16 lsf_mean; Word32 L_lsf_mean; Word16 lsf_variab_index; Word16 lsf_variab_factor; Word16 lsf_int[M]; Word16 lsf_int_variab[M]; Word16 lsp_int_variab[M]; Word16 acoeff_variab[M + 1]; Word16 lsf[M]; Word32 L_lsf[M]; Word16 ptr; Word16 tmp_int_length; /* This function is called if synthesis state is not SPEECH * the globally passed inputs to this function are * st->sid_frame * st->valid_data * st->dtxHangoverAdded * new_state (SPEECH, DTX, DTX_MUTE) */ test(); test(); if ((st->dtxHangoverAdded != 0) && (st->sid_frame != 0)) { /* sid_first after dtx hangover period */ /* or sid_upd after dtxhangover */ /* set log_en_adjust to correct value */ st->log_en_adjust = dtx_log_en_adjust[mode]; ptr = add(st->lsf_hist_ptr, M); move16(); test(); if (sub(ptr, 80) == 0) { ptr = 0; move16(); } Copy( &st->lsf_hist[st->lsf_hist_ptr],&st->lsf_hist[ptr],M); ptr = add(st->log_en_hist_ptr,1); move16(); test(); if (sub(ptr, DTX_HIST_SIZE) == 0) { ptr = 0; move16(); } move16(); st->log_en_hist[ptr] = st->log_en_hist[st->log_en_hist_ptr]; /* Q11 */ /* compute mean log energy and lsp * * from decoded signal (SID_FIRST) */ st->log_en = 0; move16(); for (i = 0; i < M; i++) { L_lsf[i] = 0; move16(); } /* average energy and lsp */ for (i = 0; i < DTX_HIST_SIZE; i++) { st->log_en = add(st->log_en, shr(st->log_en_hist[i],3)); for (j = 0; j < M; j++) { L_lsf[j] = L_add(L_lsf[j], L_deposit_l(st->lsf_hist[i * M + j])); } } for (j = 0; j < M; j++) { lsf[j] = extract_l(L_shr(L_lsf[j],3)); /* divide by 8 */ move16(); } Lsf_lsp(lsf, st->lsp, M); /* make log_en speech coder mode independent */ /* added again later before synthesis */ st->log_en = sub(st->log_en, st->log_en_adjust); /* compute lsf variability vector */ Copy(st->lsf_hist, st->lsf_hist_mean, 80); for (i = 0; i < M; i++) { L_lsf_mean = 0; move32(); /* compute mean lsf */ for (j = 0; j < 8; j++) { L_lsf_mean = L_add(L_lsf_mean, L_deposit_l(st->lsf_hist_mean[i+j*M])); } lsf_mean = extract_l(L_shr(L_lsf_mean, 3)); move16(); /* subtract mean and limit to within reasonable limits * * moreover the upper lsf's are attenuated */ for (j = 0; j < 8; j++) { /* subtract mean */ st->lsf_hist_mean[i+j*M] = sub(st->lsf_hist_mean[i+j*M], lsf_mean); /* attenuate deviation from mean, especially for upper lsf's */ st->lsf_hist_mean[i+j*M] = mult(st->lsf_hist_mean[i+j*M], lsf_hist_mean_scale[i]); /* limit the deviation */ test(); if (st->lsf_hist_mean[i+j*M] < 0) { negative = 1; move16(); } else { negative = 0; move16(); } st->lsf_hist_mean[i+j*M] = abs_s(st->lsf_hist_mean[i+j*M]); /* apply soft limit */ test(); if (sub(st->lsf_hist_mean[i+j*M], 655) > 0) { st->lsf_hist_mean[i+j*M] = add(655, shr(sub(st->lsf_hist_mean[i+j*M], 655), 2)); } /* apply hard limit */ test(); if (sub(st->lsf_hist_mean[i+j*M], 1310) > 0) { st->lsf_hist_mean[i+j*M] = 1310; move16(); } test(); if (negative != 0) { st->lsf_hist_mean[i+j*M] = -st->lsf_hist_mean[i+j*M];move16(); } } } } test(); if (st->sid_frame != 0 ) { /* Set old SID parameters, always shift */ /* even if there is no new valid_data */ Copy(st->lsp, st->lsp_old, M); st->old_log_en = st->log_en; move16(); test(); if (st->valid_data != 0 ) /* new data available (no CRC) */ { /* Compute interpolation factor, since the division only works * * for values of since_last_sid < 32 we have to limit the * * interpolation to 32 frames */ tmp_int_length = st->since_last_sid; move16(); st->since_last_sid = 0; move16(); test(); if (sub(tmp_int_length, 32) > 0) { tmp_int_length = 32; move16(); } test(); if (sub(tmp_int_length, 2) >= 0) { move16(); st->true_sid_period_inv = div_s(1 << 10, shl(tmp_int_length, 10)); } else { st->true_sid_period_inv = 1 << 14; /* 0.5 it Q15 */ move16(); } Init_D_plsf_3(lsfState, parm[0]); /* temporay initialization */ D_plsf_3(lsfState, MRDTX, 0, &parm[1], st->lsp); Set_zero(lsfState->past_r_q, M); /* reset for next speech frame */ log_en_index = parm[4]; move16(); /* Q11 and divide by 4 */ st->log_en = shl(log_en_index, (11 - 2)); move16(); /* Subtract 2.5 in Q11 */ st->log_en = sub(st->log_en, (2560 * 2)); /* Index 0 is reserved for silence */ test(); if (log_en_index == 0) { st->log_en = MIN_16; move16(); } /* no interpolation at startup after coder reset */ /* or when SID_UPD has been received right after SPEECH */ test(); test(); if ((st->data_updated == 0) || (sub(st->dtxGlobalState, SPEECH) == 0) ) { Copy(st->lsp, st->lsp_old, M); st->old_log_en = st->log_en; move16(); } } /* endif valid_data */ /* initialize gain predictor memory of other modes */ ma_pred_init = sub(shr(st->log_en,1), 9000); move16(); test(); if (ma_pred_init > 0) { ma_pred_init = 0; move16(); } test(); if (sub(ma_pred_init, -14436) < 0) { ma_pred_init = -14436; move16(); } predState->past_qua_en[0] = ma_pred_init; move16(); predState->past_qua_en[1] = ma_pred_init; move16(); predState->past_qua_en[2] = ma_pred_init; move16(); predState->past_qua_en[3] = ma_pred_init; move16(); /* past_qua_en for other modes than MR122 */ ma_pred_init = mult(5443, ma_pred_init); /* scale down by factor 20*log10(2) in Q15 */ predState->past_qua_en_MR122[0] = ma_pred_init; move16(); predState->past_qua_en_MR122[1] = ma_pred_init; move16(); predState->past_qua_en_MR122[2] = ma_pred_init; move16(); predState->past_qua_en_MR122[3] = ma_pred_init; move16(); } /* endif sid_frame */ /* CN generation */ /* recompute level adjustment factor Q11 * * st->log_en_adjust = 0.9*st->log_en_adjust + * * 0.1*dtx_log_en_adjust[mode]); */ move16(); st->log_en_adjust = add(mult(st->log_en_adjust, 29491), shr(mult(shl(dtx_log_en_adjust[mode],5),3277),5)); /* Interpolate SID info */ int_fac = shl(add(1,st->since_last_sid), 10); /* Q10 */ move16(); int_fac = mult(int_fac, st->true_sid_period_inv); /* Q10 * Q15 -> Q10 */ /* Maximize to 1.0 in Q10 */ test(); if (sub(int_fac, 1024) > 0) { int_fac = 1024; move16(); } int_fac = shl(int_fac, 4); /* Q10 -> Q14 */ L_log_en_int = L_mult(int_fac, st->log_en); /* Q14 * Q11->Q26 */ move32(); for(i = 0; i < M; i++) { lsp_int[i] = mult(int_fac, st->lsp[i]);/* Q14 * Q15 -> Q14 */ move16(); } int_fac = sub(16384, int_fac); /* 1-k in Q14 */ move16(); /* (Q14 * Q11 -> Q26) + Q26 -> Q26 */ L_log_en_int = L_mac(L_log_en_int, int_fac, st->old_log_en); for(i = 0; i < M; i++) { /* Q14 + (Q14 * Q15 -> Q14) -> Q14 */ lsp_int[i] = add(lsp_int[i], mult(int_fac, st->lsp_old[i])); move16(); lsp_int[i] = shl(lsp_int[i], 1); /* Q14 -> Q15 */ move16(); } /* compute the amount of lsf variability */ lsf_variab_factor = sub(st->log_pg_mean,2457); /* -0.6 in Q12 */ move16(); /* *0.3 Q12*Q15 -> Q12 */ lsf_variab_factor = sub(4096, mult(lsf_variab_factor, 9830)); /* limit to values between 0..1 in Q12 */ test(); if (sub(lsf_variab_factor, 4096) > 0) { lsf_variab_factor = 4096; move16(); } test(); if (lsf_variab_factor < 0) { lsf_variab_factor = 0; move16(); } lsf_variab_factor = shl(lsf_variab_factor, 3); /* -> Q15 */ move16(); /* get index of vector to do variability with */ lsf_variab_index = pseudonoise(&st->L_pn_seed_rx, 3); move16(); /* convert to lsf */ Lsp_lsf(lsp_int, lsf_int, M); /* apply lsf variability */ Copy(lsf_int, lsf_int_variab, M); for(i = 0; i < M; i++) { move16(); lsf_int_variab[i] = add(lsf_int_variab[i], mult(lsf_variab_factor, st->lsf_hist_mean[i+lsf_variab_index*M])); } /* make sure that LSP's are ordered */ Reorder_lsf(lsf_int, LSF_GAP, M); Reorder_lsf(lsf_int_variab, LSF_GAP, M); /* copy lsf to speech decoders lsf state */ Copy(lsf_int, lsfState->past_lsf_q, M); /* convert to lsp */ Lsf_lsp(lsf_int, lsp_int, M); Lsf_lsp(lsf_int_variab, lsp_int_variab, M); /* Compute acoeffs Q12 acoeff is used for level * * normalization and postfilter, acoeff_variab is * * used for synthesis filter * * by doing this we make sure that the level * * in high frequenncies does not jump up and down */ Lsp_Az(lsp_int, acoeff); Lsp_Az(lsp_int_variab, acoeff_variab); /* For use in postfilter */ Copy(acoeff, &A_t[0], M + 1); Copy(acoeff, &A_t[M + 1], M + 1); Copy(acoeff, &A_t[2 * (M + 1)], M + 1); Copy(acoeff, &A_t[3 * (M + 1)], M + 1); /* Compute reflection coefficients Q15 */ A_Refl(&acoeff[1], refl); /* Compute prediction error in Q15 */ pred_err = MAX_16; /* 0.99997 in Q15 */ move16(); for (i = 0; i < M; i++) { pred_err = mult(pred_err, sub(MAX_16, mult(refl[i], refl[i]))); } /* compute logarithm of prediction gain */ Log2(L_deposit_l(pred_err), &log_pg_e, &log_pg_m); /* convert exponent and mantissa to Word16 Q12 */ log_pg = shl(sub(log_pg_e,15), 12); /* Q12 */ move16(); log_pg = shr(sub(0,add(log_pg, shr(log_pg_m, 15-12))), 1); move16(); st->log_pg_mean = add(mult(29491,st->log_pg_mean), mult(3277, log_pg)); move16(); /* Compute interpolated log energy */ L_log_en_int = L_shr(L_log_en_int, 10); /* Q26 -> Q16 */ move32(); /* Add 4 in Q16 */ L_log_en_int = L_add(L_log_en_int, 4 * 65536L); move32(); /* subtract prediction gain */ L_log_en_int = L_sub(L_log_en_int, L_shl(L_deposit_l(log_pg), 4));move32(); /* adjust level to speech coder mode */ L_log_en_int = L_add(L_log_en_int, L_shl(L_deposit_l(st->log_en_adjust), 5)); move32(); log_en_int_e = extract_h(L_log_en_int); move16(); move16(); log_en_int_m = extract_l(L_shr(L_sub(L_log_en_int, L_deposit_h(log_en_int_e)), 1)); level = extract_l(Pow2(log_en_int_e, log_en_int_m)); /* Q4 */ move16(); for (i = 0; i < 4; i++) { /* Compute innovation vector */ build_CN_code(&st->L_pn_seed_rx, ex); for (j = 0; j < L_SUBFR; j++) { ex[j] = mult(level, ex[j]); move16(); } /* Synthesize */ Syn_filt(acoeff_variab, ex, &synth[i * L_SUBFR], L_SUBFR, mem_syn, 1); } /* next i */ /* reset codebook averaging variables */ averState->hangVar = 20; move16(); averState->hangCount = 0; move16(); test(); if (sub(new_state, DTX_MUTE) == 0) { /* mute comfort noise as it has been quite a long time since * last SID update was performed */ tmp_int_length = st->since_last_sid; move16(); test(); if (sub(tmp_int_length, 32) > 0) { tmp_int_length = 32; move16(); } /* safety guard against division by zero */ test(); if(tmp_int_length <= 0) { tmp_int_length = 8; move16(); } move16(); st->true_sid_period_inv = div_s(1 << 10, shl(tmp_int_length, 10)); st->since_last_sid = 0; move16(); Copy(st->lsp, st->lsp_old, M); st->old_log_en = st->log_en; move16(); /* subtract 1/8 in Q11 i.e -6/8 dB */ st->log_en = sub(st->log_en, 256); move16(); } /* reset interpolation length timer * if data has been updated. */ test(); test(); test(); test(); if ((st->sid_frame != 0) && ((st->valid_data != 0) || ((st->valid_data == 0) && (st->dtxHangoverAdded) != 0))) { st->since_last_sid = 0; move16(); st->data_updated = 1; move16(); } return 0; }