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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
dec_lpc.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：20k
源码类别：

Symbian

开发平台：

C/C++

dec_lpc.c：源码内容
  1. /*
  2.  *===================================================================
  3.  *  3GPP AMR Wideband Floating-point Speech Codec
  4.  *===================================================================
  5.  */
  6. #include "typedef.h"
  7. #include "dec_util.h"
  9. #define M            16             /* Order of LP filter                  */
  10. #define MP1          (M + 1)
  11. #define M16k         20
  12. #define NC16k        (M16k / 2)
  13. #define MU           10923          /* Prediction factor (1.0/3.0) in Q15  */
  14. #define L_MEANBUF    3
  15. #define ALPHA        29491          /* 0. 9 in Q15                         */
  16. #define ONE_ALPHA    (32768-ALPHA)  /* (1.0 - ALPHA) in Q15                */
  17. #define ORDER        16             /* order of linear prediction filter   */
  18. #define ISF_GAP      128            /* 50 Hz */
  19. #define INV_LENGTH   2731           /* 1/12                                */
  21. extern const Word16 D_ROM_dico1_isf[];
  22. extern const Word16 D_ROM_dico2_isf[];
  23. extern const Word16 D_ROM_dico21_isf_36b[];
  24. extern const Word16 D_ROM_dico22_isf_36b[];
  25. extern const Word16 D_ROM_dico23_isf_36b[];
  26. extern const Word16 D_ROM_dico21_isf[];
  27. extern const Word16 D_ROM_dico22_isf[];
  28. extern const Word16 D_ROM_dico23_isf[];
  29. extern const Word16 D_ROM_dico24_isf[];
  30. extern const Word16 D_ROM_dico25_isf[];
  31. extern const Word16 D_ROM_dico1_isf_noise[];
  32. extern const Word16 D_ROM_dico2_isf_noise[];
  33. extern const Word16 D_ROM_dico3_isf_noise[];
  34. extern const Word16 D_ROM_dico4_isf_noise[];
  35. extern const Word16 D_ROM_dico5_isf_noise[];
  36. extern const Word16 D_ROM_mean_isf[];
  37. extern const Word16 D_ROM_mean_isf_noise[];
  38. extern const Word16 D_ROM_cos[];
  41. /*
  42.  * D_LPC_isf_reorder
  43.  *
  44.  * Parameters:
  45.  *    isf          I/O: vector of isfs
  46.  *    min_dist       I: quantized ISFs (in frequency domain)
  47.  *    n              I: LPC order
  48.  *
  49.  * Function:
  50.  *    To make sure that the  isfs are properly order and to keep a certain
  51.  *    minimum distance between consecutive isfs.
  52.  *
  53.  * Returns:
  54.  *    void
  55.  */
  56. static void D_LPC_isf_reorder(Word16 *isf, Word16 min_dist, Word16 n)
  57. {
  58.    Word32 i, isf_min;
  60.    isf_min = min_dist;
  62.    for(i = 0; i < n - 1; i++)
  63.    {
  64.       if(isf[i] < isf_min)
  65.       {
  66.          isf[i] = (Word16)isf_min;
  67.       }
  68.       isf_min = isf[i] + min_dist;
  69.    }
  71.    return;
  72. }
  75. /*
  76.  * D_LPC_isf_noise_d
  77.  *
  78.  * Parameters:
  79.  *    indice         I: indices of the selected codebook entries
  80.  *    isf_q          O: quantized ISFs (in frequency domain)
  81.  *
  82.  * Function:
  83.  *    Decoding of ISF parameters
  84.  *
  85.  * Returns:
  86.  *    void
  87.  */
  88. void D_LPC_isf_noise_d(Word16 *indice, Word16 *isf_q)
  89. {
  90.    Word32 i;
  92.    for(i = 0; i < 2; i++)
  93.    {
  94.       isf_q[i] = D_ROM_dico1_isf_noise[indice[0] * 2 + i];
  95.    }
  97.    for(i = 0; i < 3; i++)
  98.    {
  99.       isf_q[i + 2] = D_ROM_dico2_isf_noise[indice[1] * 3 + i];
  100.    }
  102.    for(i = 0; i < 3; i++)
  103.    {
  104.       isf_q[i + 5] = D_ROM_dico3_isf_noise[indice[2] * 3 + i];
  105.    }
  107.    for(i = 0; i < 4; i++)
  108.    {
  109.       isf_q[i + 8] = D_ROM_dico4_isf_noise[indice[3] * 4 + i];
  110.    }
  112.    for(i = 0; i < 4; i++)
  113.    {
  114.       isf_q[i + 12] = D_ROM_dico5_isf_noise[indice[4] * 4 + i];
  115.    }
  117.    for(i = 0; i < ORDER; i++)
  118.    {
  119.       isf_q[i] = (Word16)(isf_q[i]+ D_ROM_mean_isf_noise[i]);
  120.    }
  122.    D_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);
  124.    return;
  125. }
  128. /*
  129.  * D_LPC_isf_isp_conversion
  130.  *
  131.  * Parameters:
  132.  *    isp            O: (Q15) isp[m] (range: -1<=val<1)
  133.  *    isf            I: (Q15) isf[m] normalized (range: 0.0 <= val <= 0.5)
  134.  *    m              I: LPC order
  135.  *
  136.  * Function:
  137.  *    Transformation isf to isp
  138.  *
  139.  *    ISP are immitance spectral pair in cosine domain (-1 to 1).
  140.  *    ISF are immitance spectral pair in frequency domain (0 to 6400).
  141.  * Returns:
  142.  *    void
  143.  */
  144. void D_LPC_isf_isp_conversion(Word16 isf[], Word16 isp[], Word16 m)
  145. {
  146.    Word32 i, ind, offset, tmp;
  148.    for(i = 0; i < m - 1; i++)
  149.    {
  150.       isp[i] = isf[i];
  151.    }
  152.    isp[m - 1] = (Word16)(isf[m - 1] << 1);
  154.    for(i = 0; i < m; i++)
  155.    {
  156.       ind = isp[i] >> 7;         /* ind = b7-b15 of isf[i]     */
  157.       offset = isp[i] & 0x007f;  /* offset = b0-b6 of isf[i]   */
  159.       /* isp[i] = table[ind]+ ((table[ind+1]-table[ind])*offset) / 128 */
  160.       tmp = (D_ROM_cos[ind + 1] - D_ROM_cos[ind]) * offset;
  161.       isp[i] = (Word16)(D_ROM_cos[ind] + (tmp >> 7));
  162.    }
  163.    return;
  164. }
  167. /*
  168.  * D_LPC_isp_pol_get
  169.  *
  170.  * Parameters:
  171.  *    isp            I: Immitance spectral pairs (cosine domaine)
  172.  *    f              O: the coefficients of F1 or F2
  173.  *    n              I: no of coefficients (m/2)
  174.  *    k16            I: 16k flag
  175.  *
  176.  * Function:
  177.  *    Find the polynomial F1(z) or F2(z) from the ISPs.
  178.  *    This is performed by expanding the product polynomials:
  179.  *
  180.  *    F1(z) =   product   ( 1 - 2 isp_i z^-1 + z^-2 )
  181.  *            i=0,2,4,6,8
  182.  *    F2(z) =   product   ( 1 - 2 isp_i z^-1 + z^-2 )
  183.  *             i=1,3,5,7
  184.  *
  185.  *    where isp_i are the ISPs in the cosine domain.
  186.  *
  187.  * Returns:
  188.  *    void
  189.  */
  190. static void D_LPC_isp_pol_get(Word16 *isp, Word32 *f, Word32 n, Word16 k16)
  191. {
  192.    Word32 i, j, t0, s1, s2;
  193.    Word16 hi, lo;
  195.    s1 = 8388608;
  196.    s2 = 512;
  198.    if(k16)
  199.    {
  200.       s1 >>= 2;
  201.       s2 >>= 2;
  202.    }
  204.    /* All computation in Q23 */
  205.    f[0] = s1;              /* f[0] = 1.0; in Q23         */
  206.    f[1] = isp[0] * (-s2);  /* f[1] = -2.0*isp[0] in Q23  */
  207.    f += 2;                 /* Advance f pointer          */
  208.    isp += 2;               /* Advance isp pointer        */
  210.    for(i = 2; i <= n; i++)
  211.    {
  212.       *f = f[ - 2];
  214.       for(j = 1; j < i; j++, f--)
  215.       {
  216.          D_UTIL_l_extract(f[- 1], &hi, &lo);
  217.          t0 = D_UTIL_mpy_32_16(hi, lo, *isp);   /* t0 = f[-1] * isp */
  218.          t0 = (t0 << 1);
  219.          *f = (*f - t0);         /* *f -= t0    */
  220.          *f = (*f + f[ - 2]);    /* *f += f[-2] */
  221.       }
  223.       *f = *f - (*isp * s2);     /* *f -= isp << 8 */
  224.       f += i;     /* Advance f pointer   */
  225.       isp += 2;   /* Advance isp pointer */
  226.    }
  228.    return;
  229. }
  232. /*
  233.  * D_LPC_isp_a_conversion
  234.  *
  235.  * Parameters:
  236.  *    isp            I: (Q15) Immittance spectral pairs
  237.  *    a              O: (Q12) Predictor coefficients (order = M)
  238.  *    m              I: order of LP filter
  239.  *
  240.  * Function:
  241.  *    Convert ISPs to predictor coefficients a[]
  242.  *
  243.  * Returns:
  244.  *    void
  245.  */
  246. void D_LPC_isp_a_conversion(Word16 isp[], Word16 a[], Word16 m)
  247. {
  248.    Word32 j, i, nc;
  249.    Word32 f1[NC16k + 1], f2[NC16k];
  250.    Word32 t0;
  251.    Word16 hi, lo;
  253.    nc = m >> 1;
  255.    if(nc > 8)
  256.    {
  257.       D_LPC_isp_pol_get(&isp[0], f1, nc, 1);
  259.       for(i = 0; i <= nc; i++)
  260.       {
  261.          f1[i] = (f1[i] << 2);
  262.       }
  263.    }
  264.    else
  265.    {
  266.       D_LPC_isp_pol_get(&isp[0], f1, nc, 0);
  267.    }
  269.    if(nc > 8)
  270.    {
  271.       D_LPC_isp_pol_get(&isp[1], f2, nc - 1, 1);
  273.       for(i = 0; i <= nc - 1; i++)
  274.       {
  275.          f2[i] = (f2[i] << 2);
  276.       }
  277.    }
  278.    else
  279.    {
  280.       D_LPC_isp_pol_get(&isp[1], f2, nc - 1, 0);
  281.    }
  283.    /*
  284.     *  Multiply F2(z) by (1 - z^-2)
  285.     */
  286.    for(i = nc - 1; i > 1; i--)
  287.    {
  288.       f2[i] = f2[i] - f2[i - 2];   /* f2[i] -= f2[i-2]; */
  289.    }
  291.    /*
  292.     *  Scale F1(z) by (1+isp[m-1]) and F2(z) by (1-isp[m-1])
  293.     */
  294.    for(i = 0; i < nc; i++)
  295.    {
  296.       /* f1[i] *= (1.0 + isp[M-1]); */
  297.       D_UTIL_l_extract(f1[i], &hi, &lo);
  298.       t0 = D_UTIL_mpy_32_16(hi, lo, isp[m - 1]);
  299.       f1[i] = f1[i] + t0;
  301.       /* f2[i] *= (1.0 - isp[M-1]); */
  302.       D_UTIL_l_extract(f2[i], &hi, &lo);
  303.       t0 = D_UTIL_mpy_32_16(hi, lo, isp[m - 1]);
  304.       f2[i] = f2[i] - t0;
  305.    }
  307.    /*
  308.     *  A(z) = (F1(z)+F2(z))/2
  309.     *  F1(z) is symmetric and F2(z) is antisymmetric
  310.     */
  312.    /* a[0] = 1.0; */
  313.    a[0] = 4096;
  315.    for(i = 1, j = m - 1; i < nc; i++, j--)
  316.    {
  317.       /* a[i] = 0.5*(f1[i] + f2[i]); */
  318.       t0 = f1[i] + f2[i];   /* f1[i] + f2[i] */
  319.       a[i] = (Word16)((t0 + 0x800) >> 12);   /* from Q23 to Q12 and * 0.5 */
  321.       /* a[j] = 0.5*(f1[i] - f2[i]); */
  322.       t0 = (f1[i] - f2[i]);   /* f1[i] - f2[i] */
  323.       a[j] = (Word16)((t0 + 0x800) >> 12);   /* from Q23 to Q12 and * 0.5 */
  324.    }
  326.    /* a[NC] = 0.5*f1[NC]*(1.0 + isp[M-1]); */
  327.    D_UTIL_l_extract(f1[nc], &hi, &lo);
  328.    t0 = D_UTIL_mpy_32_16(hi, lo, isp[m - 1]);
  329.    t0 = (f1[nc] + t0);
  330.    a[nc] = (Word16)((t0 + 0x800) >> 12);  /* from Q23 to Q12 and * 0.5 */
  332.    /* a[m] = isp[m-1]; */
  333.    a[m] = (Word16)((isp[m - 1] + 0x4) >> 3); /* from Q15 to Q12 */
  335.    return;
  336. }
  339. /*
  340.  * D_LPC_a_weight
  341.  *
  342.  * Parameters:
  343.  *    a              I: LP filter coefficients
  344.  *    ap             O: weighted LP filter coefficients
  345.  *    gamma          I: weighting factor
  346.  *    m              I: order of LP filter
  347.  *
  348.  * Function:
  349.  *    Weighting of LP filter coefficients, ap[i] = a[i] * (gamma^i).
  350.  *
  351.  * Returns:
  352.  *    void
  353.  */
  354. void D_LPC_a_weight(Word16 a[], Word16 ap[], Word16 gamma, Word16 m)
  355. {
  356.    Word32 i, fac;
  358.    ap[0] = a[0];
  359.    fac = gamma;
  361.    for(i = 1; i < m; i++)
  362.    {
  363.       ap[i] = (Word16)(((a[i] * fac) + 0x4000) >> 15);
  364.       fac = ((fac * gamma)  + 0x4000) >> 15;
  365.    }
  367.    ap[m] = (Word16)(((a[m] * fac) + 0x4000) >> 15);
  369.    return;
  370. }
  373. /*
  374.  * D_LPC_isf_2s3s_decode
  375.  *
  376.  * Parameters:
  377.  *    indice            I: quantisation indices
  378.  *    isf_q             O: quantised ISFs in the cosine domain
  379.  *    past_isfq       I/O: past ISF quantizer
  380.  *    isfold            I: past quantised ISF
  381.  *    isf_buf           O: isf buffer
  382.  *    bfi               I: Bad frame indicator
  383.  *
  384.  * Function:
  385.  *    Decoding of ISF parameters.
  386.  *
  387.  * Returns:
  388.  *    void
  389.  */
  390. void D_LPC_isf_2s3s_decode(Word16 *indice, Word16 *isf_q, Word16 *past_isfq,
  391.                            Word16 *isfold, Word16 *isf_buf, Word16 bfi)
  392. {
  394.    Word32 ref_isf[M];
  395.    Word32 L_tmp, i, j;
  396.    Word16 tmp;
  398.    if(bfi == 0) /* Good frame */
  399.    {
  400.       for(i = 0; i < 9; i++)
  401.       {
  402.          isf_q[i] = D_ROM_dico1_isf[indice[0] * 9 + i];
  403.       }
  405.       for(i = 0; i < 7; i++)
  406.       {
  407.          isf_q[i + 9] = D_ROM_dico2_isf[indice[1] * 7 + i];
  408.       }
  410.       for(i = 0; i < 5; i++)
  411.       {
  412.          isf_q[i] =
  413.             (Word16)(isf_q[i] + D_ROM_dico21_isf_36b[indice[2] * 5 + i]);
  414.       }
  416.       for(i = 0; i < 4; i++)
  417.       {
  418.          isf_q[i + 5] =
  419.             (Word16)(isf_q[i + 5] + D_ROM_dico22_isf_36b[indice[3] * 4 + i]);
  420.       }
  422.       for(i = 0; i < 7; i++)
  423.       {
  424.          isf_q[i + 9] =
  425.             (Word16)(isf_q[i + 9] + D_ROM_dico23_isf_36b[indice[4] * 7 + i]);
  426.       }
  428.       for(i = 0; i < ORDER; i++)
  429.       {
  430.          tmp = isf_q[i];
  431.          isf_q[i] =
  432.             (Word16)((tmp + D_ROM_mean_isf[i]) + ((MU * past_isfq[i]) >> 15));
  433.          past_isfq[i] = tmp;
  434.       }
  436.       for(i = 0; i < M; i++)
  437.       {
  438.          for(j = (L_MEANBUF - 1); j > 0; j--)
  439.          {
  440.             isf_buf[j * M + i] = isf_buf[(j - 1) * M + i];
  441.          }
  442.          isf_buf[i] = isf_q[i];
  443.       }
  445.    }
  446.    else
  447.    {   /* bad frame */
  449.       for(i = 0; i < M; i++)
  450.       {
  451.          L_tmp = D_ROM_mean_isf[i];
  453.          for(j = 0; j < L_MEANBUF; j++)
  454.          {
  455.             L_tmp = L_tmp + isf_buf[j * M + i];
  456.          }
  457.          ref_isf[i] = (L_tmp + 0x1) >> 2;
  458.       }
  460.       /* use the past ISFs slightly shifted towards their mean */
  461.       for(i = 0; i < ORDER; i++)
  462.       {
  463.          isf_q[i] = (Word16)((((ALPHA * isfold[i]) >> 15) +
  464.             ((ONE_ALPHA * ref_isf[i]) >> 15)));
  465.       }
  467.       /* estimate past quantized residual to be used in next frame */
  468.       for(i = 0; i < ORDER; i++)
  469.       {
  470.          /* predicted ISF */
  471.          L_tmp = ref_isf[i] + ((past_isfq[i] * MU) >> 15);
  472.          /* past_isfq[i] *= 0.5 */
  473.          past_isfq[i] = (Word16)((isf_q[i] - L_tmp) >> 1);
  474.       }
  475.    }
  477.    D_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);
  479.    return;
  480. }
  483. /*
  484.  * D_LPC_isf_2s5s_decode
  485.  *
  486.  * Parameters:
  487.  *    indice            I: quantization indices
  488.  *    isf_q             O: quantized ISFs in the cosine domain
  489.  *    past_isfq       I/O: past ISF quantizer
  490.  *    isfold            I: past quantized ISF
  491.  *    isf_buf           O: isf buffer
  492.  *    bfi               I: Bad frame indicator
  493.  *
  494.  * Function:
  495.  *    Decoding of ISF parameters.
  496.  *
  497.  * Returns:
  498.  *    void
  499.  */
  500. void D_LPC_isf_2s5s_decode(Word16 *indice, Word16 *isf_q, Word16 *past_isfq,
  501.                            Word16 *isfold, Word16 *isf_buf, Word16 bfi)
  502. {
  503.    Word32 ref_isf[M];
  504.    Word32 i, j, L_tmp;
  505.    Word16 tmp;
  507.    if(bfi == 0) /* Good frame */
  508.    {
  509.       for(i = 0; i < 9; i++)
  510.       {
  511.          isf_q[i] = D_ROM_dico1_isf[indice[0] * 9 + i];
  512.       }
  514.       for(i = 0; i < 7; i++)
  515.       {
  516.          isf_q[i + 9] = D_ROM_dico2_isf[indice[1] * 7 + i];
  517.       }
  519.       for(i = 0; i < 3; i++)
  520.       {
  521.          isf_q[i] = (Word16)(isf_q[i] + D_ROM_dico21_isf[indice[2] * 3 + i]);
  522.       }
  524.       for(i = 0; i < 3; i++)
  525.       {
  526.          isf_q[i + 3] =
  527.             (Word16)(isf_q[i + 3] + D_ROM_dico22_isf[indice[3] * 3 + i]);
  528.       }
  530.       for(i = 0; i < 3; i++)
  531.       {
  532.          isf_q[i + 6] =
  533.             (Word16)(isf_q[i + 6] + D_ROM_dico23_isf[indice[4] * 3 + i]);
  534.       }
  536.       for(i = 0; i < 3; i++)
  537.       {
  538.          isf_q[i + 9] =
  539.             (Word16)(isf_q[i + 9] + D_ROM_dico24_isf[indice[5] * 3 + i]);
  540.       }
  542.       for(i = 0; i < 4; i++)
  543.       {
  544.          isf_q[i + 12] =
  545.             (Word16)(isf_q[i + 12] + D_ROM_dico25_isf[indice[6] * 4 + i]);
  546.       }
  548.       for(i = 0; i < ORDER; i++)
  549.       {
  550.          tmp = isf_q[i];
  551.          isf_q[i] =
  552.             (Word16)((tmp + D_ROM_mean_isf[i]) + ((MU * past_isfq[i]) >> 15));
  553.          past_isfq[i] = tmp;
  554.       }
  557.       for(i = 0; i < M; i++)
  558.       {
  559.          for(j = (L_MEANBUF - 1); j > 0; j--)
  560.          {
  561.             isf_buf[j * M + i] = isf_buf[(j - 1) * M + i];
  562.          }
  563.          isf_buf[i] = isf_q[i];
  564.       }
  566.    }
  567.    else
  568.    {   /* bad frame */
  570.       for(i = 0; i < M; i++)
  571.       {
  572.          L_tmp = D_ROM_mean_isf[i];
  574.          for(j = 0; j < L_MEANBUF; j++)
  575.          {
  576.             L_tmp = L_tmp + isf_buf[j * M + i];
  577.          }
  579.          ref_isf[i] = (L_tmp + 0x1) >> 2;
  580.       }
  582.       /* use the past ISFs slightly shifted towards their mean */
  583.       for(i = 0; i < ORDER; i++)
  584.       {
  585.          isf_q[i] = (Word16)(((ALPHA * isfold[i]) >> 15) +
  586.             ((ONE_ALPHA * ref_isf[i]) >> 15));
  587.       }
  589.       /* estimate past quantized residual to be used in next frame */
  590.       for(i = 0; i < ORDER; i++)
  591.       {
  592.          /* predicted ISF */
  593.          L_tmp = ref_isf[i] + ((past_isfq[i] * MU) >> 15);
  594.          /* past_isfq[i] *= 0.5 */
  595.          past_isfq[i] = (Word16)((isf_q[i] - L_tmp) >> 1);
  596.       }
  597.    }
  599.    D_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);
  601.    return;
  602. }
  605. /*
  606.  * D_LPC_int_isp_find
  607.  *
  608.  * Parameters:
  609.  *    isp_old           I: isps from past frame
  610.  *    isp_new           I: isps from present frame
  611.  *    frac              I: (Q15) fraction for 3 first subfr
  612.  *    Az                O: LP coefficients in 4 subframes
  613.  *
  614.  * Function:
  615.  *    Find the interpolated ISP parameters for all subframes.
  616.  *
  617.  * Returns:
  618.  *    void
  619.  */
  620. void D_LPC_int_isp_find(Word16 isp_old[], Word16 isp_new[],
  621.                         const Word16 frac[], Word16 Az[])
  622. {
  623.    Word32 tmp, i, k, fac_old, fac_new;
  624.    Word16 isp[M];
  626.    for(k = 0; k < 3; k++)
  627.    {
  628.       fac_new = frac[k];
  629.       fac_old = (32767 - fac_new) + 1;   /* 1.0 - fac_new */
  631.       for(i = 0; i < M; i++)
  632.       {
  633.          tmp = isp_old[i] * fac_old;
  634.          tmp += isp_new[i] * fac_new;
  635.          isp[i] = (Word16)((tmp + 0x4000) >> 15);
  636.       }
  638.       D_LPC_isp_a_conversion(isp, Az, M);
  639.       Az += MP1;
  640.    }
  642.    /* 4th subframe: isp_new (frac=1.0) */
  643.    D_LPC_isp_a_conversion(isp_new, Az, M);
  645.    return;
  646. }
  649. /*
  650.  * D_LPC_isf_extrapolation
  651.  *
  652.  * Parameters:
  653.  *    HfIsf          I/O: ISF vector
  654.  *
  655.  * Function:
  656.  *    Conversion of 16th-order 12.8kHz ISF vector
  657.  *    into 20th-order 16kHz ISF vector
  658.  *
  659.  * Returns:
  660.  *    void
  661.  */
  662. void D_LPC_isf_extrapolation(Word16 HfIsf[])
  663. {
  664.    Word32 IsfDiff[M - 2];
  665.    Word32 IsfCorr[3];
  666.    Word32 tmp, tmp2, tmp3, mean, i;
  667.    Word32 MaxCorr, exp, exp2, coeff;
  668.    Word16 hi, lo;
  670.    HfIsf[M16k - 1] = HfIsf[M - 1];
  672.    /* Difference vector */
  673.    for(i = 1; i < M - 1; i++)
  674.    {
  675.       IsfDiff[i - 1] = HfIsf[i] - HfIsf[i - 1];
  676.    }
  678.    tmp = 0;
  680.    /* Mean of difference vector */
  681.    for(i = 3; i < (M - 1); i++)
  682.    {
  683.       tmp = tmp + (IsfDiff[i - 1] * INV_LENGTH);
  684.    }
  686.    mean = (tmp + 0x4000) >> 15;
  687.    IsfCorr[0] = 0;
  688.    IsfCorr[1] = 0;
  689.    IsfCorr[2] = 0;
  690.    tmp = 0;
  692.    for(i = 0; i < M - 2; i++)
  693.    {
  694.       if(IsfDiff[i] > tmp)
  695.       {
  696.          tmp = IsfDiff[i];
  697.       }
  698.    }
  700.    exp = D_UTIL_norm_s((Word16)tmp);
  702.    for(i = 0; i < M - 2; i++)
  703.    {
  704.       IsfDiff[i] = IsfDiff[i] << exp;
  705.    }
  707.    mean = mean << exp;
  709.    for(i = 7; i < M - 2; i++)
  710.    {
  711.       tmp2 = IsfDiff[i] - mean;
  712.       tmp3 = IsfDiff[i - 2] - mean;
  713.       tmp = (tmp2 * tmp3) << 1;
  714.       D_UTIL_l_extract(tmp, &hi, &lo);
  715.       tmp = D_UTIL_mpy_32(hi, lo, hi, lo);
  716.       IsfCorr[0] = (IsfCorr[0] + tmp);
  717.    }
  719.    for(i = 7; i < M - 2; i++)
  720.    {
  721.       tmp2 = IsfDiff[i] - mean;
  722.       tmp3 = IsfDiff[i - 3] - mean;
  723.       tmp = (tmp2 * tmp3) << 1;
  724.       D_UTIL_l_extract(tmp, &hi, &lo);
  725.       tmp = D_UTIL_mpy_32(hi, lo, hi, lo);
  726.       IsfCorr[1] = (IsfCorr[1] + tmp);
  727.    }
  729.    for(i = 7; i < M - 2; i++)
  730.    {
  731.       tmp2 = IsfDiff[i] - mean;
  732.       tmp3 = IsfDiff[i - 4] - mean;
  733.       tmp = (tmp2 * tmp3) << 1;
  734.       D_UTIL_l_extract(tmp, &hi, &lo);
  735.       tmp = D_UTIL_mpy_32(hi, lo, hi, lo);
  736.       IsfCorr[2] = (IsfCorr[2] + tmp);
  737.    }
  739.    if(IsfCorr[0] > IsfCorr[1])
  740.    {
  741.       MaxCorr = 0;
  742.    }
  743.    else
  744.    {
  745.       MaxCorr = 1;
  746.    }
  748.    if(IsfCorr[2] > IsfCorr[MaxCorr])
  749.    {
  750.       MaxCorr = 2;
  751.    }
  753.    MaxCorr = MaxCorr + 1;   /* Maximum correlation of difference vector */
  755.    for(i = M - 1; i < (M16k - 1); i++)
  756.    {
  757.       tmp = (HfIsf[i - 1 - MaxCorr] - HfIsf[i - 2 - MaxCorr]);
  758.       HfIsf[i] = (Word16)(HfIsf[i - 1] + tmp);
  759.    }
  761.    /* tmp=7965+(HfIsf[2]-HfIsf[3]-HfIsf[4])/6; */
  762.    tmp = HfIsf[4] + HfIsf[3];
  763.    tmp = HfIsf[2] - tmp;
  764.    tmp = (tmp * 5461) >> 15;
  765.    tmp = tmp + 20390;
  767.    if(tmp > 19456)
  768.    {   /* Maximum value of ISF should be at most 7600 Hz */
  769.       tmp = 19456;
  770.    }
  772.    tmp = tmp - HfIsf[M - 2];
  773.    tmp2 = HfIsf[M16k - 2] - HfIsf[M - 2];
  774.    exp2 = D_UTIL_norm_s((Word16)tmp2);
  775.    exp = D_UTIL_norm_s((Word16)tmp);
  776.    exp = exp - 1;
  777.    tmp = tmp << exp;
  778.    tmp2 = tmp2 << exp2;
  779.    coeff = (tmp << 15) / tmp2;   /* Coefficient for stretching the ISF vector */
  780.    exp = exp2 - exp;
  782.    if(exp >= 0)
  783.    {
  784.       for(i = M - 1; i < M16k - 1; i++)
  785.       {
  786.          tmp = ((HfIsf[i] - HfIsf[i - 1]) * coeff) >> 15;
  787.          IsfDiff[i - (M - 1)] = tmp << exp;
  788.       }
  789.    }
  790.    else
  791.    {
  792.       exp = 15 - exp;
  794.       for(i = M - 1; i < M16k - 1; i++)
  795.       {
  796.          IsfDiff[i - (M - 1)] = ((HfIsf[i] - HfIsf[i - 1]) * coeff) >> exp;
  797.       }
  798.    }
  800.    for(i = M; i < (M16k - 1); i++)
  801.    {
  802.       /* The difference between ISF(n) and ISF(n-2) should be at least 500 Hz */
  803.       tmp = ((IsfDiff[i - (M - 1)] + IsfDiff[i - M]) - 1280);
  805.       if(tmp < 0)
  806.       {
  807.          if(IsfDiff[i - (M - 1)] > IsfDiff[i - M])
  808.          {
  809.             IsfDiff[i - M] = (1280 - IsfDiff[i - (M - 1)]);
  810.          }
  811.          else
  812.          {
  813.             IsfDiff[i - (M - 1)] = (1280 - IsfDiff[i - M]);
  814.          }
  815.       }
  816.    }
  818.    for(i = M - 1; i < M16k - 1; i++)
  819.    {
  820.       HfIsf[i] = (Word16)(HfIsf[i - 1] + IsfDiff[i - (M - 1)]);
  821.    }
  823.    for(i = 0; i < M16k - 1; i++)
  824.    {
  825.       HfIsf[i] = (Word16)((HfIsf[i] * 13107) >> 14);
  826.       /* Scale the ISF vector correctly for 16000 kHz */
  827.    }
  829.    D_LPC_isf_isp_conversion(HfIsf, HfIsf, M16k);
  831.    return;
  832. }