开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
enc_main.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：42k
源码类别：

Symbian

开发平台：

Visual C++

enc_main.c：源码内容
  1. /*
  2.  *===================================================================
  3.  *  3GPP AMR Wideband Floating-point Speech Codec
  4.  *===================================================================
  5.  */
  6. #include <stdlib.h>
  7. #include "hlxclib/memory.h"
  8. #include <math.h>
  9. #include <float.h>
  10. #include <string.h>
  11. #include <stdio.h>
  13. #include "enc_dtx.h"
  14. #include "enc_acelp.h"
  15. #include "enc_lpc.h"
  16. #include "enc_main.h"
  17. #include "enc_gain.h"
  18. #include "enc_util.h"
  20. #ifdef WIN32
  21. #pragma warning( disable : 4310)
  22. #endif
  24. #include "typedef.h"
  26. #define MAX_16       (Word16)0x7fff
  27. #define MIN_16       (Word16)0x8000
  28. #define Q_MAX        8        /* scaling max for signal                 */
  29. #define PREEMPH_FAC  0.68F    /* preemphasis factor                     */
  30. #define GAMMA1       0.92F    /* Weighting factor (numerator)           */
  31. #define TILT_FAC     0.68F    /* tilt factor (denominator)              */
  32. #define PIT_MIN      34       /* Minimum pitch lag with resolution 1/4  */
  33. #define PIT_FR2      128      /* Minimum pitch lag with resolution 1/2  */
  34. #define PIT_FR1_9b   160      /* Minimum pitch lag with resolution 1    */
  35. #define PIT_FR1_8b   92       /* Minimum pitch lag with resolution 1    */
  36. #define PIT_MAX      231      /* Maximum pitch lag                      */
  37. #define L_INTERPOL   (16+1)   /* Length of filter for interpolation     */
  38. #define L_FRAME16k   320      /* Frame size at 16kHz                    */
  39. #define L_SUBFR      64       /* Subframe size                          */
  40. #define NB_SUBFR     4        /* Number of subframe per frame           */
  41. #define L_FILT       12       /* Delay of up-sampling filter            */
  42. #define L_NEXT       64       /* Overhead in LP analysis                */
  43. #define MODE_7k      0        /* modes                                  */
  44. #define MODE_9k      1
  45. #define MODE_12k     2
  46. #define MODE_14k     3
  47. #define MODE_16k     4
  48. #define MODE_18k     5
  49. #define MODE_20k     6
  50. #define MODE_23k     7
  51. #define MODE_24k     8
  52. #define MRDTX        10
  54. extern const Word16 E_ROM_isp[];
  55. extern const Word16 E_ROM_isf[];
  56. extern const Word16 E_ROM_interpol_frac[];
  58. /*
  59.  * E_MAIN_reset
  60.  *
  61.  * Parameters:
  62.  *    st        I/O: pointer to state structure
  63.  *    reset_all   I: perform full reset
  64.  *
  65.  * Function:
  66.  *    Initialisation of variables for the coder section.
  67.  *
  68.  *
  69.  * Returns:
  70.  *    void
  71.  */
  72. void E_MAIN_reset(void *st, Word16 reset_all)
  73. {
  74.    Word32 i;
  76.    Coder_State *cod_state;
  78.    cod_state = (Coder_State *) st;
  80.    memset(cod_state->mem_exc, 0, (PIT_MAX + L_INTERPOL) * sizeof(Word16));
  81.    memset(cod_state->mem_isf_q, 0, M * sizeof(Word16));
  82.    memset(cod_state->mem_syn, 0, M * sizeof(Float32));
  84.    cod_state->mem_w0 = 0.0F;
  85.    cod_state->mem_tilt_code = 0;
  86.    cod_state->mem_first_frame = 1;
  88.    E_GAIN_clip_init(cod_state->mem_gp_clip);
  90.    cod_state->mem_gc_threshold = 0.0F;
  92.    if (reset_all != 0)
  93.    {
  94.       /* Set static vectors to zero */
  95.       memset(cod_state->mem_speech, 0, (L_TOTAL - L_FRAME) * sizeof(Float32));
  96.       memset(cod_state->mem_wsp, 0, (PIT_MAX / OPL_DECIM) * sizeof(Float32));
  97.       memset(cod_state->mem_decim2, 0, 3 * sizeof(Float32));
  99.       /* routines initialization */
  101.       memset(cod_state->mem_decim, 0, 2 * L_FILT16k * sizeof(Float32));
  102.       memset(cod_state->mem_sig_in, 0, 4 * sizeof(Float32));
  103.       E_ACELP_Gain2_Q_init(cod_state->mem_gain_q);
  104.       memset(cod_state->mem_hf_wsp, 0, 8 * sizeof(Float32));
  106.       /* isp initialization */
  107.       for (i = 0; i < M - 1; i++)
  108.       {
  109.          cod_state->mem_isp[i] =
  110.             (Float32)cos(3.141592654 * (Float32)(i + 1) / (Float32)M);
  111.       }
  113.       cod_state->mem_isp[M - 1] = 0.045F;
  114.       memcpy(cod_state->mem_isp_q, E_ROM_isp, M * sizeof(Word16));
  116.       /* variable initialization */
  117.       cod_state->mem_preemph = 0.0F;
  118.       cod_state->mem_wsp_df = 0.0F;
  119.       cod_state->mem_q = Q_MAX;
  120.       cod_state->mem_subfr_q[3] = Q_MAX;
  121.       cod_state->mem_subfr_q[2] = Q_MAX;
  122.       cod_state->mem_subfr_q[1] = Q_MAX;
  123.       cod_state->mem_subfr_q[0] = Q_MAX;
  124.       cod_state->mem_ada_w = 0.0F;
  125.       cod_state->mem_ol_gain = 0.0F;
  126.       cod_state->mem_ol_wght_flg = 0;
  128.       for (i = 0; i < 5; i++)
  129.       {
  130.          cod_state->mem_ol_lag[i] = 40;
  131.       }
  133.       cod_state->mem_T0_med = 40;
  134.       memset(cod_state->mem_hp_wsp, 0,
  135.          ( ( L_FRAME / 2 ) / OPL_DECIM + ( PIT_MAX / OPL_DECIM ) )
  136.          * sizeof(Float32) );
  138.       memset(cod_state->mem_syn_hf, 0, M * sizeof(Float32));
  139.       memset(cod_state->mem_syn2, 0, M * sizeof(Float32));
  141.       memset(cod_state->mem_hp400, 0, 4 * sizeof(Float32));
  142.       memset(cod_state->mem_sig_out, 0, 4 * sizeof(Float32));
  144.       memset(cod_state->mem_hf, 0, 2 * L_FILT16k * sizeof(Float32));
  145.       memset(cod_state->mem_hf2, 0, 2 * L_FILT16k * sizeof(Float32));
  146.       memset(cod_state->mem_hf3, 0, 2 * L_FILT16k * sizeof(Float32));
  148.       memcpy(cod_state->mem_isf, E_ROM_isf, M * sizeof(Float32));
  150.       cod_state->mem_deemph = 0.0F;
  152.       cod_state->mem_seed = 21845;
  153.       cod_state->mem_gain_alpha = 1.0F;
  154.       cod_state->mem_vad_hist = 0;
  156.       E_DTX_reset(cod_state->dtx_encSt);
  157.       E_DTX_vad_reset(cod_state->vadSt);
  158.    }
  159. }
  161. /*
  162.  * E_MAIN_init
  163.  *
  164.  * Parameters:
  165.  *    spe_state         I/O: pointer to state structure
  166.  *
  167.  * Function:
  168.  *    Initialisation of variables for the coder section.
  169.  *    Memory allocation.
  170.  *
  171.  * Returns:
  172.  *    void
  173.  */
  174. Word16 E_MAIN_init(void **spe_state)
  175. {
  176.    Coder_State *st;
  178.    *spe_state = NULL;
  180.    /* allocate memory */
  181.    if ((st = (Coder_State *) malloc(sizeof(Coder_State))) == NULL)
  182.    {
  183.       return(-1);
  184.    }
  186.    st->vadSt = NULL;
  187.    st->dtx_encSt = NULL;
  189.    E_DTX_init(&(st->dtx_encSt));
  190.    E_DTX_vad_init(&(st->vadSt));
  192.    E_MAIN_reset((void *) st, 1);
  194.    *spe_state = (void*)st;
  196.    return(0);
  197. }
  199. /*
  200.  * E_MAIN_close
  201.  *
  202.  *
  203.  * Parameters:
  204.  *    spe_state   I: pointer to state structure
  205.  *
  206.  * Function:
  207.  *    Free coder memory.
  208.  *
  209.  *
  210.  * Returns:
  211.  *    void
  212.  */
  213. void E_MAIN_close(void **spe_state)
  214. {
  215.    E_DTX_exit(&( ( (Coder_State *)(*spe_state) )->dtx_encSt));
  216.    E_DTX_vad_exit(&( ( (Coder_State *) (*spe_state) )->vadSt));
  217.    free(*spe_state);
  219.    return;
  220. }
  222. /*
  223.  * E_MAIN_parm_store
  224.  *
  225.  * Parameters:
  226.  *    value       I: parameter value
  227.  *    prms        O: output parameters
  228.  *
  229.  * Function:
  230.  *    Store parameter values
  231.  *
  232.  * Returns:
  233.  *    void
  234.  */
  235. static void E_MAIN_parm_store(Word32 value, Word16 **prms)
  236. {
  237.    **prms = (Word16)value;
  238.    (*prms)++;
  239.    return;
  240. }
  243. /*
  244.  * E_MAIN_encode
  245.  *
  246.  * Parameters:
  247.  *    mode        I: used mode
  248.  *    input_sp    I: 320 new speech samples (at 16 kHz)
  249.  *    prms        O: output parameters
  250.  *    spe_state   B: state structure
  251.  *    allow_dtx   I: DTX ON/OFF
  252.  *
  253.  * Function:
  254.  *    Main coder routine.
  255.  *
  256.  * Returns:
  257.  *    void
  258.  */
  259. Word16 E_MAIN_encode(Word16 * mode, Word16 speech16k[], Word16 prms[],
  260.                     void *spe_state, Word16 allow_dtx)
  261. {
  263.    /* Float32 */
  264.    Float32 f_speech16k[L_FRAME16k];    /* Speech vector                          */
  265.    Float32 f_old_exc[(L_FRAME + 1) + PIT_MAX + L_INTERPOL]; /* Excitation vector */
  266.    Float32 f_exc2[L_FRAME];            /* excitation vector                      */
  267.    Float32 error[M + L_SUBFR];         /* error of quantization                  */
  268.    Float32 A[NB_SUBFR * (M + 1)];      /* A(z) unquantized for the 4 subframes   */
  269.    Float32 Aq[NB_SUBFR * (M + 1)];     /* A(z)   quantized for the 4 subframes   */
  270.    Float32 xn[L_SUBFR];                /* Target vector for pitch search         */
  271.    Float32 xn2[L_SUBFR];               /* Target vector for codebook search      */
  272.    Float32 dn[L_SUBFR];                /* Correlation between xn2 and h1         */
  273.    Float32 cn[L_SUBFR];                /* Target vector in residual domain       */
  274.    Float32 h1[L_SUBFR];                /* Impulse response vector                */
  275.    Float32 f_code[L_SUBFR];            /* Fixed codebook excitation              */
  276.    Float32 y1[L_SUBFR];                /* Filtered adaptive excitation           */
  277.    Float32 y2[L_SUBFR];                /* Filtered adaptive excitation           */
  278.    Float32 synth[L_SUBFR];             /* 12.8kHz synthesis vector               */
  279.    Float32 r[M + 1];                   /* Autocorrelations of windowed speech    */
  280.    Float32 Ap[M + 1];                  /* A(z) with spectral expansion           */
  281.    Float32 ispnew[M];                  /* immittance spectral pairs at 4nd sfr   */
  282.    Float32 isf[M];                     /* ISF (frequency domain) at 4nd sfr      */
  283.    Float32 g_coeff[5], g_coeff2[2];    /* Correlations                           */
  284.    Float32 gain_pit;
  285.    Float32 f_tmp, gain1, gain2;
  286.    Float32 stab_fac = 0.0F, fac;
  287.    Float32 *new_speech, *speech;       /* Speech vector                          */
  288.    Float32 *wsp;                       /* Weighted speech vector                 */
  289.    Float32 *f_exc;                     /* Excitation vector                      */
  290.    Float32 *p_A, *p_Aq;                /* ptr to A(z) for the 4 subframes        */
  291.    Float32 *f_pt_tmp;
  293.    /* Word32 */
  294.    Word32 indice[8];                   /* quantization indices                   */
  295.    Word32 vad_flag, clip_gain;
  296.    Word32 T_op, T_op2, T0, T0_frac;
  297.    Word32 T0_min, T0_max;
  298.    Word32 voice_fac, Q_new = 0;
  299.    Word32 L_gain_code, l_tmp;
  300.    Word32 i, i_subfr, pit_flag;
  302.    /* Word16 */
  303.    Word16 exc2[L_FRAME];               /* excitation vector                      */
  304.    Word16 s_Aq[NB_SUBFR * (M + 1)];    /* A(z) quantized for the 4 subframes     */
  305.    Word16 s_code[L_SUBFR];             /* Fixed codebook excitation              */
  306.    Word16 ispnew_q[M];                 /* quantized ISPs at 4nd subframe         */
  307.    Word16 isfq[M];                     /* quantized ISPs                         */
  308.    Word16 select, codec_mode;
  309.    Word16 index;
  310.    Word16 s_gain_pit, gain_code;
  311.    Word16 s_tmp, s_max;
  312.    Word16 corr_gain;
  313.    Word16 *exc;                        /* Excitation vector                      */
  315.    /* Other */
  316.    Coder_State *st;                    /* Coder states                           */
  318.    st = (Coder_State *)spe_state;
  319.    codec_mode = *mode;
  321.    /*
  322.     * Initialize pointers to speech vector.
  323.     *
  324.     *
  325.     *         |-------|-------|-------|-------|-------|-------|
  326.     *          past sp   sf1     sf2     sf3     sf4    L_NEXT
  327.     *         <-------  Total speech buffer (L_TOTAL)   ------>
  328.     *   old_speech
  329.     *         <-------  LPC analysis window (L_WINDOW)  ------>
  330.     *                 <-- present frame (L_FRAME) ---->
  331.     *                 |       <----- new speech (L_FRAME) ---->
  332.     *                 |       |
  333.     *               speech    |
  334.     *                      new_speech
  335.     */
  337.    new_speech = st->mem_speech + L_TOTAL - L_FRAME - L_FILT;     /* New speech     */
  338.    speech     = st->mem_speech + L_TOTAL - L_FRAME - L_NEXT;     /* Present frame  */
  340.    exc = st->mem_exc + PIT_MAX + L_INTERPOL;
  341.    f_exc = f_old_exc + PIT_MAX + L_INTERPOL;
  342.    wsp = st->mem_wsp + (PIT_MAX / OPL_DECIM);
  344.    for(i = 0; i < L_FRAME16k; i++)
  345.    {
  346.       f_speech16k[i] = (Float32)speech16k[i];
  347.    }
  349.    Q_new = -st->mem_q;
  351.    for(i = 0; i < (PIT_MAX + L_INTERPOL); i++)
  352.    {
  353.       f_old_exc[i] = (Float32)(st->mem_exc[i] * pow(2, Q_new));
  354.    }
  356.    /*
  357.     * Down sampling signal from 16kHz to 12.8kHz
  358.     */
  359.    E_UTIL_decim_12k8(f_speech16k, L_FRAME16k, new_speech, st->mem_decim);
  361.    /* decimate with zero-padding to avoid delay of filter */
  362.    memcpy(f_code, st->mem_decim, 2 * L_FILT16k * sizeof(Float32));
  363.    memset(error, 0, L_FILT16k * sizeof(Float32));
  365.    E_UTIL_decim_12k8(error, L_FILT16k, new_speech + L_FRAME, f_code);
  367.    /*
  368.     * Perform 50Hz HP filtering of input signal.
  369.     * Perform fixed preemphasis through 1 - g z^-1
  370.     */
  371.    E_UTIL_hp50_12k8(new_speech, L_FRAME, st->mem_sig_in);
  373.    memcpy(f_code, st->mem_sig_in,  4 * sizeof(Float32) );
  375.    E_UTIL_hp50_12k8(new_speech + L_FRAME, L_FILT, f_code);
  377.    E_UTIL_f_preemph(new_speech, PREEMPH_FAC, L_FRAME, &(st->mem_preemph));
  379.    /* last L_FILT samples for autocorrelation window */
  380.    f_tmp = st->mem_preemph;
  381.    E_UTIL_f_preemph(new_speech + L_FRAME, PREEMPH_FAC, L_FILT, &f_tmp);
  383.    /*
  384.     *  Call VAD
  385.     *  Preemphesis scale down signal in low frequency and keep dynamic in HF.
  386.     *  Vad work slightly in futur (new_speech = speech + L_NEXT - L_FILT).
  387.     */
  389.    vad_flag = E_DTX_vad(st->vadSt, new_speech);
  391.    if (vad_flag == 0)
  392.    {
  393.       st->mem_vad_hist = 1;
  394.    }
  395.    else
  396.    {
  397.       st->mem_vad_hist = 0;
  398.    }
  400.    /* DTX processing */
  401.    if (allow_dtx)
  402.    {
  403.       /* Note that mode may change here */
  404.       E_DTX_tx_handler(st->dtx_encSt, vad_flag, mode);
  405.    }
  406.    else
  407.    {
  408.       E_DTX_reset(st->dtx_encSt);
  409.    }
  411.    if(*mode != MRDTX)
  412.    {
  413.       E_MAIN_parm_store(vad_flag, &prms);
  414.    }
  416.    /*
  417.     *  Perform LPC analysis
  418.     *  --------------------
  419.     *   - autocorrelation + lag windowing
  420.     *   - Levinson-durbin algorithm to find a[]
  421.     *   - convert a[] to isp[]
  422.     *   - convert isp[] to isf[] for quantization
  423.     *   - quantize and code the isf[]
  424.     *   - convert isf[] to isp[] for interpolation
  425.     *   - find the interpolated isps and convert to a[] for the 4 subframes
  426.     */
  428.    /* LP analysis centered at 3nd subframe */
  429.    E_UTIL_autocorr(st->mem_speech, r);
  430.    E_LPC_lag_wind(r + 1, M);  /* Lag windowing    */
  432.    E_LPC_lev_dur(A, r, M);
  434.    E_LPC_a_isp_conversion(A, ispnew, st->mem_isp, M);  /* From A(z) to isp */
  436.    /* Find the interpolated isps and convert to a[] for all subframes */
  437.    E_LPC_f_int_isp_find(st->mem_isp, ispnew, A, NB_SUBFR, M);
  439.    /* update isp memory for the next frame */
  440.    memcpy(st->mem_isp, ispnew, M * sizeof(Float32));
  442.    /* Convert isps to frequency domain 0..6400 */
  443.    E_LPC_isp_isf_conversion(ispnew, isf, M);
  445.    /* check resonance for pitch clipping algorithm */
  446.    E_GAIN_clip_isf_test(isf, st->mem_gp_clip);
  449.    /*
  450.     *  Perform PITCH_OL analysis
  451.     *  -------------------------
  452.     * - Find the residual res[] for the whole speech frame
  453.     * - Find the weighted input speech wsp[] for the whole speech frame
  454.     * - Find the 2 open-loop pitch estimate
  455.     * - Set the range for searching closed-loop pitch in 1st subframe
  456.     */
  458.    p_A = A;
  460.    for (i_subfr = 0;  i_subfr < L_FRAME; i_subfr += L_SUBFR)
  461.    {
  462.       E_LPC_a_weight(p_A, Ap, GAMMA1, M);
  464.       E_UTIL_residu(Ap, &speech[i_subfr], &wsp[i_subfr], L_SUBFR);
  466.       p_A += (M + 1);
  467.    }
  469.    E_UTIL_deemph(wsp, TILT_FAC, L_FRAME, &(st->mem_wsp_df));
  471.    /* decimation of wsp[] to search pitch in LF and to reduce complexity */
  473.    E_GAIN_lp_decim2(wsp, L_FRAME, st->mem_decim2);
  475.    /* Find open loop pitch lag for whole speech frame */
  477.    if (*mode == MODE_7k)
  478.    {
  479.       /* Find open loop pitch lag for whole speech frame */
  481.       T_op = E_GAIN_open_loop_search(wsp, PIT_MIN / OPL_DECIM,
  482.          PIT_MAX / OPL_DECIM, L_FRAME / OPL_DECIM, st->mem_T0_med,
  483.          &(st->mem_ol_gain), st->mem_hf_wsp, st->mem_hp_wsp,
  484.          st->mem_ol_wght_flg);
  485.    }
  486.    else
  487.    {
  488.       /* Find open loop pitch lag for first 1/2 frame */
  490.       T_op = E_GAIN_open_loop_search(wsp, PIT_MIN / OPL_DECIM,
  491.          PIT_MAX / OPL_DECIM, (L_FRAME / 2) / OPL_DECIM, st->mem_T0_med,
  492.          &(st->mem_ol_gain), st->mem_hf_wsp, st->mem_hp_wsp,
  493.          st->mem_ol_wght_flg);
  494.    }
  496.    if (st->mem_ol_gain > 0.6)
  497.    {
  498.       st->mem_T0_med = E_GAIN_olag_median(T_op, st->mem_ol_lag);
  499.       st->mem_ada_w = 1.0F;
  500.    }
  501.    else
  502.    {
  503.       st->mem_ada_w = st->mem_ada_w * 0.9F;
  504.    }
  506.    if (st->mem_ada_w < 0.8)
  507.    {
  508.       st->mem_ol_wght_flg = 0;
  509.    }
  510.    else
  511.    {
  512.       st->mem_ol_wght_flg = 1;
  513.    }
  515.    E_DTX_pitch_tone_detection(st->vadSt, st->mem_ol_gain);
  517.    T_op *= OPL_DECIM;
  519.    if (*mode != MODE_7k)
  520.    {
  521.       /* Find open loop pitch lag for second 1/2 frame */
  522.       T_op2 = E_GAIN_open_loop_search(wsp + ((L_FRAME / 2) / OPL_DECIM),
  523.          PIT_MIN / OPL_DECIM, PIT_MAX / OPL_DECIM, (L_FRAME / 2) / OPL_DECIM,
  524.          st->mem_T0_med, &st->mem_ol_gain, st->mem_hf_wsp, st->mem_hp_wsp,
  525.          st->mem_ol_wght_flg);
  527.       if (st->mem_ol_gain > 0.6)
  528.       {
  529.           st->mem_T0_med = E_GAIN_olag_median(T_op2, st->mem_ol_lag);
  530.           st->mem_ada_w = 1.0F;
  531.       }
  532.       else
  533.       {
  534.           st->mem_ada_w = st->mem_ada_w * 0.9F;
  535.       }
  537.       if (st->mem_ada_w < 0.8)
  538.       {
  539.          st->mem_ol_wght_flg = 0;
  540.       }
  541.       else
  542.       {
  543.          st->mem_ol_wght_flg = 1;
  544.       }
  546.       E_DTX_pitch_tone_detection(st->vadSt, st->mem_ol_gain);
  548.       T_op2 *= OPL_DECIM;
  549.    }
  550.    else
  551.    {
  552.       T_op2 = T_op;
  553.    }
  555.    /*
  556.     * DTX-CNG
  557.     */
  558.    if(*mode == MRDTX)
  559.    {
  560.       /* Buffer isf's and energy */
  561.       E_UTIL_residu(&A[3 * (M + 1)], speech, f_exc, L_FRAME);
  562.       f_tmp = 0.0;
  564.       for(i = 0; i < L_FRAME; i++)
  565.       {
  566.          f_tmp += f_exc[i] * f_exc[i];
  567.       }
  569.       E_DTX_buffer(st->dtx_encSt, isf, f_tmp, codec_mode);
  571.       /* Quantize and code the isfs */
  572.       E_DTX_exe(st->dtx_encSt, f_exc2, &prms);
  574.       /* reset speech coder memories */
  575.       E_MAIN_reset(st, 0);
  577.       /*
  578.        * Update signal for next frame.
  579.        * -> save past of speech[] and wsp[].
  580.        */
  581.       memcpy(st->mem_speech, &st->mem_speech[L_FRAME],
  582.          (L_TOTAL - L_FRAME) * sizeof(Float32));
  583.       memcpy(st->mem_wsp, &st->mem_wsp[L_FRAME / OPL_DECIM],
  584.          (PIT_MAX / OPL_DECIM) * sizeof(Float32));
  586.       return(0);
  587.    }
  589.    /*
  590.     *   ACELP
  591.     */
  593.    /* Quantize and code the isfs */
  595.    if (*mode <= MODE_7k)
  596.    {
  597.       E_LPC_isf_2s3s_quantise(isf, isfq, st->mem_isf_q, indice, 4);
  598.       E_MAIN_parm_store((Word16)indice[0], &prms);
  599.       E_MAIN_parm_store((Word16)indice[1], &prms);
  600.       E_MAIN_parm_store((Word16)indice[2], &prms);
  601.       E_MAIN_parm_store((Word16)indice[3], &prms);
  602.       E_MAIN_parm_store((Word16)indice[4], &prms);
  603.    }
  604.    else
  605.    {
  606.       E_LPC_isf_2s5s_quantise(isf, isfq, st->mem_isf_q, indice, 4);
  607.       E_MAIN_parm_store((Word16)indice[0], &prms);
  608.       E_MAIN_parm_store((Word16)indice[1], &prms);
  609.       E_MAIN_parm_store((Word16)indice[2], &prms);
  610.       E_MAIN_parm_store((Word16)indice[3], &prms);
  611.       E_MAIN_parm_store((Word16)indice[4], &prms);
  612.       E_MAIN_parm_store((Word16)indice[5], &prms);
  613.       E_MAIN_parm_store((Word16)indice[6], &prms);
  614.    }
  616.    /* Convert isfs to the cosine domain */
  617.    E_LPC_isf_isp_conversion(isfq, ispnew_q, M);
  619.    if (*mode == MODE_24k)
  620.    {
  621.       /* Check stability on isf : distance between old isf and current isf */
  623.       f_tmp = 0.0F;
  624.       f_pt_tmp = st->mem_isf;
  626.       for (i=0; i < M - 1; i++)
  627.       {
  628.          f_tmp += (isf[i] - f_pt_tmp[i]) * (isf[i] - f_pt_tmp[i]);
  629.       }
  631.       stab_fac = (Float32)(1.25F - (f_tmp / 400000.0F));
  633.       if (stab_fac > 1.0F)
  634.       {
  635.          stab_fac = 1.0F;
  636.       }
  638.       if (stab_fac < 0.0F)
  639.       {
  640.          stab_fac = 0.0F;
  641.       }
  643.       memcpy(f_pt_tmp, isf, M * sizeof(Float32));
  644.    }
  647.    if (st->mem_first_frame == 1)
  648.    {
  649.       st->mem_first_frame = 0;
  650.       memcpy(st->mem_isp_q, ispnew_q, M * sizeof(Word16));
  651.    }
  653.    /* Find the interpolated isps and convert to a[] for all subframes */
  654.    E_LPC_int_isp_find(st->mem_isp_q, ispnew_q, E_ROM_interpol_frac, s_Aq);
  657.    for (i = 0; i < (NB_SUBFR * (M + 1)); i++)
  658.    {
  659.       Aq[i] = s_Aq[i] * 0.000244140625F; /* 1/4096 */
  660.    }
  662.    /* update isp memory for the next frame */
  663.    memcpy(st->mem_isp_q, ispnew_q, M * sizeof(Word16));
  665.    /*
  666.     * Find the best interpolation for quantized ISPs
  667.     */
  669.    p_Aq = Aq;
  671.    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
  672.    {
  673.       E_UTIL_residu(p_Aq, &speech[i_subfr], &f_exc[i_subfr], L_SUBFR);
  674.       p_Aq += (M + 1);
  675.    }
  678.    /* Buffer isf's and energy for dtx on non-speech frame */
  680.    if(vad_flag == 0)
  681.    {
  682.       f_tmp = 0.0F;
  684.       for(i = 0; i < L_FRAME; i++)
  685.       {
  686.          f_tmp += f_exc[i] * f_exc[i];
  687.       }
  689.       E_DTX_buffer(st->dtx_encSt, isf, f_tmp, codec_mode);
  690.    }
  692.    /* range for closed loop pitch search in 1st subframe */
  694.    T0_min = T_op - 8;
  696.    if (T0_min < PIT_MIN)
  697.    {
  698.       T0_min = PIT_MIN;
  699.    }
  701.    T0_max = T0_min + 15;
  703.    if (T0_max > PIT_MAX)
  704.    {
  705.       T0_max = PIT_MAX;
  706.       T0_min = T0_max - 15;
  707.    }
  709.    /*
  710.     *          Loop for every subframe in the analysis frame
  711.     *          ---------------------------------------------
  712.     *  To find the pitch and innovation parameters. The subframe size is
  713.     *  L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times.
  714.     *     - compute the target signal for pitch search
  715.     *     - compute impulse response of weighted synthesis filter (h1[])
  716.     *     - find the closed-loop pitch parameters
  717.     *     - encode the pitch dealy
  718.     *     - find 2 lt prediction (with / without LP filter for lt pred)
  719.     *     - find 2 pitch gains and choose the best lt prediction.
  720.     *     - find target vector for codebook search
  721.     *     - update the impulse response h1[] for codebook search
  722.     *     - correlation between target vector and impulse response
  723.     *     - codebook search and encoding
  724.     *     - VQ of pitch and codebook gains
  725.     *     - find voicing factor and tilt of code for next subframe.
  726.     *     - update states of weighting filter
  727.     *     - find excitation and synthesis speech
  728.     */
  730.    p_A = A;
  731.    p_Aq = Aq;
  733.    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
  734.    {
  735.       pit_flag = i_subfr;
  737.       if ((i_subfr == (2 * L_SUBFR)) & (*mode > MODE_7k))
  738.       {
  739.          pit_flag = 0;
  741.          /* range for closed loop pitch search in 3rd subframe */
  743.          T0_min = T_op2 - 8;
  745.          if (T0_min < PIT_MIN)
  746.          {
  747.             T0_min = PIT_MIN;
  748.          }
  750.          T0_max = T0_min + 15;
  752.          if (T0_max > PIT_MAX)
  753.          {
  754.             T0_max = PIT_MAX;
  755.             T0_min = T0_max - 15;
  756.          }
  758.       }
  760.       /*
  761.        *
  762.        *        Find the target vector for pitch search:
  763.        *        ---------------------------------------
  764.        *
  765.        *             |------|  res[n]
  766.        * speech[n]---| A(z) |--------
  767.        *             |------|       |   |--------| error[n]  |------|
  768.        *                   zero -- (-)--| 1/A(z) |-----------| W(z) |-- target
  769.        *                   exc          |--------|           |------|
  770.        *
  771.        * Instead of subtracting the zero-input response of filters from
  772.        * the weighted input speech, the above configuration is used to
  773.        * compute the target vector.
  774.        *
  775.        */
  777.       for (i = 0; i < M; i++)
  778.       {
  779.          error[i] = (Float32)(speech[i + i_subfr - 16] - st->mem_syn[i]);
  780.       }
  782.       E_UTIL_residu(p_Aq, &speech[i_subfr], &f_exc[i_subfr], L_SUBFR);
  784.       E_UTIL_synthesis(p_Aq, &f_exc[i_subfr], error + M, L_SUBFR, error, 0);
  786.       E_LPC_a_weight(p_A, Ap, GAMMA1, M);
  788.       E_UTIL_residu(Ap, error + M, xn, L_SUBFR);
  790.       E_UTIL_deemph(xn, TILT_FAC, L_SUBFR, &(st->mem_w0));
  792.       /*
  793.        * Find target in residual domain (cn[]) for innovation search.
  794.        */
  796.       /* first half: xn[] --> cn[] */
  797.       memset(f_code, 0, M * sizeof(Float32));
  799.       memcpy(f_code + M, xn, (L_SUBFR / 2) * sizeof(Float32));
  801.       f_tmp = 0.0F;
  803.       E_UTIL_f_preemph(f_code + M, TILT_FAC, L_SUBFR / 2, &f_tmp);
  805.       E_LPC_a_weight(p_A, Ap, GAMMA1, M);
  807.       E_UTIL_synthesis(Ap, f_code + M, f_code + M, L_SUBFR / 2, f_code, 0);
  809.       E_UTIL_residu(p_Aq, f_code + M, cn, L_SUBFR / 2);
  811.       /* second half: res[] --> cn[] (approximated and faster) */
  812.       for(i = (L_SUBFR / 2); i < L_SUBFR; i++)
  813.       {
  814.          cn[i] = f_exc[i_subfr + i];
  815.       }
  817.       /*
  818.        * Compute impulse response, h1[], of weighted synthesis filter
  819.        */
  821.       E_LPC_a_weight(p_A, Ap, GAMMA1, M);
  823.       memset(h1, 0, L_SUBFR * sizeof(Float32));
  824.       memcpy(h1, Ap, (M + 1) * sizeof(Float32));
  825.       E_UTIL_synthesis(p_Aq, h1, h1, L_SUBFR, h1 + (M + 1), 0);
  827.       f_tmp = 0.0;
  828.       E_UTIL_deemph(h1, TILT_FAC, L_SUBFR, &f_tmp);
  830.       /*
  831.        * Closed-loop fractional pitch search
  832.        */
  834.       /* find closed loop fractional pitch  lag */
  836.       if (*mode <= MODE_9k)
  837.       {
  838.          T0 = E_GAIN_closed_loop_search(&f_exc[i_subfr], xn, h1,
  839.             T0_min, T0_max, &T0_frac,
  840.             pit_flag, PIT_MIN, PIT_FR1_8b);
  842.          /* encode pitch lag */
  844.          if (pit_flag == 0)   /* if 1st/3rd subframe */
  845.          {
  847.             /*
  848.              * The pitch range for the 1st/3rd subframe is encoded with
  849.              * 8 bits and is divided as follows:
  850.              *   PIT_MIN to PIT_FR1-1  resolution 1/2 (frac = 0 or 2)
  851.              *   PIT_FR1 to PIT_MAX    resolution 1   (frac = 0)
  852.              */
  853.             if (T0 < PIT_FR1_8b)
  854.             {
  855.                index = (Word16)(T0 * 2 + (T0_frac >> 1) - (PIT_MIN * 2));
  856.             }
  857.             else
  858.             {
  859.                index = (Word16)(T0 - PIT_FR1_8b + ((PIT_FR1_8b - PIT_MIN) * 2));
  860.             }
  862.             E_MAIN_parm_store(index, &prms);
  864.             /* find T0_min and T0_max for subframe 2 and 4 */
  866.             T0_min = T0 - 8;
  868.             if (T0_min < PIT_MIN)
  869.             {
  870.                T0_min = PIT_MIN;
  871.             }
  873.             T0_max = T0_min + 15;
  875.             if (T0_max > PIT_MAX)
  876.             {
  877.                T0_max = PIT_MAX;
  878.                T0_min = T0_max - 15;
  879.             }
  880.          }
  881.          else  /* if subframe 2 or 4 */
  882.          {
  883.             /*
  884.              * The pitch range for subframe 2 or 4 is encoded with 6 bits:
  885.              *   T0_min  to T0_max     resolution 1/2 (frac = 0 or 2)
  886.              */
  887.             i = T0 - T0_min;
  888.             index = (Word16)(i * 2 + (T0_frac >> 1));
  890.             E_MAIN_parm_store(index, &prms);
  891.          }
  892.       }
  893.       else
  894.       {
  895.          T0 = E_GAIN_closed_loop_search(&f_exc[i_subfr], xn, h1,
  896.             T0_min, T0_max, &T0_frac,
  897.             pit_flag, PIT_FR2, PIT_FR1_9b);
  899.          /* encode pitch lag */
  901.          if (pit_flag == 0)   /* if 1st/3rd subframe */
  902.          {
  903.             /*
  904.              * The pitch range for the 1st/3rd subframe is encoded with
  905.              * 9 bits and is divided as follows:
  906.              *   PIT_MIN to PIT_FR2-1  resolution 1/4 (frac = 0,1,2 or 3)
  907.              *   PIT_FR2 to PIT_FR1-1  resolution 1/2 (frac = 0 or 2)
  908.              *   PIT_FR1 to PIT_MAX    resolution 1   (frac = 0)
  909.              */
  910.             if (T0 < PIT_FR2)
  911.             {
  912.                index = (Word16)(T0 * 4 + T0_frac - (PIT_MIN * 4));
  913.             }
  914.             else if (T0 < PIT_FR1_9b)
  915.             {
  916.                index = (Word16)(T0 * 2 + (T0_frac >> 1) - (PIT_FR2 * 2) + ((PIT_FR2 - PIT_MIN) * 4));
  917.             }
  918.             else
  919.             {
  920.                index = (Word16)(T0 - PIT_FR1_9b + ((PIT_FR2 - PIT_MIN) * 4) + ((PIT_FR1_9b - PIT_FR2) * 2));
  921.             }
  923.             E_MAIN_parm_store(index, &prms);
  925.             /* find T0_min and T0_max for subframe 2 and 4 */
  927.             T0_min = T0 - 8;
  929.             if (T0_min < PIT_MIN)
  930.             {
  931.                T0_min = PIT_MIN;
  932.             }
  934.             T0_max = T0_min + 15;
  936.             if (T0_max > PIT_MAX)
  937.             {
  938.                T0_max = PIT_MAX;
  939.                T0_min = T0_max - 15;
  940.             }
  941.          }
  942.          else      /* if subframe 2 or 4 */
  943.          {
  944.             /*
  945.              * The pitch range for subframe 2 or 4 is encoded with 6 bits:
  946.              *   T0_min  to T0_max     resolution 1/4 (frac = 0,1,2 or 3)
  947.              */
  948.             i = T0 - T0_min;
  949.             index = (Word16)(i * 4 + T0_frac);
  951.             E_MAIN_parm_store(index, &prms);
  952.          }
  953.       }
  955.       /*
  956.        * Gain clipping test to avoid unstable synthesis on frame erasure
  957.        */
  959.       clip_gain = E_GAIN_clip_test(st->mem_gp_clip);
  961.       /*
  962.        * - find unity gain pitch excitation (adaptive codebook entry)
  963.        *   with fractional interpolation.
  964.        * - find filtered pitch exc. y1[]=exc[] convolved with h1[])
  965.        * - compute pitch gain1
  966.        */
  968.       /* find pitch exitation */
  969.       E_GAIN_adaptive_codebook_excitation(&exc[i_subfr], (Word16)T0, T0_frac, L_SUBFR + 1);
  971.       if(*mode > MODE_9k)
  972.       {
  974.          E_UTIL_convolve(&exc[i_subfr], st->mem_q, h1, y1);
  976.          gain1 = E_ACELP_xy1_corr(xn, y1, g_coeff);
  978.          /* clip gain if necessary to avoid problem at decoder */
  979.         if (clip_gain && (gain1 > 0.95))
  980.         {
  981.            gain1 = 0.95f;
  982.         }
  984.          /* find energy of new target xn2[] */
  985.          E_ACELP_codebook_target_update(xn, dn, y1, gain1);
  986.       }
  987.       else
  988.       {
  989.          gain1 = 0.0F;
  990.       }
  992.       /*
  993.        * - find pitch excitation filtered by 1st order LP filter.
  994.        * - find filtered pitch exc. y2[]=exc[] convolved with h1[])
  995.        * - compute pitch gain2
  996.        */
  998.       /* find pitch excitation with lp filter */
  999.       for (i = 0; i < L_SUBFR; i++)
  1000.       {
  1001.          l_tmp = 5898 * exc[i - 1 + i_subfr];
  1002.          l_tmp += 20972 * exc[i + i_subfr];
  1003.          l_tmp += 5898 * exc[i + 1 + i_subfr];
  1004.          s_code[i] = (Word16)((l_tmp + 0x4000) >> 15);
  1005.       }
  1007.       E_UTIL_convolve(s_code, st->mem_q, h1, y2);
  1009.       gain2 = E_ACELP_xy1_corr(xn, y2, g_coeff2);
  1011.       /* clip gain if necessary to avoid problem at decoder */
  1012.       if (clip_gain && (gain2 > 0.95))
  1013.       {
  1014.          gain2 = 0.95F;
  1015.       }
  1017.       /* find energy of new target xn2[] */
  1018.       E_ACELP_codebook_target_update(xn, xn2, y2, gain2);
  1020.       /*
  1021.        * use the best prediction (minimise quadratic error).
  1022.        */
  1024.       select = 0;
  1026.       if (*mode > MODE_9k)
  1027.       {
  1028.          f_tmp = 0.0;
  1029.          for (i = 0; i < L_SUBFR; i++)
  1030.          {
  1031.             f_tmp += dn[i] * dn[i];
  1032.             f_tmp -= xn2[i] * xn2[i];
  1033.          }
  1035.          if (f_tmp < 0.1)
  1036.          {
  1037.             select = 1;
  1038.          }
  1040.          E_MAIN_parm_store(select, &prms);
  1041.       }
  1043.       if (select == 0)
  1044.       {
  1045.          /* use the lp filter for pitch excitation prediction */
  1046.          memcpy(&exc[i_subfr], s_code, L_SUBFR * sizeof(Word16));
  1047.          memcpy(y1, y2, L_SUBFR * sizeof(Float32));
  1048.          gain_pit = gain2;
  1049.          g_coeff[0] = g_coeff2[0];
  1050.          g_coeff[1] = g_coeff2[1];
  1051.       }
  1052.       else
  1053.       {
  1054.          /* no filter used for pitch excitation prediction */
  1055.          gain_pit = gain1;
  1056.          memcpy(xn2, dn, L_SUBFR * sizeof(Float32));        /* target vector for codebook search */
  1057.       }
  1060.       /*
  1061.        * - update target vector for codebook search
  1062.        * - scaling of cn[] to limit dynamic at 12 bits
  1063.        */
  1064.       for (i = 0; i < L_SUBFR; i ++)
  1065.       {
  1066.          cn[i] = (Float32)(cn[i] - gain_pit * exc[i_subfr + i] * pow(2, Q_new));
  1067.       }
  1069.       /*
  1070.        * - include fixed-gain pitch contribution into impulse resp. h1[]
  1071.        */
  1072.       f_tmp = 0.0F;
  1073.       E_UTIL_f_preemph(h1, (Float32)(st->mem_tilt_code / 32768.0), L_SUBFR, &f_tmp);
  1075.       if (T0_frac > 2)
  1076.       {
  1077.          T0++;
  1078.       }
  1080.       E_GAIN_f_pitch_sharpening(h1, T0);
  1082.       /*
  1083.        * - Correlation between target xn2[] and impulse response h1[]
  1084.        * - Innovative codebook search
  1085.        */
  1086.       E_ACELP_xh_corr(xn2, dn, h1);
  1088.       switch(*mode)
  1089.       {
  1090.       case MODE_7k:
  1091.          E_ACELP_2t(dn, cn, h1, s_code, y2, indice);
  1092.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1093.          break;
  1094.       case MODE_9k:
  1095.          E_ACELP_4t(dn, cn, h1, s_code, y2, 20, *mode, indice);
  1096.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1097.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1098.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1099.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1101.          break;
  1102.       case MODE_12k:
  1103.          E_ACELP_4t(dn, cn, h1, s_code, y2, 36, *mode, indice);
  1104.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1105.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1106.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1107.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1109.          break;
  1110.       case MODE_14k:
  1111.          E_ACELP_4t(dn, cn, h1, s_code, y2, 44, *mode, indice);
  1112.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1113.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1114.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1115.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1117.          break;
  1118.       case MODE_16k:
  1119.          E_ACELP_4t(dn, cn, h1, s_code, y2, 52, *mode, indice);
  1120.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1121.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1122.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1123.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1125.          break;
  1126.       case MODE_18k:
  1127.          E_ACELP_4t(dn, cn, h1, s_code, y2, 64, *mode, indice);
  1128.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1129.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1130.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1131.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1132.          E_MAIN_parm_store((Word16)indice[4], &prms);
  1133.          E_MAIN_parm_store((Word16)indice[5], &prms);
  1134.          E_MAIN_parm_store((Word16)indice[6], &prms);
  1135.          E_MAIN_parm_store((Word16)indice[7], &prms);
  1137.          break;
  1138.       case MODE_20k:
  1139.          E_ACELP_4t(dn, cn, h1, s_code, y2, 72, *mode, indice);
  1140.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1141.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1142.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1143.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1144.          E_MAIN_parm_store((Word16)indice[4], &prms);
  1145.          E_MAIN_parm_store((Word16)indice[5], &prms);
  1146.          E_MAIN_parm_store((Word16)indice[6], &prms);
  1147.          E_MAIN_parm_store((Word16)indice[7], &prms);
  1149.          break;
  1150.       case MODE_23k:
  1151.       case MODE_24k:
  1152.          E_ACELP_4t(dn, cn, h1, s_code, y2, 88, *mode, indice);
  1153.          E_MAIN_parm_store((Word16)indice[0], &prms);
  1154.          E_MAIN_parm_store((Word16)indice[1], &prms);
  1155.          E_MAIN_parm_store((Word16)indice[2], &prms);
  1156.          E_MAIN_parm_store((Word16)indice[3], &prms);
  1157.          E_MAIN_parm_store((Word16)indice[4], &prms);
  1158.          E_MAIN_parm_store((Word16)indice[5], &prms);
  1159.          E_MAIN_parm_store((Word16)indice[6], &prms);
  1160.          E_MAIN_parm_store((Word16)indice[7], &prms);
  1161.          break;
  1162.       default:
  1163.          return -1;
  1164.       }
  1166.       /*
  1167.        * - Add the fixed-gain pitch contribution to code[].
  1168.        */
  1169.       s_tmp = 0;
  1170.       E_UTIL_preemph(s_code, st->mem_tilt_code, L_SUBFR, &s_tmp);
  1172.       E_GAIN_pitch_sharpening(s_code, (Word16)T0);
  1174.       E_ACELP_xy2_corr(xn, y1, y2, g_coeff);
  1176.       /*
  1177.        *  - Compute the fixed codebook gain
  1178.        *  - quantize fixed codebook gain
  1179.        */
  1180.       if (*mode <= MODE_9k)
  1181.       {
  1182.           index = (Word16)E_ACELP_gains_quantise(s_code, 6, gain_pit,
  1183.              &s_gain_pit, &L_gain_code, g_coeff, clip_gain, st->mem_gain_q);
  1185.          E_MAIN_parm_store(index, &prms);
  1186.       }
  1187.       else
  1188.       {
  1189.          index = (Word16)E_ACELP_gains_quantise(s_code, 7, gain_pit,
  1190.             &s_gain_pit, &L_gain_code, g_coeff, clip_gain, st->mem_gain_q);
  1191.          E_MAIN_parm_store(index, &prms);
  1192.       }
  1194.       /* find best scaling to perform on excitation (Q_new) */
  1195.       s_tmp = st->mem_subfr_q[0];
  1196.       for (i = 1; i < 4; i++)
  1197.       {
  1198.          if (st->mem_subfr_q[i] < s_tmp)
  1199.          {
  1200.             s_tmp = st->mem_subfr_q[i];
  1201.          }
  1202.       }
  1204.       /* limit scaling (Q_new) to Q_MAX */
  1205.       if (s_tmp > Q_MAX)
  1206.       {
  1207.          s_tmp = Q_MAX;
  1208.       }
  1210.       Q_new = 0;
  1211.       l_tmp = L_gain_code;                 /* L_gain_code in Q16 */
  1213.       while ((l_tmp < 0x08000000L) && (Q_new < s_tmp))
  1214.       {
  1215.          l_tmp = (l_tmp << 1);
  1216.          Q_new = Q_new + 1;
  1217.       }
  1219.       if (l_tmp < 0x7FFF7FFF)
  1220.       {
  1221.          /* scaled gain_code with Qnew */
  1222.          gain_code = (Word16)((l_tmp + 0x8000) >> 16);
  1223.       }
  1224.       else
  1225.       {
  1226.          gain_code = 32767;
  1227.       }
  1229.       if (Q_new > st->mem_q)
  1230.       {
  1231.          E_UTIL_signal_up_scale(exc + i_subfr - (PIT_MAX + L_INTERPOL),
  1232.             (Word16)(Q_new - st->mem_q));
  1233.       }
  1234.       else
  1235.       {
  1236.          E_UTIL_signal_down_scale(exc + i_subfr - (PIT_MAX + L_INTERPOL),
  1237.             PIT_MAX + L_INTERPOL + L_SUBFR, (Word16)(st->mem_q - Q_new));
  1238.       }
  1239.       st->mem_q = (Word16)Q_new;
  1241.       /* test quantized gain of pitch for pitch clipping algorithm */
  1242.       E_GAIN_clip_pit_test((Float32)(s_gain_pit * pow(2, -14)),
  1243.          st->mem_gp_clip);
  1245.       /*
  1246.        * Update parameters for the next subframe.
  1247.        * - tilt of code: 0.0 (unvoiced) to 0.5 (voiced)
  1248.        */
  1250.       /* find voice factor in Q15 (1=voiced, -1=unvoiced) */
  1251.       memcpy(exc2, &exc[i_subfr], L_SUBFR * sizeof(Word16));
  1253.       E_UTIL_signal_down_scale(exc2, L_SUBFR, 3);
  1255.       voice_fac = E_GAIN_voice_factor(exc2, -3, s_gain_pit, s_code, gain_code);
  1257.       /* tilt of code for next subframe: 0.5=voiced, 0=unvoiced */
  1258.       st->mem_tilt_code = (Word16)((voice_fac >> 2) + 8192);
  1260.       /*
  1261.        * - Update filter's memory "mem_w0" for finding the
  1262.        *   target vector in the next subframe.
  1263.        * - Find the total excitation
  1264.        * - Find synthesis speech to update mem_syn[].
  1265.        */
  1266.       memcpy(exc2, &exc[i_subfr], L_SUBFR * sizeof(Word16));
  1268.       st->mem_w0 = (Float32)((xn[L_SUBFR - 1] -
  1269.          ((s_gain_pit / 16384.0F) * y1[L_SUBFR - 1])) -
  1270.          (gain_code * pow(2, -st->mem_q) * y2[L_SUBFR - 1]));
  1272.       if (*mode == MODE_24k)
  1273.       {
  1274.          Q_new = -st->mem_q;
  1276.          for (i = 0; i < L_SUBFR; i++)
  1277.          {
  1278.             f_exc2[i_subfr + i] = (Float32)(exc[i_subfr + i] * pow(2, Q_new) * (s_gain_pit / 16384.0F));
  1279.          }
  1280.       }
  1282.       s_max = 1;
  1283.       for (i = 0; i < L_SUBFR; i++)
  1284.       {
  1285.          /* code in Q9, gain_pit in Q14 */
  1286.          l_tmp = gain_code * s_code[i];
  1287.          l_tmp = l_tmp << 5;
  1288.          l_tmp += exc[i + i_subfr] * s_gain_pit; /* gain_pit Q14 */
  1289.          l_tmp = (l_tmp + 0x2000) >> 14;
  1291.          if ((l_tmp > MIN_16) & (l_tmp < 32768))
  1292.          {
  1293.             exc[i + i_subfr] = (Word16)l_tmp;
  1294.             s_tmp = (Word16)abs(l_tmp);
  1296.             if (s_tmp > s_max)
  1297.             {
  1298.                s_max = s_tmp;
  1299.             }
  1300.          }
  1301.          else if (l_tmp > MAX_16)
  1302.          {
  1303.             exc[i + i_subfr] = MAX_16;
  1304.             s_max = MAX_16;
  1305.          }
  1306.          else
  1307.          {
  1308.             exc[i + i_subfr] = MIN_16;
  1309.             s_max = MAX_16;
  1310.          }
  1311.       }
  1313.       /* tmp = scaling possible according to max value of excitation */
  1314.       s_tmp = (Word16)((E_UTIL_norm_s(s_max) + st->mem_q) - 1);
  1316.       st->mem_subfr_q[3] = st->mem_subfr_q[2];
  1317.       st->mem_subfr_q[2] = st->mem_subfr_q[1];
  1318.       st->mem_subfr_q[1] = st->mem_subfr_q[0];
  1319.       st->mem_subfr_q[0] = s_tmp;
  1321.       Q_new = -st->mem_q;
  1323.       for (i = 0; i < L_SUBFR; i++)
  1324.       {
  1325.          f_exc[i + i_subfr] = (Float32)(exc[i + i_subfr] * pow(2, Q_new));
  1326.       }
  1328.       E_UTIL_synthesis(p_Aq, &f_exc[i_subfr], synth, L_SUBFR, st->mem_syn, 1);
  1330.       if(*mode >= MODE_24k)
  1331.       {
  1332.          /*
  1333.           * noise enhancer
  1334.           * --------------
  1335.           * - Enhance excitation on noise. (modify gain of code)
  1336.           *   If signal is noisy and LPC filter is stable, move gain
  1337.           *   of code 1.5 dB toward gain of code threshold.
  1338.           *   This decrease by 3 dB noise energy variation.
  1339.           */
  1341.          /* 1=unvoiced, 0=voiced */
  1342.          f_tmp = (Float32)(0.5 * (1.0 - (voice_fac / 32768.0)));
  1343.          fac = stab_fac * f_tmp;
  1344.          f_tmp = (Float32)(gain_code * pow(2, -st->mem_q));
  1346.          if(f_tmp < st->mem_gc_threshold)
  1347.          {
  1348.             f_tmp = (Float32)(f_tmp * 1.19);
  1350.             if(f_tmp > st->mem_gc_threshold)
  1351.             {
  1352.                f_tmp = st->mem_gc_threshold;
  1353.             }
  1354.          }
  1355.          else
  1356.          {
  1357.             f_tmp = (Float32)(f_tmp / 1.19);
  1359.             if(f_tmp < st->mem_gc_threshold)
  1360.             {
  1361.                f_tmp = st->mem_gc_threshold;
  1362.             }
  1363.          }
  1365.          st->mem_gc_threshold = f_tmp;
  1366.          f_tmp = (Float32)(((fac * f_tmp) + ((1.0 - fac) *
  1367.             (gain_code * pow(2, -st->mem_q)))) * 0.001953125F);
  1369.          for(i = 0; i < L_SUBFR; i++)
  1370.          {
  1371.             f_code[i] = (Float32)(s_code[i] * f_tmp);
  1372.          }
  1374.          /*
  1375.           * pitch enhancer
  1376.           * --------------
  1377.           * - Enhance excitation on voice. (HP filtering of code)
  1378.           *   On voiced signal, filtering of code by a smooth fir HP
  1379.           *   filter to decrease energy of code in low frequency.
  1380.           */
  1382.          /* 0.25=voiced, 0=unvoiced */
  1383.          f_tmp = (Float32)(0.125F * (1.0F + (voice_fac / 32768.0)));
  1385.          f_exc2[i_subfr] += f_code[0] - (f_tmp * f_code[1]);
  1387.          for(i = 1; i < L_SUBFR - 1; i++)
  1388.          {
  1389.             f_exc2[i + i_subfr] +=
  1390.                f_code[i] - (f_tmp * f_code[i - 1]) - (f_tmp * f_code[i + 1]);
  1391.          }
  1393.          f_exc2[i_subfr + L_SUBFR - 1] +=
  1394.             f_code[L_SUBFR - 1] - (f_tmp * f_code[L_SUBFR - 2]);
  1396.          corr_gain = (Word16)E_UTIL_enc_synthesis(p_Aq, &f_exc2[i_subfr],
  1397.             &f_speech16k[i_subfr * 5 /4], st);
  1399.          E_MAIN_parm_store(corr_gain, &prms);
  1400.       }
  1402.       p_A += (M + 1);
  1403.       p_Aq += (M + 1);
  1404.   }   /* end of subframe loop */
  1406.    /*
  1407.     * Update signal for next frame.
  1408.     * -> save past of speech[], wsp[] and exc[].
  1409.     */
  1411.    memmove(st->mem_speech, &st->mem_speech[L_FRAME], (L_TOTAL - L_FRAME) * sizeof(Float32));
  1412.    memmove(st->mem_wsp, &st->mem_wsp[L_FRAME / OPL_DECIM], (PIT_MAX / OPL_DECIM) * sizeof(Float32));
  1413.    memmove(st->mem_exc, &st->mem_exc[L_FRAME], (PIT_MAX + L_INTERPOL) * sizeof(Word16));
  1415.    return 0;
  1416. }