dec_lpc.c
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:20k
源码类别:

Symbian

开发平台:

Visual C++

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