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

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

Symbian

开发平台：

Visual C++

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