static void CFac_CalcFacSignal(FIXP_DBL *pOut, FIXP_DBL *pFac, const int fac_scale, const int fac_length, const FIXP_LPC A[M_LP_FILTER_ORDER], const INT A_exp, const int fAddZir, const int isFdFac) { FIXP_LPC wA[M_LP_FILTER_ORDER]; FIXP_DBL tf_gain = (FIXP_DBL)0; int wlength; int scale = fac_scale; /* obtain tranform gain. */ imdct_gain(&tf_gain, &scale, isFdFac ? 0 : fac_length); /* 4) Compute inverse DCT-IV of FAC data. Output scale of DCT IV is 16 bits. */ dct_IV(pFac, fac_length, &scale); /* dct_IV scale = log2(fac_length). "- 7" is a factor of 2/128 */ if (tf_gain != (FIXP_DBL)0) { /* non-radix 2 transform gain */ int i; for (i = 0; i < fac_length; i++) { pFac[i] = fMult(tf_gain, pFac[i]); } } scaleValuesSaturate(pOut, pFac, fac_length, scale); /* Avoid overflow issues and saturate. */ E_LPC_a_weight(wA, A, M_LP_FILTER_ORDER); /* We need the output of the IIR filter to be longer than "fac_length". For this reason we run it with zero input appended to the end of the input sequence, i.e. we generate its ZIR and extend the output signal.*/ FDKmemclear(pOut + fac_length, fac_length * sizeof(FIXP_DBL)); wlength = 2 * fac_length; /* 5) Apply weighted synthesis filter to FAC data, including optional Zir (5. * item 4). */ Syn_filt_zero(wA, A_exp, wlength, pOut); }
/* * E_MAIN_encode * * Parameters: * mode I: used mode * input_sp I: 320 new speech samples (at 16 kHz) * prms O: output parameters * spe_state B: state structure * allow_dtx I: DTX ON/OFF * * Function: * Main coder routine. * * Returns: * void */ Word16 E_MAIN_encode(Word16 * mode, Word16 speech16k[], Word16 prms[], void *spe_state, Word16 allow_dtx) { /* Float32 */ Float32 f_speech16k[L_FRAME16k]; /* Speech vector */ Float32 f_old_exc[(L_FRAME + 1) + PIT_MAX + L_INTERPOL]; /* Excitation vector */ Float32 f_exc2[L_FRAME]; /* excitation vector */ Float32 error[M + L_SUBFR]; /* error of quantization */ Float32 A[NB_SUBFR * (M + 1)]; /* A(z) unquantized for the 4 subframes */ Float32 Aq[NB_SUBFR * (M + 1)]; /* A(z) quantized for the 4 subframes */ Float32 xn[L_SUBFR]; /* Target vector for pitch search */ Float32 xn2[L_SUBFR]; /* Target vector for codebook search */ Float32 dn[L_SUBFR]; /* Correlation between xn2 and h1 */ Float32 cn[L_SUBFR]; /* Target vector in residual domain */ Float32 h1[L_SUBFR]; /* Impulse response vector */ Float32 f_code[L_SUBFR]; /* Fixed codebook excitation */ Float32 y1[L_SUBFR]; /* Filtered adaptive excitation */ Float32 y2[L_SUBFR]; /* Filtered adaptive excitation */ Float32 synth[L_SUBFR]; /* 12.8kHz synthesis vector */ Float32 r[M + 1]; /* Autocorrelations of windowed speech */ Float32 Ap[M + 1]; /* A(z) with spectral expansion */ Float32 ispnew[M]; /* immittance spectral pairs at 4nd sfr */ Float32 isf[M]; /* ISF (frequency domain) at 4nd sfr */ Float32 g_coeff[5], g_coeff2[2]; /* Correlations */ Float32 gain_pit; Float32 f_tmp, gain1, gain2; Float32 stab_fac = 0.0F, fac; Float32 *new_speech, *speech; /* Speech vector */ Float32 *wsp; /* Weighted speech vector */ Float32 *f_exc; /* Excitation vector */ Float32 *p_A, *p_Aq; /* ptr to A(z) for the 4 subframes */ Float32 *f_pt_tmp; /* Word32 */ Word32 indice[8]; /* quantization indices */ Word32 vad_flag, clip_gain; Word32 T_op, T_op2, T0, T0_frac; Word32 T0_min, T0_max; Word32 voice_fac, Q_new = 0; Word32 L_gain_code, l_tmp; Word32 i, i_subfr, pit_flag; /* Word16 */ Word16 exc2[L_FRAME]; /* excitation vector */ Word16 s_Aq[NB_SUBFR * (M + 1)]; /* A(z) quantized for the 4 subframes */ Word16 s_code[L_SUBFR]; /* Fixed codebook excitation */ Word16 ispnew_q[M]; /* quantized ISPs at 4nd subframe */ Word16 isfq[M]; /* quantized ISPs */ Word16 select, codec_mode; Word16 index; Word16 s_gain_pit, gain_code; Word16 s_tmp, s_max; Word16 corr_gain; Word16 *exc; /* Excitation vector */ /* Other */ Coder_State *st; /* Coder states */ /* Memory Usage eval */ st = (Coder_State *)spe_state; codec_mode = *mode; /* * Initialize pointers to speech vector. * * * |-------|-------|-------|-------|-------|-------| * past sp sf1 sf2 sf3 sf4 L_NEXT * <------- Total speech buffer (L_TOTAL) ------> * old_speech * <------- LPC analysis window (L_WINDOW) ------> * <-- present frame (L_FRAME) ----> * | <----- new speech (L_FRAME) ----> * | | * speech | * new_speech */ new_speech = st->mem_speech + L_TOTAL - L_FRAME - L_FILT + 460; /* New speech */ speech = st->mem_speech + L_TOTAL - L_FRAME - L_NEXT; /* Present frame */ exc = st->mem_exc + PIT_MAX + L_INTERPOL; f_exc = f_old_exc + PIT_MAX + L_INTERPOL; wsp = st->mem_wsp + (PIT_MAX / OPL_DECIM); for(i = 0; i < L_FRAME16k; i++) { f_speech16k[i] = (Float32)speech16k[i]; } Q_new = -st->mem_q; for(i = 0; i < (PIT_MAX + L_INTERPOL); i++) { f_old_exc[i] = (Float32)(st->mem_exc[i] * pow(2, Q_new)); } /* * Down sampling signal from 16kHz to 12.8kHz */ E_UTIL_decim_12k8(f_speech16k, L_FRAME16k, new_speech, st->mem_decim); /* decimate with zero-padding to avoid delay of filter */ memcpy(f_code, st->mem_decim, 2 * L_FILT16k * sizeof(Float32)); memset(error, 0, L_FILT16k * sizeof(Float32)); E_UTIL_decim_12k8(error, L_FILT16k, new_speech + L_FRAME, f_code); /* * Perform 50Hz HP filtering of input signal. * Perform fixed preemphasis through 1 - g z^-1 */ E_UTIL_hp50_12k8(new_speech, L_FRAME, st->mem_sig_in); memcpy(f_code, st->mem_sig_in, 4 * sizeof(Float32) ); E_UTIL_hp50_12k8(new_speech + L_FRAME, L_FILT, f_code); E_UTIL_f_preemph(new_speech, PREEMPH_FAC, L_FRAME, &(st->mem_preemph)); /* last L_FILT samples for autocorrelation window */ f_tmp = st->mem_preemph; E_UTIL_f_preemph(new_speech + L_FRAME, PREEMPH_FAC, L_FILT, &f_tmp); /* * Call VAD * Preemphesis scale down signal in low frequency and keep dynamic in HF. * Vad work slightly in future (new_speech = speech + L_NEXT - L_FILT). */ vad_flag = E_DTX_vad(st->vadSt, speech + L_NEXT - L_FILT); if (vad_flag == 0) { st->mem_vad_hist = 1; } else { st->mem_vad_hist = 0; } /* DTX processing */ if (allow_dtx) { /* Note that mode may change here */ E_DTX_tx_handler(st->dtx_encSt, vad_flag, mode); } else { E_DTX_reset(st->dtx_encSt); } if(*mode != MRDTX) { E_MAIN_parm_store(vad_flag, &prms); } /* * Perform LPC analysis * -------------------- * - autocorrelation + lag windowing * - Levinson-durbin algorithm to find a[] * - convert a[] to isp[] * - convert isp[] to isf[] for quantization * - quantize and code the isf[] * - convert isf[] to isp[] for interpolation * - find the interpolated isps and convert to a[] for the 4 subframes */ /* LP analysis centered at 3nd surame */ E_UTIL_autocorr(st->mem_speech, r); E_LPC_lag_wind(r + 1, M); /* Lagindowing */ E_LPC_lev_dur(A, r, M); E_LPC_a_isp_conversion(A, ispnew, st->mem_isp, M); /* From A(z) to isp */ /* Find the interpolated isps and convert to a[] for all subframes */ E_LPC_f_int_isp_find(st->mem_isp, ispnew, A, NB_SUBFR, M); /* update isp memory for the next frame */ memcpy(st->mem_isp, ispnew, M * sizeof(Float32)); /* Convert isps to frequency domain 0..6400 */ E_LPC_isp_isf_conversion(ispnew, isf, M); /* check resonance for pitch clipping algorithm */ E_GAIN_clip_isf_test(isf, st->mem_gp_clip); /* * Perform PITCH_OL analysis * ------------------------- * - Find the residual res[] for the whole speech frame * - Find the weighted input speech wsp[] for the whole speech frame * - Find the 2 open-loop pitch estimate * - Set the range for searching closed-loop pitch in 1st subframe */ p_A = A; for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { E_LPC_a_weight(p_A, Ap, GAMMA1, M); E_UTIL_residu(Ap, &speech[i_subfr], &wsp[i_subfr], L_SUBFR); p_A += (M + 1); } E_UTIL_deemph(wsp, TILT_FAC, L_FRAME, &(st->mem_wsp_df)); /* decimation of wsp[] to search pitch in LF and to reduce complexity */ E_GAIN_lp_decim2(wsp, L_FRAME, st->mem_decim2); /* Find open loop pitch lag for whole speech frame */ if (*mode == MODE_7k) { /* Find open loop pitch lag for whole speech frame */ T_op = E_GAIN_open_loop_search(wsp, PIT_MIN / OPL_DECIM, PIT_MAX / OPL_DECIM, L_FRAME / OPL_DECIM, st->mem_T0_med, &(st->mem_ol_gain), st->mem_hf_wsp, st->mem_hp_wsp, st->mem_ol_wght_flg); } else { /* Find open loop pitch lag for first 1/2 frame */ T_op = E_GAIN_open_loop_search(wsp, PIT_MIN / OPL_DECIM, PIT_MAX / OPL_DECIM, (L_FRAME / 2) / OPL_DECIM, st->mem_T0_med, &(st->mem_ol_gain), st->mem_hf_wsp, st->mem_hp_wsp, st->mem_ol_wght_flg); } if (st->mem_ol_gain > 0.6) { st->mem_T0_med = E_GAIN_olag_median(T_op, st->mem_ol_lag); st->mem_ada_w = 1.0F; } else { st->mem_ada_w = st->mem_ada_w * 0.9F; } if (st->mem_ada_w < 0.8) { st->mem_ol_wght_flg = 0; } else { st->mem_ol_wght_flg = 1; } E_DTX_pitch_tone_detection(st->vadSt, st->mem_ol_gain); T_op *= OPL_DECIM; if (*mode != MODE_7k) { /* Find open loop pitch lag for second 1/2 frame */ T_op2 = E_GAIN_open_loop_search(wsp + ((L_FRAME / 2) / OPL_DECIM), PIT_MIN / OPL_DECIM, PIT_MAX / OPL_DECIM, (L_FRAME / 2) / OPL_DECIM, st->mem_T0_med, &st->mem_ol_gain, st->mem_hf_wsp, st->mem_hp_wsp, st->mem_ol_wght_flg); if (st->mem_ol_gain > 0.6) { st->mem_T0_med = E_GAIN_olag_median(T_op2, st->mem_ol_lag); st->mem_ada_w = 1.0F; } else { st->mem_ada_w = st->mem_ada_w * 0.9F; } if (st->mem_ada_w < 0.8) { st->mem_ol_wght_flg = 0; } else { st->mem_ol_wght_flg = 1; } E_DTX_pitch_tone_detection(st->vadSt, st->mem_ol_gain); T_op2 *= OPL_DECIM; } else { T_op2 = T_op; } /* * DTX-CNG */ if(*mode == MRDTX) { /* Buffer isf's and energy */ E_UTIL_residu(&A[3 * (M + 1)], speech, f_exc, L_FRAME); f_tmp = 0.0; for(i = 0; i < L_FRAME; i++) { f_tmp += f_exc[i] * f_exc[i]; } E_DTX_buffer(st->dtx_encSt, isf, f_tmp, codec_mode); /* Quantize and code the isfs */ E_DTX_exe(st->dtx_encSt, f_exc2, &prms); /* reset speech coder memories */ E_MAIN_reset(st, 0); /* * Update signal for next frame. * -> save past of speech[] and wsp[]. */ memcpy(st->mem_speech, &st->mem_speech[L_FRAME], (L_TOTAL - L_FRAME + 460) * sizeof(Float32)); memcpy(st->mem_wsp, &st->mem_wsp[L_FRAME / OPL_DECIM], (PIT_MAX / OPL_DECIM) * sizeof(Float32)); return(0); } /* * ACELP */ /* Quantize and code the isfs */ if (*mode <= MODE_7k) { E_LPC_isf_2s3s_quantise(isf, isfq, st->mem_isf_q, indice, 4); E_MAIN_parm_store((Word16)indice[0], &prms); E_MAIN_parm_store((Word16)indice[1], &prms); E_MAIN_parm_store((Word16)indice[2], &prms); E_MAIN_parm_store((Word16)indice[3], &prms); E_MAIN_parm_store((Word16)indice[4], &prms); } else { E_LPC_isf_2s5s_quantise(isf, isfq, st->mem_isf_q, indice, 4); E_MAIN_parm_store((Word16)indice[0], &prms); E_MAIN_parm_store((Word16)indice[1], &prms); E_MAIN_parm_store((Word16)indice[2], &prms); E_MAIN_parm_store((Word16)indice[3], &prms); E_MAIN_parm_store((Word16)indice[4], &prms); E_MAIN_parm_store((Word16)indice[5], &prms); E_MAIN_parm_store((Word16)indice[6], &prms); } /* Convert isfs to the cosine domain */ E_LPC_isf_isp_conversion(isfq, ispnew_q, M); if (*mode == MODE_24k) { /* Check stability on isf : distance between old isf and current isf */ f_tmp = 0.0F; f_pt_tmp = st->mem_isf; for (i=0; i < M - 1; i++) { f_tmp += (isf[i] - f_pt_tmp[i]) * (isf[i] - f_pt_tmp[i]); } stab_fac = (Float32)(1.25F - (f_tmp / 400000.0F)); if (stab_fac > 1.0F) { stab_fac = 1.0F; } if (stab_fac < 0.0F) { stab_fac = 0.0F; } memcpy(f_pt_tmp, isf, M * sizeof(Float32)); } if (st->mem_first_frame == 1) { st->mem_first_frame = 0; memcpy(st->mem_isp_q, ispnew_q, M * sizeof(Word16)); } /* Find the interpolated isps and convert to a[] for all subframes */ E_LPC_int_isp_find(st->mem_isp_q, ispnew_q, E_ROM_interpol_frac, s_Aq); for (i = 0; i < (NB_SUBFR * (M + 1)); i++) { Aq[i] = s_Aq[i] * 0.000244140625F; /* 1/4096 */ } /* update isp memory for the next frame */ memcpy(st->mem_isp_q, ispnew_q, M * sizeof(Word16)); /* * Find the best interpolation for quantized ISPs */ p_Aq = Aq; for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { E_UTIL_residu(p_Aq, &speech[i_subfr], &f_exc[i_subfr], L_SUBFR); p_Aq += (M + 1); } /* Buffer isf's and energy for dtx on non-speech frame */ if(vad_flag == 0) { f_tmp = 0.0F; for(i = 0; i < L_FRAME; i++) { f_tmp += f_exc[i] * f_exc[i]; } E_DTX_buffer(st->dtx_encSt, isf, f_tmp, codec_mode); } /* range for closed loop pitch search in 1st subframe */ T0_min = T_op - 8; if (T0_min < PIT_MIN) { T0_min = PIT_MIN; } T0_max = T0_min + 15; if (T0_max > PIT_MAX) { T0_max = PIT_MAX; T0_min = T0_max - 15; } /* * 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. * - compute the target signal for pitch search * - compute impulse response of weighted synthesis filter (h1[]) * - find the closed-loop pitch parameters * - encode the pitch dealy * - find 2 lt prediction (with / without LP filter for lt pred) * - find 2 pitch gains and choose the best lt prediction. * - find target vector for codebook search * - update the impulse response h1[] for codebook search * - correlation between target vector and impulse response * - codebook search and encoding * - VQ of pitch and codebook gains * - find voicing factor and tilt of code for next subframe. * - update states of weighting filter * - find excitation and synthesis speech */ p_A = A; p_Aq = Aq; for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { pit_flag = i_subfr; if ((i_subfr == (2 * L_SUBFR)) & (*mode > MODE_7k)) { pit_flag = 0; /* range for closed loop pitch search in 3rd subframe */ T0_min = T_op2 - 8; if (T0_min < PIT_MIN) { T0_min = PIT_MIN; } T0_max = T0_min + 15; if (T0_max > PIT_MAX) { T0_max = PIT_MAX; T0_min = T0_max - 15; } } /* * * 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. * */ for (i = 0; i < M; i++) { error[i] = (Float32)(speech[i + i_subfr - 16] - st->mem_syn[i]); } E_UTIL_residu(p_Aq, &speech[i_subfr], &f_exc[i_subfr], L_SUBFR); E_UTIL_synthesis(p_Aq, &f_exc[i_subfr], error + M, L_SUBFR, error, 0); E_LPC_a_weight(p_A, Ap, GAMMA1, M); E_UTIL_residu(Ap, error + M, xn, L_SUBFR); E_UTIL_deemph(xn, TILT_FAC, L_SUBFR, &(st->mem_w0)); /* * Find target in residual domain (cn[]) for innovation search. */ /* first half: xn[] --> cn[] */ memset(f_code, 0, M * sizeof(Float32)); memcpy(f_code + M, xn, (L_SUBFR / 2) * sizeof(Float32)); f_tmp = 0.0F; E_UTIL_f_preemph(f_code + M, TILT_FAC, L_SUBFR / 2, &f_tmp); E_LPC_a_weight(p_A, Ap, GAMMA1, M); E_UTIL_synthesis(Ap, f_code + M, f_code + M, L_SUBFR / 2, f_code, 0); E_UTIL_residu(p_Aq, f_code + M, cn, L_SUBFR / 2); /* second half: res[] --> cn[] (approximated and faster) */ for(i = (L_SUBFR / 2); i < L_SUBFR; i++) { cn[i] = f_exc[i_subfr + i]; } /* * Compute impulse response, h1[], of weighted synthesis filter */ E_LPC_a_weight(p_A, Ap, GAMMA1, M); memset(h1, 0, L_SUBFR * sizeof(Float32)); memcpy(h1, Ap, (M + 1) * sizeof(Float32)); E_UTIL_synthesis(p_Aq, h1, h1, L_SUBFR, h1 + (M + 1), 0); f_tmp = 0.0; E_UTIL_deemph(h1, TILT_FAC, L_SUBFR, &f_tmp); /* * Closed-loop fractional pitch search */ /* find closed loop fractional pitch lag */ if (*mode <= MODE_9k) { T0 = E_GAIN_closed_loop_search(&f_exc[i_subfr], xn, h1, T0_min, T0_max, &T0_frac, pit_flag, PIT_MIN, PIT_FR1_8b); /* encode pitch lag */ if (pit_flag == 0) /* if 1st/3rd subframe */ { /* * The pitch range for the 1st/3rd subframe is encoded with * 8 bits and is divided as follows: * PIT_MIN to PIT_FR1-1 resolution 1/2 (frac = 0 or 2) * PIT_FR1 to PIT_MAX resolution 1 (frac = 0) */ if (T0 < PIT_FR1_8b) { index = (Word16)(T0 * 2 + (T0_frac >> 1) - (PIT_MIN * 2)); } else { index = (Word16)(T0 - PIT_FR1_8b + ((PIT_FR1_8b - PIT_MIN) * 2)); } E_MAIN_parm_store(index, &prms); /* find T0_min and T0_max for subframe 2 and 4 */ T0_min = T0 - 8; if (T0_min < PIT_MIN) { T0_min = PIT_MIN; } T0_max = T0_min + 15; if (T0_max > PIT_MAX) { T0_max = PIT_MAX; T0_min = T0_max - 15; } }