enc_dtx.c
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:40k
源码类别:

Symbian

开发平台:

C/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 "typedef.h"
  10. #include "enc_lpc.h"
  11. #include "enc_util.h"
  12. #define DTX_HIST_SIZE_MIN_ONE       7
  13. #define DTX_HANG_CONST              7     /* yields eight frames of SP HANGOVER  */
  14. #define DTX_ELAPSED_FRAMES_THRESH   (24 + 7 -1)
  15. #define MED_THRESH                  2.25
  16. #define GAIN_THR                    1.406
  17. #define ORDER                       16    /* order of linear prediction filter   */
  18. #define RANDOM_INITSEED             21845 /* own random init value               */
  19. #define MRDTX                       10
  20. #define SIZE_BK_NOISE1  64
  21. #define SIZE_BK_NOISE2  64
  22. #define SIZE_BK_NOISE3  64
  23. #define SIZE_BK_NOISE4  32
  24. #define SIZE_BK_NOISE5  32
  25. #define FRAME_LEN 256   /* Length (samples) of the input frame */
  26. #define SCALE     128   /* (UNITY * UNITY) / 512               */
  27. #define TONE_THR 0.65f  /* Threshold for tone detection        */
  28. /* constants for speech level estimation */
  29. #define SP_EST_COUNT       80
  30. #define SP_ACTIVITY_COUNT  25
  31. #define ALPHA_SP_UP     (1.0f - 0.85f)
  32. #define ALPHA_SP_DOWN   (1.0f - 0.85f)
  33. #define NOM_LEVEL          2050.0F              /* about -26 dBov                */
  34. #define SPEECH_LEVEL_INIT  NOM_LEVEL
  35. #define MIN_SPEECH_LEVEL1  (NOM_LEVEL * 0.063F) /* NOM_LEVEL -24 dB              */
  36. #define MIN_SPEECH_LEVEL2  (NOM_LEVEL * 0.2F)   /* NOM_LEVEL -14 dB              */
  37. #define MIN_SPEECH_SNR     0.125F               /* 0 dB, lowest SNR estimation   */
  38. /* Constants for background spectrum update */
  39. #define ALPHA_UP1   (1.0f - 0.95f)  /* Normal update, upwards:   */
  40. #define ALPHA_DOWN1 (1.0f - 0.936f) /* Normal update, downwards  */
  41. #define ALPHA_UP2   (1.0f - 0.985f) /* Forced update, upwards    */
  42. #define ALPHA_DOWN2 (1.0f - 0.943f) /* Forced update, downwards  */
  43. #define ALPHA3      (1.0f - 0.95f)  /* Update downwards          */
  44. #define ALPHA4      (1.0f - 0.9f)   /* For stationary estimation */
  45. #define ALPHA5      (1.0f - 0.5f)   /* For stationary estimation */
  46. /* Constants for VAD threshold */
  47. #define THR_MIN   (1.6F * SCALE) /* Minimum threshold                            */
  48. #define THR_HIGH  (6.0F * SCALE) /* Highest threshold                            */
  49. #define THR_LOW   (1.7F * SCALE) /* Lowest threshold                             */
  50. #define NO_P1     31744.0F       /* ilog2(1), Noise level for highest threshold  */
  51. #define NO_P2     19786.0F       /* ilog2(0.1, Noise level for lowest threshold  */
  52. #define NO_SLOPE  ((Float32)(THR_LOW - THR_HIGH) / (Float32)(NO_P2 - NO_P1))
  53. #define SP_CH_MIN (-0.75F * SCALE)
  54. #define SP_CH_MAX (0.75F * SCALE)
  55. #define SP_P1     22527.0F       /* ilog2(NOM_LEVEL / 4)                         */
  56. #define SP_P2     17832.0F       /* ilog2(NOM_LEVEL * 4)                         */
  57. #define SP_SLOPE  ((Float32)(SP_CH_MAX - SP_CH_MIN) / (Float32)(SP_P2 - SP_P1))
  58. /* Constants for hangover length */
  59. #define HANG_HIGH 12          /* longest hangover                 */
  60. #define HANG_LOW  2           /* shortest hangover                */
  61. #define HANG_P1   THR_LOW     /* threshold for longest hangover   */
  62. #define HANG_P2   (4 * SCALE) /* threshold for Word16est hangover */
  63. #define HANG_SLOPE ((Float32)(HANG_LOW - HANG_HIGH) / (Float32)(HANG_P2 - HANG_P1))
  64. /* Constants for burst length */
  65. #define BURST_HIGH   8        /* longest burst length          */
  66. #define BURST_LOW    3        /* shortest burst length         */
  67. #define BURST_P1     THR_HIGH /* threshold for Word32est burst */
  68. #define BURST_P2     THR_LOW  /* threshold for Word16est burst */
  69. #define BURST_SLOPE  ((Float32)(BURST_LOW - BURST_HIGH) / (Float32)(BURST_P2 - BURST_P1))
  70. /* Parameters for background spectrum recovery function */
  71. #define STAT_COUNT      20    /* threshold of stationary detection counter         */
  72. #define STAT_THR_LEVEL  184   /* Threshold level for stationarity detection        */
  73. #define STAT_THR        1000  /* Threshold for stationarity detection              */
  74. /* Limits for background noise estimate */
  75. #define NOISE_MIN    40    /* minimum */
  76. #define NOISE_MAX    20000 /* maximum */
  77. #define NOISE_INIT   150   /* initial */
  78. /* Thresholds for signal power (now calculated on 2 frames) */
  79. #define VAD_POW_LOW        30000.0f   /* If input power is lower than this, VAD is set to 0  */
  80. #define POW_PITCH_TONE_THR 686080.0f  /* If input power is lower, pitch detection is ignored */
  81. /* Constants for the filter bank */
  82. #define COEFF3   0.407806f /* coefficient for the 3rd order filter     */
  83. #define COEFF5_1 0.670013f /* 1st coefficient the for 5th order filter */
  84. #define COEFF5_2 0.195007f /* 2nd coefficient the for 5th order filter */
  85. extern const Float32 E_ROM_en_adjust[];
  86. extern const Float32 E_ROM_mean_isf_noise[];
  87. extern const Float32 E_ROM_dico1_isf_noise[];
  88. extern const Float32 E_ROM_dico2_isf_noise[];
  89. extern const Float32 E_ROM_dico3_isf_noise[];
  90. extern const Float32 E_ROM_dico4_isf_noise[];
  91. extern const Float32 E_ROM_dico5_isf_noise[];
  92. extern const Float32 E_ROM_isf[];
  93. /*
  94.  * E_DTX_isf_history_aver
  95.  *
  96.  * Parameters:
  97.  *    isf_old         I/O: ISF vectors
  98.  *    indices           I: ISF indices
  99.  *    isf_aver          O: averaged ISFs
  100.  *
  101.  * Function:
  102.  *    Perform the ISF averaging
  103.  *
  104.  * Returns:
  105.  *    void
  106.  */
  107. static void E_DTX_isf_history_aver(Float32 isf_old[], Word16 indices[],
  108.                                    Float32 isf_aver[])
  109. {
  110.    Float32 isf_tmp[2 * M];
  111.    Float32 tmp;
  112.    Word32 i, j, k;
  113.    /*
  114.     * Memorize in isf_tmp[][] the ISF vectors to be replaced by
  115.     * the median ISF vector prior to the averaging
  116.     */
  117.    for (k = 0; k < 2; k++)
  118.    {
  119.       if (indices[k] != -1)
  120.       {
  121.          for (i = 0; i < M; i++)
  122.          {
  123.             isf_tmp[k * M + i] = isf_old[indices[k] * M + i];
  124.             isf_old[indices[k] * M + i] = isf_old[indices[2] * M + i];
  125.          }
  126.       }
  127.    }
  128.    /* Perform the ISF averaging */
  129.    for (j = 0; j < M; j++)
  130.    {
  131.       tmp = 0;
  132.       for (i = 0; i < DTX_HIST_SIZE; i++)
  133.       {
  134.          tmp += isf_old[i * M + j];
  135.       }
  136.       isf_aver[j] = tmp;
  137.    }
  138.    /* Retrieve from isf_tmp[][] the ISF vectors saved prior to averaging */
  139.    for (k = 0; k < 2; k++)
  140.    {
  141.       if (indices[k] != -1)
  142.       {
  143.          for (i = 0; i < M; i++)
  144.          {
  145.             isf_old[indices[k] * M + i] = isf_tmp[k * M + i];
  146.          }
  147.       }
  148.    }
  149.    return;
  150. }
  151. /*
  152.  * E_DTX_dithering_control
  153.  *
  154.  * Parameters:
  155.  *    st                I: state struct
  156.  *
  157.  * Function:
  158.  *    Analysis of the variation and stationarity
  159.  *    of the background noise.
  160.  *
  161.  * Returns:
  162.  *    Dithering decision
  163.  */
  164. static Word16 E_DTX_dithering_control(E_DTX_State * st)
  165. {
  166.    Float32 ISF_diff, gain_diff, mean, tmp;
  167.    Word32 i;
  168.    Word16 CN_dith;
  169.    /* determine how stationary the spectrum of background noise is */
  170.    ISF_diff = 0.0F;
  171.    for (i = 0; i < 8; i++)
  172.    {
  173.       ISF_diff += st->mem_distance_sum[i];
  174.    }
  175.    if (ISF_diff > 5147609.0f)
  176.    {
  177.       CN_dith = 1;
  178.    }
  179.    else
  180.    {
  181.       CN_dith = 0;
  182.    }
  183.    /* determine how stationary the energy of background noise is */
  184.    mean = 0.0f;
  185.    for (i = 0; i < DTX_HIST_SIZE; i++)
  186.    {
  187.       mean += st->mem_log_en[i] / (Float32)DTX_HIST_SIZE;
  188.    }
  189.    gain_diff = 0.0f;
  190.    for (i = 0; i < DTX_HIST_SIZE; i++)
  191.    {
  192.       tmp = (Float32)fabs(st->mem_log_en[i] - mean);
  193.       gain_diff += tmp;
  194.    }
  195.    if (gain_diff > GAIN_THR)
  196.    {
  197.       CN_dith = 1;
  198.    }
  199.    return CN_dith;
  200. }
  201. /*
  202.  * E_DTX_buffer
  203.  *
  204.  * Parameters:
  205.  *    st           I/O: state struct
  206.  *    isf_new        I: isf vector
  207.  *    enr            I: residual energy (for L_FRAME)
  208.  *    codec_mode     I: speech coder mode
  209.  *
  210.  * Function:
  211.  *    Handles the DTX buffer
  212.  *
  213.  * Returns:
  214.  *    void
  215.  */
  216. void E_DTX_buffer(E_DTX_State *st, Float32 isf_new[], Float32 enr,
  217.                   Word16 codec_mode)
  218. {
  219.    Float32 log_en;
  220.    /* update pointer to circular buffer */
  221.    st->mem_hist_ptr++;
  222.    if (st->mem_hist_ptr == DTX_HIST_SIZE)
  223.    {
  224.       st->mem_hist_ptr = 0;
  225.    }
  226.    /* copy isf vector into buffer */
  227.    memcpy(&st->mem_isf[st->mem_hist_ptr * M], isf_new, M * sizeof(Float32));
  228.    enr += 1e-10F;
  229.    log_en = (Float32)(log10(enr / ((Float64)L_FRAME)) / log10(2.0F));
  230.    /* Subtract ~ 3 dB */
  231.    st->mem_log_en[st->mem_hist_ptr] = log_en + E_ROM_en_adjust[codec_mode];
  232.    return;
  233. }
  234. /*
  235.  * E_DTX_frame_indices_find
  236.  *
  237.  * Parameters:
  238.  *    st           I/O: state struct
  239.  *    isf_old_tx     I: isf vector
  240.  *    indices        I: distance indices
  241.  *
  242.  * Function:
  243.  *    Find indices for min/max distances
  244.  *
  245.  * Returns:
  246.  *    void
  247.  */
  248. static void E_DTX_frame_indices_find(E_DTX_State * st, Word16 indices[])
  249. {
  250.    Float32 L_tmp, tmp, summin, summax, summax2nd;
  251.    Word32 i, j, k;
  252.    Word16 ptr;
  253.    /*
  254.     * Remove the effect of the oldest frame from the column
  255.     * sum sumD[0..E_DTX_HIST_SIZE-1]. sumD[E_DTX_HIST_SIZE] is
  256.     * not updated since it will be removed later.
  257.     */
  258.    k = DTX_HIST_SIZE_MIN_ONE;
  259.    j = -1;
  260.    for (i = 0; i < DTX_HIST_SIZE_MIN_ONE; i++)
  261.    {
  262.       j = j + k;
  263.       st->mem_distance_sum[i] = st->mem_distance_sum[i] - st->mem_distance[j];
  264.       k--;
  265.    }
  266.    /*
  267.     * Shift the column sum sumD. The element sumD[E_DTX_HIST_SIZE-1]
  268.     * corresponding to the oldest frame is removed. The sum of
  269.     * the distances between the latest isf and other isfs,
  270.     * i.e. the element sumD[0], will be computed during this call.
  271.     * Hence this element is initialized to zero.
  272.     */
  273.    for (i = DTX_HIST_SIZE_MIN_ONE; i > 0; i--)
  274.    {
  275.       st->mem_distance_sum[i] = st->mem_distance_sum[i - 1];
  276.    }
  277.    st->mem_distance_sum[0] = 0.0F;
  278.    /*
  279.     * Remove the oldest frame from the distance matrix.
  280.     * Note that the distance matrix is replaced by a one-
  281.     * dimensional array to save static memory.
  282.     */
  283.    k = 0;
  284.    for (i = 27; i >= 12; i = i - k)
  285.    {
  286.       k++;
  287.       for (j = k; j > 0; j--)
  288.       {
  289.          st->mem_distance[i - j + 1] = st->mem_distance[i - j - k];
  290.       }
  291.    }
  292.    /*
  293.     * Compute the first column of the distance matrix D
  294.     * (squared Euclidean distances from isf1[] to isf_old_tx[][]).
  295.     */
  296.    ptr = st->mem_hist_ptr;
  297.    for (i = 1; i < DTX_HIST_SIZE; i++)
  298.    {
  299.       /* Compute the distance between the latest isf and the other isfs. */
  300.       ptr--;
  301.       if (ptr < 0)
  302.       {
  303.          ptr = DTX_HIST_SIZE_MIN_ONE;
  304.       }
  305.       L_tmp = 0;
  306.       for (j = 0; j < M; j++)
  307.       {
  308.          tmp = st->mem_isf[st->mem_hist_ptr * M + j] - st->mem_isf[ptr * M + j];
  309.          L_tmp += tmp * tmp;
  310.       }
  311.       st->mem_distance[i - 1] = L_tmp;
  312.       /* Update also the column sums. */
  313.       st->mem_distance_sum[0] += st->mem_distance[i - 1];
  314.       st->mem_distance_sum[i] += st->mem_distance[i - 1];
  315.    }
  316.    /* Find the minimum and maximum distances */
  317.    summax = st->mem_distance_sum[0];
  318.    summin = st->mem_distance_sum[0];
  319.    indices[0] = 0;
  320.    indices[2] = 0;
  321.    for (i = 1; i < DTX_HIST_SIZE; i++)
  322.    {
  323.       if (st->mem_distance_sum[i] > summax)
  324.       {
  325.          indices[0] = (Word16)i;
  326.          summax = st->mem_distance_sum[i];
  327.       }
  328.       if (st->mem_distance_sum[i] < summin)
  329.       {
  330.          indices[2] = (Word16)i;
  331.          summin = st->mem_distance_sum[i];
  332.       }
  333.    }
  334.    /* Find the second largest distance */
  335.    summax2nd = -100000000.0;
  336.    indices[1] = -1;
  337.    for (i = 0; i < DTX_HIST_SIZE; i++)
  338.    {
  339.       if ((st->mem_distance_sum[i] > summax2nd) && (i != indices[0]))
  340.       {
  341.          indices[1] = (Word16)i;
  342.          summax2nd = st->mem_distance_sum[i];
  343.       }
  344.    }
  345.    for (i = 0; i < 3; i++)
  346.    {
  347.       indices[i] = (Word16)(st->mem_hist_ptr - indices[i]);
  348.       if (indices[i] < 0)
  349.       {
  350.          indices[i] += DTX_HIST_SIZE;
  351.       }
  352.    }
  353.    /*
  354.     * If maximum distance / MED_THRESH is smaller than minimum distance
  355.     * then the median ISF vector replacement is not performed
  356.     */
  357.    L_tmp = (Float32)(summax / MED_THRESH);
  358.    if (L_tmp <= summin)
  359.    {
  360.       indices[0] = -1;
  361.    }
  362.    /*
  363.     * If second largest distance/MED_THRESH is smaller than
  364.     * minimum distance then the median ISF vector replacement is
  365.     * not performed
  366.     */
  367.    L_tmp = (Float32)(summax2nd / MED_THRESH);
  368.    if (L_tmp <= summin)
  369.    {
  370.       indices[1] = -1;
  371.    }
  372.    return;
  373. }
  374. /*
  375.  * E_DTX_isf_q
  376.  *
  377.  * Parameters:
  378.  *    isf            I: ISF in the frequency domain (0..6400)
  379.  *    isf_q          O: quantised ISF
  380.  *    indice         O: quantisation indices
  381.  *
  382.  * Function:
  383.  *    The ISF vector is quantized using VQ with split-by-5
  384.  *
  385.  * Returns:
  386.  *    void
  387.  */
  388. static void E_DTX_isf_q(Float32 *isf, Word16 **indice)
  389. {
  390.    Word32 i;
  391.    Float32 tmp;
  392.    for (i = 0; i < ORDER; i++)
  393.    {
  394.       isf[i] = isf[i] - E_ROM_mean_isf_noise[i];
  395.    }
  396.    (*indice)[0] = E_LPC_isf_sub_vq(&isf[0], E_ROM_dico1_isf_noise, 2,
  397.       SIZE_BK_NOISE1, &tmp);
  398.    (*indice)[1] = E_LPC_isf_sub_vq(&isf[2], E_ROM_dico2_isf_noise, 3,
  399.       SIZE_BK_NOISE2, &tmp);
  400.    (*indice)[2] = E_LPC_isf_sub_vq(&isf[5], E_ROM_dico3_isf_noise, 3,
  401.       SIZE_BK_NOISE3, &tmp);
  402.    (*indice)[3] = E_LPC_isf_sub_vq(&isf[8], E_ROM_dico4_isf_noise, 4,
  403.       SIZE_BK_NOISE4, &tmp);
  404.    (*indice)[4] = E_LPC_isf_sub_vq(&isf[12], E_ROM_dico5_isf_noise, 4,
  405.       SIZE_BK_NOISE5, &tmp);
  406.    return;
  407. }
  408. /*
  409.  * E_DTX_exe
  410.  *
  411.  * Parameters:
  412.  *    st           I/O: state struct
  413.  *    exc2           O: CN excitation
  414.  *    pt_prms        O: analysis parameters
  415.  *
  416.  * Function:
  417.  *    Confort noise parameters are encoded for the SID frame
  418.  *
  419.  * Returns:
  420.  *    void
  421.  */
  422. void E_DTX_exe(E_DTX_State *st, Float32 *exc2, Word16 **pt_prms)
  423. {
  424.    Float32 isf[M];
  425.    Float32 log_en, level, gain, ener;
  426.    Word32 i,j;
  427.    Word16 isf_order[3];
  428.    Word16 CN_dith;
  429.    /* VOX mode computation of SID parameters */
  430.    log_en = 0.0F;
  431.    memset(isf, 0, M * sizeof(Float32));
  432.    /* average energy and isf */
  433.    for (i = 0; i < DTX_HIST_SIZE; i++)
  434.    {
  435.       log_en += st->mem_log_en[i] / (Float32)DTX_HIST_SIZE;
  436.    }
  437.    E_DTX_frame_indices_find(st, isf_order);
  438.    E_DTX_isf_history_aver(st->mem_isf, isf_order, isf);
  439.    for (j = 0; j < M; j++)
  440.    {
  441.       isf[j] = isf[j] / (Float32)DTX_HIST_SIZE;   /* divide by 8 */
  442.    }
  443.    /*  quantize logarithmic energy to 6 bits (-6 : 66 dB) */
  444.    st->mem_log_en_index = (Word16)((log_en + 2.0F) * 2.625F);
  445.    if(st->mem_log_en_index > 63)
  446.    {
  447.       st->mem_log_en_index = 63;
  448.    }
  449.    if(st->mem_log_en_index < 0)
  450.    {
  451.       st->mem_log_en_index = 0;
  452.    }
  453.    E_DTX_isf_q(isf, pt_prms);
  454.    (*pt_prms) += 5;
  455.    **pt_prms = st->mem_log_en_index;
  456.    (*pt_prms) += 1;
  457.    CN_dith = E_DTX_dithering_control(st);
  458.    **pt_prms = CN_dith;
  459.    (*pt_prms) += 1;
  460.    /* adjust level to speech coder mode */
  461.    log_en = (Float32)((Float32)st->mem_log_en_index / 2.625 - 2.0);
  462.    level = (Float32)(pow( 2.0, log_en ));
  463.    /* generate white noise vector */
  464.    for (i = 0; i < L_FRAME; i++)
  465.    {
  466.       exc2[i] = (Float32)E_UTIL_random(&(st->mem_cng_seed));
  467.    }
  468.    ener = 0.01F;
  469.    for (i = 0; i < L_FRAME; i++)
  470.    {
  471.       ener += exc2[i] * exc2[i];
  472.    }
  473.    gain = (Float32)sqrt(level * L_FRAME / ener);
  474.    for (i = 0; i < L_FRAME; i++)
  475.    {
  476.       exc2[i] *= gain;
  477.    }
  478.    return;
  479. }
  480. /*
  481.  * E_DTX_reset
  482.  *
  483.  * Parameters:
  484.  *    st             O: state struct
  485.  *
  486.  * Function:
  487.  *    Initializes state memory
  488.  *
  489.  * Returns:
  490.  *    non-zero with error, zero for ok
  491.  */
  492. Word32 E_DTX_reset(E_DTX_State *st)
  493. {
  494.    Word32 i;
  495.    if (st == (E_DTX_State *) NULL)
  496.    {
  497.       return -1;
  498.    }
  499.    st->mem_hist_ptr = 0;
  500.    st->mem_log_en_index = 0;
  501.    /* Init isf_hist[] */
  502.    for(i = 0; i < DTX_HIST_SIZE; i++)
  503.    {
  504.       memcpy(&st->mem_isf[i * M], E_ROM_isf, M * sizeof(Float32));
  505.    }
  506.    st->mem_cng_seed = RANDOM_INITSEED;
  507.    /* Reset energy history */
  508.    memset(st->mem_log_en, 0, DTX_HIST_SIZE * sizeof(Float32));
  509.    st->mem_dtx_hangover_count = DTX_HANG_CONST;
  510.    st->mem_dec_ana_elapsed_count = DTX_ELAPSED_FRAMES_THRESH;
  511.    memset(st->mem_distance, 0, 28 * sizeof(Float32));
  512.    memset(st->mem_distance_sum, 0, (DTX_HIST_SIZE - 1) * sizeof(Float32));
  513.    return 0;
  514. }
  515. /*
  516.  * E_DTX_init
  517.  *
  518.  * Parameters:
  519.  *    st           I/O: state struct
  520.  *
  521.  * Function:
  522.  *    Allocates state memory and initializes state memory
  523.  *
  524.  * Returns:
  525.  *    non-zero with error, zero for ok
  526.  */
  527. Word32 E_DTX_init (E_DTX_State **st)
  528. {
  529.    E_DTX_State* s;
  530.    if (st == (E_DTX_State **) NULL)
  531.    {
  532.       return -1;
  533.    }
  534.    *st = NULL;
  535.    /* allocate memory */
  536.    if ((s= (E_DTX_State *) malloc(sizeof(E_DTX_State))) == NULL)
  537.    {
  538.       return -1;
  539.    }
  540.    E_DTX_reset(s);
  541.    *st = s;
  542.    return 0;
  543. }
  544. /*
  545.  * E_DTX_exit
  546.  *
  547.  * Parameters:
  548.  *    state        I/0: State struct
  549.  *
  550.  * Function:
  551.  *    The memory used for state memory is freed
  552.  *
  553.  * Returns:
  554.  *    void
  555.  */
  556. void E_DTX_exit (E_DTX_State **st)
  557. {
  558.    if (st == NULL || *st == NULL)
  559.    {
  560.       return;
  561.    }
  562.    /* deallocate memory */
  563.    free(*st);
  564.    *st = NULL;
  565.    return;
  566. }
  567. /*
  568.  * E_DTX_tx_handler
  569.  *
  570.  * Parameters:
  571.  *    st           I/O: State struct
  572.  *    vad_flag       I: vad decision
  573.  *    usedMode     I/O: mode changed or not
  574.  *
  575.  * Function:
  576.  *    Adds extra speech hangover to analyze speech on the decoding side.
  577.  *
  578.  * Returns:
  579.  *    void
  580.  */
  581. void E_DTX_tx_handler(E_DTX_State *st, Word32 vad_flag, Word16 *usedMode)
  582. {
  583.    /* this state machine is in synch with the GSMEFR txDtx machine */
  584.    st->mem_dec_ana_elapsed_count++;
  585.    if (vad_flag != 0)
  586.    {
  587.       st->mem_dtx_hangover_count = DTX_HANG_CONST;
  588.    }
  589.    else
  590.    {  /* non-speech */
  591.       if (st->mem_dtx_hangover_count == 0)
  592.       {  /* out of decoder analysis hangover  */
  593.          st->mem_dec_ana_elapsed_count = 0;
  594.          *usedMode = MRDTX;
  595.       }
  596.       else
  597.       { /* in possible analysis hangover */
  598.          st->mem_dtx_hangover_count--;
  599.          /* decAnaElapsedCount + dtxHangoverCount < E_DTX_ELAPSED_FRAMES_THRESH */
  600.          if ((st->mem_dec_ana_elapsed_count + st->mem_dtx_hangover_count)
  601.             < DTX_ELAPSED_FRAMES_THRESH)
  602.          {
  603.             *usedMode = MRDTX;
  604.             /* if Word16 time since decoder update, do not add extra HO */
  605.          }
  606.          /*
  607.          else
  608.          override VAD and stay in
  609.          speech mode *usedMode
  610.          and add extra hangover
  611.          */
  612.       }
  613.    }
  614.    return;
  615. }
  616. /*
  617.  * E_DTX_filter5
  618.  *
  619.  * Parameters:
  620.  *    in0         I/O: input values / output low-pass part
  621.  *    in1         I/O: input values / output high-pass part
  622.  *    data        I/O: updated filter memory
  623.  *
  624.  * Function:
  625.  *    Fifth-order half-band lowpass/highpass filter pair with decimation.
  626.  *
  627.  * Returns:
  628.  *    void
  629.  */
  630. static void E_DTX_filter5(Float32 *in0, Float32 *in1,  Float32 data[])
  631. {
  632.    Float32 temp0, temp1, temp2;
  633.    temp0 = *in0 - COEFF5_1 * data[0];
  634.    temp1 = data[0] + COEFF5_1 * temp0;
  635.    data[0] = ((temp0 > 1e-10) | (temp0 < -1e-10)) ? temp0 : 0;
  636.    temp0 = *in1 - COEFF5_2 * data[1];
  637.    temp2 = data[1] + COEFF5_2 * temp0;
  638.    data[1] = ((temp0 > 1e-10) | (temp0 < -1e-10)) ? temp0 : 0;
  639.    *in0 = (temp1 + temp2) * 0.5F;
  640.    *in1 = (temp1 - temp2) * 0.5F;
  641. }
  642. /*
  643.  * E_DTX_filter3
  644.  *
  645.  * Parameters:
  646.  *    in0         I/O: input values / output low-pass part
  647.  *    in1         I/O: input values / output high-pass part
  648.  *    data        I/O: updated filter memory
  649.  *
  650.  * Function:
  651.  *    Third-order half-band lowpass/highpass filter pair with decimation.
  652.  *
  653.  * Returns:
  654.  *    void
  655.  */
  656. static void E_DTX_filter3(Float32 *in0, Float32 *in1, Float32 *data)
  657. {
  658.    Float32 temp1, temp2;
  659.    temp1 = *in1 - COEFF3 * *data;
  660.    temp2 = *data + COEFF3 * temp1;
  661.    *data = ((temp1 > 1e-10) | (temp1 < -1e-10)) ? temp1 : 0;
  662.    *in1 = (*in0 - temp2) * 0.5F;
  663.    *in0 = (*in0 + temp2) * 0.5F;
  664. }
  665. /*
  666.  * E_DTX_level_calculation
  667.  *
  668.  * Parameters:
  669.  *    data          I: signal buffer
  670.  *    sub_level   I/0: level calculated at the end of the previous frame /
  671.  *                     level of signal calculated from the last
  672.  *                     (count2 - count1) samples
  673.  *    count1        I: number of samples to be counted
  674.  *    count2        I: number of samples to be counted
  675.  *    ind_m         I: step size for the index of the data buffer
  676.  *    ind_a         I: starting index of the data buffer
  677.  *    scale         I: scaling for the level calculation
  678.  *
  679.  * Function:
  680.  *    Calculate signal level in a sub-band. Level is calculated
  681.  *    by summing absolute values of the input data.
  682.  *
  683.  *    Because speech coder has a lookahead, signal level calculated
  684.  *    over the lookahead (data[count1 - count2]) is stored (*sub_level)
  685.  *    and added to the level of the next frame. Additionally, group
  686.  *    delay and decimation of the filter bank is taken into the count
  687.  *    for the values of the counters (count1, count2).
  688.  *
  689.  * Returns:
  690.  *    signal level
  691.  */
  692. static Float32 E_DTX_level_calculation(Float32 data[], Float32 *sub_level,
  693.                                        Word16 count1, Word16 count2,
  694.                                        Word16 ind_m, Word16 ind_a,
  695.                                        Float32 scale)
  696. {
  697.   Float64 l_temp1, l_temp2;
  698.   Float32 level;
  699.   Word32 i;
  700.   l_temp1 = 0.0;
  701.   for (i = count1; i < count2; i++)
  702.   {
  703.      l_temp1 += fabs(data[ind_m * i + ind_a]);
  704.   }
  705.   l_temp1 *= 2.0;
  706.   l_temp2 = l_temp1 + *sub_level / scale;
  707.   *sub_level = (Float32)(l_temp1 * scale);
  708.   for (i = 0; i < count1; i++)
  709.   {
  710.      l_temp2 += 2.0f * fabs(data[ind_m * i + ind_a]);
  711.   }
  712.   level = (Float32)(l_temp2 * scale);
  713.   return level;
  714. }
  715. /*
  716.  * E_DTX_filter_bank
  717.  *
  718.  * Parameters:
  719.  *    st          I/0: State struct
  720.  *    in            I: input frame
  721.  *    level         I: signal levels at each band
  722.  *
  723.  * Function:
  724.  *    Divide input signal into bands and calculate level of
  725.  *    the signal in each band
  726.  *
  727.  * Returns:
  728.  *    void
  729.  */
  730. static void E_DTX_filter_bank(E_DTX_Vad_State *st, Float32 in[],
  731.                               Float32 level[])
  732. {
  733.    Float32 tmp_buf[FRAME_LEN];
  734.    Word32 i, j;
  735.    /* shift input 1 bit down for safe scaling */
  736.    for (i = 0; i < FRAME_LEN; i++)
  737.    {
  738.       tmp_buf[i] = in[i] * 0.5F;
  739.    }
  740.    /* run the filter bank */
  741.    for (i = 0; i < (FRAME_LEN >> 1); i++)
  742.    {
  743.       j = i << 1;
  744.       E_DTX_filter5(&tmp_buf[j], &tmp_buf[j + 1], st->mem_a_data5[0]);
  745.    }
  746.    for (i = 0; i < (FRAME_LEN >> 2); i++)
  747.    {
  748.       j = i << 2;
  749.       E_DTX_filter5(&tmp_buf[j], &tmp_buf[j + 2], st->mem_a_data5[1]);
  750.       E_DTX_filter5(&tmp_buf[j + 1], &tmp_buf[j + 3], st->mem_a_data5[2]);
  751.    }
  752.    for (i = 0; i < (FRAME_LEN >> 3); i++)
  753.    {
  754.       j = i << 3;
  755.       E_DTX_filter5(&tmp_buf[j], &tmp_buf[j + 4], st->mem_a_data5[3]);
  756.       E_DTX_filter5(&tmp_buf[j + 2], &tmp_buf[j + 6], st->mem_a_data5[4]);
  757.       E_DTX_filter3(&tmp_buf[j + 3], &tmp_buf[j + 7], &st->mem_a_data3[0]);
  758.    }
  759.    for (i = 0; i < (FRAME_LEN >> 4); i++)
  760.    {
  761.       j = i << 4;
  762.       E_DTX_filter3(&tmp_buf[j], &tmp_buf[j + 8], &st->mem_a_data3[1]);
  763.       E_DTX_filter3(&tmp_buf[j + 4], &tmp_buf[j + 12], &st->mem_a_data3[2]);
  764.       E_DTX_filter3(&tmp_buf[j + 6], &tmp_buf[j + 14], &st->mem_a_data3[3]);
  765.    }
  766.    for (i = 0; i < (FRAME_LEN >> 5); i++)
  767.    {
  768.       j = i << 5;
  769.       E_DTX_filter3(&tmp_buf[j + 0], &tmp_buf[j + 16], &st->mem_a_data3[4]);
  770.       E_DTX_filter3(&tmp_buf[j + 8], &tmp_buf[j + 24], &st->mem_a_data3[5]);
  771.    }
  772.    /* calculate levels in each frequency band */
  773.    /* 4800 - 6400 Hz*/
  774.    level[11] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[11],
  775.       (FRAME_LEN >> 2) - 48, FRAME_LEN >> 2, 4, 1, 0.25F);
  776.    /* 4000 - 4800 Hz*/
  777.    level[10] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[10],
  778.       (FRAME_LEN >> 3) - 24, FRAME_LEN >> 3, 8, 7, 0.5F);
  779.    /* 3200 - 4000 Hz*/
  780.    level[9] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[9],
  781.       (FRAME_LEN >> 3) - 24, FRAME_LEN >> 3, 8, 3, 0.5F);
  782.    /* 2400 - 3200 Hz*/
  783.    level[8] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[8],
  784.       (FRAME_LEN >> 3) - 24, FRAME_LEN >> 3, 8, 2, 0.5F);
  785.    /* 2000 - 2400 Hz*/
  786.    level[7] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[7],
  787.       (FRAME_LEN >> 4) - 12, FRAME_LEN >> 4, 16, 14, 1.0F);
  788.    /* 1600 - 2000 Hz*/
  789.    level[6] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[6],
  790.       (FRAME_LEN >> 4) - 12, FRAME_LEN >> 4, 16, 6, 1.0F);
  791.    /* 1200 - 1600 Hz*/
  792.    level[5] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[5],
  793.       (FRAME_LEN >> 4) - 12, FRAME_LEN >> 4, 16, 4, 1.0F);
  794.    /* 800 - 1200 Hz*/
  795.    level[4] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[4],
  796.       (FRAME_LEN >> 4) - 12, FRAME_LEN >> 4, 16, 12, 1.0F);
  797.    /* 600 - 800 Hz*/
  798.    level[3] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[3],
  799.       (FRAME_LEN >> 5) - 6, FRAME_LEN >> 5, 32, 8, 2.0F);
  800.    /* 400 - 600 Hz*/
  801.    level[2] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[2],
  802.       (FRAME_LEN >> 5) - 6, FRAME_LEN >> 5, 32, 24, 2.0F);
  803.    /* 200 - 400 Hz*/
  804.    level[1] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[1],
  805.       (FRAME_LEN >> 5) - 6, FRAME_LEN >> 5, 32, 16, 2.0F);
  806.    /* 0 - 200 Hz*/
  807.    level[0] = E_DTX_level_calculation(tmp_buf, &st->mem_sub_level[0],
  808.       (FRAME_LEN >> 5) - 6, FRAME_LEN >> 5, 32, 0, 2.0F);
  809. }
  810. /*
  811.  * E_DTX_update_cntrl
  812.  *
  813.  * Parameters:
  814.  *    st          I/0: State struct
  815.  *    level         I: sub-band levels of the input frame
  816.  *
  817.  * Function:
  818.  *    Control update of the background noise estimate.
  819.  *
  820.  * Returns:
  821.  *    void
  822.  */
  823. static void E_DTX_update_cntrl(E_DTX_Vad_State *st, Float32 level[])
  824. {
  825.    Float32 stat_rat;
  826.    Float32 num, denom;
  827.    Float32 alpha;
  828.    Word32 i;
  829.    /* if fullband pitch or tone have been detected for a while, initialize stat_count */
  830.    if ((st->mem_pitch_tone & 0x7c00) == 0x7c00)
  831.    {
  832.       st->mem_stat_count = STAT_COUNT;
  833.    }
  834.    else
  835.    {
  836.       /* if 8 last vad-decisions have been "0", reinitialize stat_count */
  837.       if ((st->mem_vadreg & 0x7f80) == 0)
  838.       {
  839.          st->mem_stat_count = STAT_COUNT;
  840.       }
  841.       else
  842.       {
  843.          stat_rat = 0;
  844.          for (i = 0; i < COMPLEN; i++)
  845.          {
  846.             if (level[i] > st->mem_ave_level[i])
  847.             {
  848.                num = level[i];
  849.                denom = st->mem_ave_level[i];
  850.             }
  851.             else
  852.             {
  853.                num = st->mem_ave_level[i];
  854.                denom = level[i];
  855.             }
  856.             /* Limit nimimum value of num and denom to STAT_THR_LEVEL */
  857.             if (num  < STAT_THR_LEVEL)
  858.             {
  859.                num = STAT_THR_LEVEL;
  860.             }
  861.             if (denom < STAT_THR_LEVEL)
  862.             {
  863.                denom = STAT_THR_LEVEL;
  864.             }
  865.             stat_rat += num/denom * 64;
  866.          }
  867.          /* compare stat_rat with a threshold and update stat_count */
  868.          if (stat_rat  > STAT_THR)
  869.          {
  870.             st->mem_stat_count = STAT_COUNT;
  871.          }
  872.          else
  873.          {
  874.             if ((st->mem_vadreg & 0x4000) != 0)
  875.             {
  876.                if (st->mem_stat_count != 0)
  877.                {
  878.                   st->mem_stat_count--;
  879.                }
  880.             }
  881.          }
  882.       }
  883.    }
  884.    /* Update average amplitude estimate for stationarity estimation */
  885.    alpha = ALPHA4;
  886.    if (st->mem_stat_count == STAT_COUNT)
  887.    {
  888.       alpha = 1.0;
  889.    }
  890.    else if ((st->mem_vadreg & 0x4000) == 0)
  891.    {
  892.       alpha = ALPHA5;
  893.    }
  894.    for (i = 0; i < COMPLEN; i++)
  895.    {
  896.       st->mem_ave_level[i] += alpha * (level[i] - st->mem_ave_level[i]);
  897.    }
  898. }
  899. /*
  900.  * E_DTX_hangover_addition
  901.  *
  902.  * Parameters:
  903.  *    st              I/0: State struct
  904.  *    low_power         I: flag power of the input frame
  905.  *    hang_len          I: hangover length
  906.  *    burst_len         I: minimum burst length for hangover addition
  907.  *
  908.  * Function:
  909.  *    Add hangover after speech bursts.
  910.  *
  911.  * Returns:
  912.  *    VAD_flag indicating final VAD decision
  913.  */
  914. static Word16 E_DTX_hangover_addition(E_DTX_Vad_State *st, Word16 low_power,
  915.                                       Word16 hang_len, Word16 burst_len)
  916. {
  917.    /*
  918.     * if the input power (pow_sum) is lower than a threshold, clear
  919.     * counters and set VAD_flag to "0"  "fast exit"
  920.     */
  921.    if (low_power != 0)
  922.    {
  923.       st->mem_burst_count = 0;
  924.       st->mem_hang_count = 0;
  925.       return 0;
  926.    }
  927.    /* update the counters (hang_count, burst_count) */
  928.    if ((st->mem_vadreg & 0x4000) != 0)
  929.    {
  930.       st->mem_burst_count++;
  931.       if (st->mem_burst_count >= burst_len)
  932.       {
  933.          st->mem_hang_count = hang_len;
  934.       }
  935.       return 1;
  936.    }
  937.    else
  938.    {
  939.       st->mem_burst_count = 0;
  940.       if (st->mem_hang_count > 0)
  941.       {
  942.          st->mem_hang_count--;
  943.          return 1;
  944.       }
  945.    }
  946.    return 0;
  947. }
  948. /*
  949.  * E_DTX_noise_estimate_update
  950.  *
  951.  * Parameters:
  952.  *    st           I/0: State struct
  953.  *    level          I: sub-band levels of the input frame
  954.  *
  955.  * Function:
  956.  *    Update of background noise estimate
  957.  *
  958.  * Returns:
  959.  *    void
  960.  */
  961. static void E_DTX_noise_estimate_update(E_DTX_Vad_State *st, Float32 level[])
  962. {
  963.    Float32 alpha_up, alpha_down, bckr_add, temp;
  964.    Word32 i;
  965.    /* Control update of bckr_est[] */
  966.    E_DTX_update_cntrl(st, level);
  967.    /* Choose update speed */
  968.    bckr_add = 2.0;
  969.    if ((0x7800 & st->mem_vadreg) == 0)
  970.    {
  971.       alpha_up = ALPHA_UP1;
  972.       alpha_down = ALPHA_DOWN1;
  973.    }
  974.    else
  975.    {
  976.       if (st->mem_stat_count == 0)
  977.       {
  978.          alpha_up = ALPHA_UP2;
  979.          alpha_down = ALPHA_DOWN2;
  980.       }
  981.       else
  982.       {
  983.          alpha_up = 0.0;
  984.          alpha_down = ALPHA3;
  985.          bckr_add = 0.0;
  986.       }
  987.    }
  988.    /* Update noise estimate (bckr_est) */
  989.    for (i = 0; i < COMPLEN; i++)
  990.    {
  991.       temp = st->mem_level[i] - st->mem_bckr_est[i];
  992.       if (temp < 0.0)
  993.       { /* update downwards*/
  994.          st->mem_bckr_est[i] += -2 + (alpha_down * temp);
  995.          /* limit minimum value of the noise estimate to NOISE_MIN */
  996.          if (st->mem_bckr_est[i] < NOISE_MIN)
  997.          {
  998.             st->mem_bckr_est[i] = NOISE_MIN;
  999.          }
  1000.       }
  1001.       else
  1002.       { /* update upwards */
  1003.          st->mem_bckr_est[i] += bckr_add + (alpha_up * temp);
  1004.          /* limit maximum value of the noise estimate to NOISE_MAX */
  1005.          if (st->mem_bckr_est[i] > NOISE_MAX)
  1006.          {
  1007.             st->mem_bckr_est[i] = NOISE_MAX;
  1008.          }
  1009.       }
  1010.    }
  1011.    /* Update signal levels of the previous frame (old_level) */
  1012.    memcpy(st->mem_level, level, COMPLEN * sizeof(Float32));
  1013. }
  1014. /*
  1015.  * E_DTX_decision
  1016.  *
  1017.  * Parameters:
  1018.  *    st           I/0: State struct
  1019.  *    level          I: sub-band levels of the input frame
  1020.  *    pow_sum        I: power of the input frame
  1021.  *
  1022.  * Function:
  1023.  *    Calculates VAD_flag
  1024.  *
  1025.  * Returns:
  1026.  *    VAD_flag
  1027.  */
  1028. static Word16 E_DTX_decision(E_DTX_Vad_State *st, Float32 level[COMPLEN], Float64 pow_sum)
  1029. {
  1030.    Float64 snr_sum;
  1031.    Float32 vad_thr, temp, noise_level;
  1032.    Float32 ilog2_speech_level, ilog2_noise_level;
  1033.    Float32 temp2;
  1034.    Word32 i;
  1035.    Word16 low_power_flag;
  1036.    Word16 hang_len,burst_len;
  1037.    /*
  1038.     * Calculate squared sum of the input levels (level)
  1039.     * divided by the background noise components (bckr_est).
  1040.     */
  1041.    snr_sum = 0.0;
  1042.    for (i = 0; i < COMPLEN; i++)
  1043.    {
  1044.       temp = level[i] / st->mem_bckr_est[i];
  1045.       snr_sum += temp * temp;
  1046.    }
  1047.    /* Calculate average level of estimated background noise */
  1048.    temp = 0.0;
  1049.    for (i = 1; i < COMPLEN; i++) /* ignore lowest band */
  1050.    {
  1051.       temp += st->mem_bckr_est[i];
  1052.    }
  1053.    noise_level = (Float32)(temp * 0.0625);
  1054.    /*
  1055.     * if SNR is lower than a threshold (MIN_SPEECH_SNR),
  1056.     * and increase speech_level
  1057.     */
  1058.    temp = noise_level * MIN_SPEECH_SNR * 8;
  1059.    if (st->mem_speech_level < temp)
  1060.    {
  1061.       st->mem_speech_level = temp;
  1062.    }
  1063.    ilog2_noise_level = (Float32)(-1024.0F * log10(noise_level / 2147483648.0F) / log10(2.0F));
  1064.    /*
  1065.     * If SNR is very poor, speech_level is probably corrupted by noise level. This
  1066.     * is correctred by subtracting -MIN_SPEECH_SNR*noise_level from speech level
  1067.     */
  1068.    ilog2_speech_level = (Float32)(-1024.0F * log10((st->mem_speech_level - temp) / 2147483648.0F) / log10(2.0F));
  1069.    /* ilog2_speech_level = ilog2(st->speech_level); */
  1070.    temp = NO_SLOPE * (ilog2_noise_level- NO_P1)+ THR_HIGH;
  1071.    temp2 = SP_CH_MIN + SP_SLOPE * (ilog2_speech_level - SP_P1);
  1072.    if (temp2 < SP_CH_MIN)
  1073.    {
  1074.       temp2 = SP_CH_MIN;
  1075.    }
  1076.    if (temp2 > SP_CH_MAX)
  1077.    {
  1078.       temp2 = SP_CH_MAX;
  1079.    }
  1080.    vad_thr = temp + temp2;
  1081.    if (vad_thr < THR_MIN)
  1082.    {
  1083.       vad_thr = THR_MIN;
  1084.    }
  1085.    /* Shift VAD decision register */
  1086.    st->mem_vadreg = (Word16)(st->mem_vadreg >> 1);
  1087.    /* Make intermediate VAD decision */
  1088.    if (snr_sum > (vad_thr * (Float32)COMPLEN / 128.0F))
  1089.    {
  1090.       st->mem_vadreg = (Word16)(st->mem_vadreg | 0x4000);
  1091.    }
  1092.    /* primary vad decsion made */
  1093.    /* check if the input power (pow_sum) is lower than a threshold" */
  1094.    if (pow_sum < VAD_POW_LOW)
  1095.    {
  1096.       low_power_flag = 1;
  1097.    }
  1098.    else
  1099.    {
  1100.       low_power_flag = 0;
  1101.    }
  1102.    /* Update speech subband background noise estimates */
  1103.    E_DTX_noise_estimate_update(st, level);
  1104.    hang_len = (Word16)((HANG_SLOPE * (vad_thr - HANG_P1) - 0.5) + HANG_HIGH);
  1105.    if (hang_len < HANG_LOW)
  1106.    {
  1107.       hang_len = HANG_LOW;
  1108.    }
  1109.    burst_len = (Word16)((BURST_SLOPE * (vad_thr - BURST_P1) - 0.5) + BURST_HIGH);
  1110.    return(E_DTX_hangover_addition(st, low_power_flag, hang_len,burst_len));
  1111. }
  1112. /*
  1113.  * E_DTX_dpeech_estimate
  1114.  *
  1115.  * Parameters:
  1116.  *    st           I/0: State struct
  1117.  *    in_level       I: level of the input frame
  1118.  *
  1119.  * Function:
  1120.  *    Estimate speech level
  1121.  *
  1122.  *    Maximum signal level is searched and stored to the variable sp_max.
  1123.  *    The speech frames must locate within SP_EST_COUNT number of frames to be counted.
  1124.  *    Thus, noisy frames having occasional VAD = "1" decisions will not
  1125.  *    affect to the estimated speech_level.
  1126.  *
  1127.  * Returns:
  1128.  *    void
  1129.  */
  1130. static void E_DTX_speech_estimate(E_DTX_Vad_State *st, Float32 in_level)
  1131. {
  1132.    Float32 alpha, tmp;
  1133.    /* if the required activity count cannot be achieved, reset counters */
  1134.    if (SP_ACTIVITY_COUNT  > (SP_EST_COUNT - st->mem_sp_est_cnt + st->mem_sp_max_cnt))
  1135.    {
  1136.       st->mem_sp_est_cnt = 0;
  1137.       st->mem_sp_max = 0.0;
  1138.       st->mem_sp_max_cnt = 0;
  1139.    }
  1140.    st->mem_sp_est_cnt++;
  1141.    if (((st->mem_vadreg & 0x4000) || (in_level > st->mem_speech_level))
  1142.       && (in_level > MIN_SPEECH_LEVEL1))
  1143.    {
  1144.       if (in_level > st->mem_sp_max)
  1145.       {
  1146.          st->mem_sp_max = in_level;
  1147.       }
  1148.       st->mem_sp_max_cnt++;
  1149.       if (st->mem_sp_max_cnt >= SP_ACTIVITY_COUNT)
  1150.       {
  1151.          tmp = st->mem_sp_max / 2.0F; /* scale to get "average" speech level*/
  1152.          if (tmp > st->mem_speech_level)
  1153.          {
  1154.             alpha = ALPHA_SP_UP;
  1155.          }
  1156.          else
  1157.          {
  1158.             alpha = ALPHA_SP_DOWN;
  1159.          }
  1160.          if (tmp > MIN_SPEECH_LEVEL2)
  1161.          {
  1162.             st->mem_speech_level += alpha * (tmp - st->mem_speech_level);
  1163.          }
  1164.          st->mem_sp_max = 0.0;
  1165.          st->mem_sp_max_cnt = 0;
  1166.          st->mem_sp_est_cnt = 0;
  1167.       }
  1168.    }
  1169. }
  1170. /*
  1171.  * E_DTX_vad_reset
  1172.  *
  1173.  * Parameters:
  1174.  *    state        I/0: State struct
  1175.  *
  1176.  * Function:
  1177.  *    Initialises state memory
  1178.  *
  1179.  * Returns:
  1180.  *    non-zero with error, zero for ok
  1181.  */
  1182. Word32 E_DTX_vad_reset (E_DTX_Vad_State *state)
  1183. {
  1184.    Word32 i;
  1185.    if (state == (E_DTX_Vad_State *) NULL)
  1186.    {
  1187.       return -1;
  1188.    }
  1189.    /* Initialize pitch detection variables */
  1190.    state->mem_pitch_tone = 0;
  1191.    state->mem_vadreg = 0;
  1192.    state->mem_hang_count = 0;
  1193.    state->mem_burst_count = 0;
  1194.    state->mem_hang_count = 0;
  1195.    /* initialize memory used by the filter bank */
  1196.    memset(state->mem_a_data5, 0, F_5TH_CNT * 2 * sizeof(Float32));
  1197.    memset(state->mem_a_data3, 0, F_3TH_CNT * sizeof(Float32));
  1198.    /* initialize the rest of the memory */
  1199.    for (i = 0; i < COMPLEN; i++)
  1200.    {
  1201.       state->mem_bckr_est[i] = NOISE_INIT;
  1202.       state->mem_level[i] = NOISE_INIT;
  1203.       state->mem_ave_level[i] = NOISE_INIT;
  1204.       state->mem_sub_level[i] = 0;
  1205.    }
  1206.    state->mem_sp_est_cnt = 0;
  1207.    state->mem_sp_max = 0;
  1208.    state->mem_sp_max_cnt = 0;
  1209.    state->mem_speech_level = SPEECH_LEVEL_INIT;
  1210.    state->mem_pow_sum = 0;
  1211.    state->mem_stat_count = 0;
  1212.    return 0;
  1213. }
  1214. /*
  1215.  * E_DTX_vad_init
  1216.  *
  1217.  * Parameters:
  1218.  *    state        I/0: State struct
  1219.  *
  1220.  * Function:
  1221.  *    Allocates state memory and initializes state memory
  1222.  *
  1223.  * Returns:
  1224.  *    non-zero with error, zero for ok
  1225.  */
  1226. Word32 E_DTX_vad_init (E_DTX_Vad_State **state)
  1227. {
  1228.    E_DTX_Vad_State* s;
  1229.    if (state == (E_DTX_Vad_State **) NULL)
  1230.    {
  1231.       return -1;
  1232.    }
  1233.    *state = NULL;
  1234.    /* allocate memory */
  1235.    if ((s = (E_DTX_Vad_State *) malloc(sizeof(E_DTX_Vad_State))) == NULL)
  1236.    {
  1237.       return -1;
  1238.    }
  1239.    E_DTX_vad_reset(s);
  1240.    *state = s;
  1241.    return 0;
  1242. }
  1243. /*
  1244.  * E_DTX_vad_exit
  1245.  *
  1246.  * Parameters:
  1247.  *    state        I/0: State struct
  1248.  *
  1249.  * Function:
  1250.  *    The memory used for state memory is freed
  1251.  *
  1252.  * Returns:
  1253.  *    void
  1254.  */
  1255. void E_DTX_vad_exit (E_DTX_Vad_State **state)
  1256. {
  1257.    if (state == NULL || *state == NULL)
  1258.    {
  1259.       return;
  1260.    }
  1261.    /* deallocate memory */
  1262.    free(*state);
  1263.    *state = NULL;
  1264.    return;
  1265. }
  1266. /*
  1267.  * E_DTX_pitch_tone_detection
  1268.  *
  1269.  * Parameters:
  1270.  *    state        I/0: State struct
  1271.  *    p_gain         I: pitch gain
  1272.  *
  1273.  * Function:
  1274.  *    Set tone flag if pitch gain is high. This is used to detect
  1275.  *    signaling tones and other signals with high pitch gain.
  1276.  *
  1277.  * Returns:
  1278.  *    void
  1279.  */
  1280. void E_DTX_pitch_tone_detection (E_DTX_Vad_State *st, Float32 p_gain)
  1281. {
  1282.    /* update tone flag and pitch flag */
  1283.    st->mem_pitch_tone = (Word16)(st->mem_pitch_tone >> 1);
  1284.    /* if (pitch_gain > TONE_THR) set tone flag */
  1285.    if (p_gain > TONE_THR)
  1286.    {
  1287.       st->mem_pitch_tone = (Word16)(st->mem_pitch_tone | 0x4000);
  1288.    }
  1289. }
  1290. /*
  1291.  * E_DTX_vad
  1292.  *
  1293.  * Parameters:
  1294.  *    st           I/0: State struct
  1295.  *    in_buf         I: samples of the input frame
  1296.  *
  1297.  * Function:
  1298.  *    Main program for Voice Activity Detection (VAD)
  1299.  *
  1300.  * Returns:
  1301.  *    VAD Decision, 1 = speech, 0 = noise
  1302.  */
  1303. Word16 E_DTX_vad(E_DTX_Vad_State *st, Float32 in_buf[])
  1304. {
  1305.    Float64 L_temp, pow_sum;
  1306.    Float32 level[COMPLEN];
  1307.    Float32 temp;
  1308.    Word32 i;
  1309.    Word16 VAD_flag;
  1310.    /* Calculate power of the input frame. */
  1311.    L_temp = 0.0;
  1312.    for (i = 0; i < FRAME_LEN; i++)
  1313.    {
  1314.       L_temp += in_buf[i] * in_buf[i];
  1315.    }
  1316.    L_temp *= 2.0;
  1317.    /* pow_sum = power of current frame and previous frame */
  1318.    pow_sum = L_temp + st->mem_pow_sum;
  1319.    /* save power of current frame for next call */
  1320.    st->mem_pow_sum = L_temp;
  1321.    /* If input power is very low, clear tone flag */
  1322.    if (pow_sum < POW_PITCH_TONE_THR)
  1323.    {
  1324.       st->mem_pitch_tone = (Word16)(st->mem_pitch_tone & 0x1fff);
  1325.    }
  1326.    /*  Run the filter bank and calculate signal levels at each band */
  1327.    E_DTX_filter_bank(st, in_buf, level);
  1328.    /* compute VAD decision */
  1329.    VAD_flag = E_DTX_decision(st, level, pow_sum);
  1330.    /* Calculate input level */
  1331.    L_temp = 0.0;
  1332.    for (i = 1; i < COMPLEN; i++) /* ignore lowest band */
  1333.    {
  1334.       L_temp += level[i];
  1335.    }
  1336.    temp = (Float32)(L_temp / 16.0F);
  1337.    E_DTX_speech_estimate(st, temp); /* Estimate speech level */
  1338.    return(VAD_flag);
  1339. }