ldelnr.c
上传用户:szhypcb168
上传日期:2007-01-06
资源大小:2187k
文件大小:6k
源码类别:

语音压缩

开发平台:

Unix_Linux

  1. #define NFRAC 6
  2. #define TRUE 1
  3. #define FALSE 0
  4. #define M1 -10
  5. #define M2   9
  6. /* five fractional delays plus zero delay = 6 */
  7. static float frac[NFRAC] = {0.25, 0.33333334, 0.5, 0.66666667, 0.75, 0.0};
  8. static int twelfths[NFRAC] = {3, 4, 6, 8, 9, 0};
  9. /**************************************************************************
  10. *
  11. * NAME
  12. * ldelay_nr
  13. *
  14. * FUNCTION
  15. * Time delay a bandlimited signal
  16. * using blockwise recursion (aka "nonrecursive")
  17. * with a long interpolation filter (see delay_ne.c)
  18. *
  19. * SYNOPSIS
  20. * subroutine ldelay_nr(x, start, n, d, m, y)
  21. *
  22. *   formal 
  23. *                       data    I/O
  24. *       name            type    type    function
  25. *       -------------------------------------------------------------------
  26. * x[n] float i signal input
  27. * start int i beginning of output sequence
  28. * n int i length of input sequence
  29. * d float i fractional pitch
  30. * m int i integer pitch
  31. * y[n] float o delayed input signal
  32. *
  33. ***************************************************************************
  34. *
  35. * DESCRIPTION
  36. *
  37. * Subroutine to time delay a bandlimited signal by resampling the
  38. * reconstructed data (aka sinc interpolation).  The well known
  39. * reconstruction formula is:
  40. *
  41. *              |    M2      sin[pi(t-nT)/T]    M2
  42. *   y(n) = X(t)| = SUM x(n) --------------- = SUM x(n) sinc[(t-nT)/T]
  43. *              |   n=M1         pi(t-nT)/T    n=M1
  44. *              |t=n+d
  45. *
  46. * The interpolating (sinc) function is Hamming windowed to bandlimit
  47. * the signal to reduce aliasing.
  48. *
  49. * Multiple simultaneous time delays may be efficiently calculated
  50. * by polyphase filtering.  Polyphase filters decimate the unused
  51. * filter coefficients.  See Chapter 6 in C&R for details. 
  52. *
  53. ***************************************************************************
  54. *
  55. * CALLED BY
  56. *
  57. * pitchvq   psearch
  58. *
  59. * CALLS
  60. *
  61. * ham
  62. *
  63. ***************************************************************************
  64. *
  65. * REFERENCES
  66. *
  67. * Crochiere & Rabiner, Multirate Digital Signal Processing,
  68. * P-H 1983, Chapters 2 and 6.
  69. *
  70. * Kroon & Atal, "Pitch Predictors with High Temporal Resolution,"
  71. * ICASSP '90, S12.6
  72. *
  73. * CELP Documentation, Version 3.1, Figure 9, 15 Dec '89.
  74. *
  75. **************************************************************************/
  76. #define SIZE (M2 - M1 + 1)
  77. ldelay_nr(x, start, n, d, m, y)
  78. float x[], d, y[];
  79. int m, n, start;
  80. {
  81.   static float wsinc[SIZE][NFRAC], hwin[12*SIZE+1];
  82.   float pitch, pitch2, pitch3;
  83.   static int first = TRUE;
  84.   float sinc();
  85.   int i, j, k, index, k2, k3, mtwo, qd();
  86.   /* Generate Hamming windowed sinc interpolating function for each */
  87.   /* allowable fraction.  The interpolating functions are stored in   */
  88.   /* time reverse order (i.e., delay appears as advance) to align     */
  89.   /* with the adaptive code book v0 array.  The interp filters are:   */
  90.   /*  wsinc[.,0] frac = 1/4 (3/12)       */
  91.   /*  wsinc[.,1] frac = 1/3 (4/12)       */
  92.   /*  . .       */
  93.   /*  wsinc[.,4] frac = 3/4 (9/12)       */
  94.   /*  wsinc[.,5] frac = 0 zero delay for programming ease*/
  95.   if (first)
  96.   {
  97.     ham(hwin, 12*SIZE+1);
  98.     for (i = 0; i < NFRAC; i++)
  99.       for (k = M1, j = 0; j < SIZE; j++)
  100.       {
  101.         wsinc[j][i] = sinc(frac[i] + k) * hwin[12*j+twelfths[i]];
  102.         k++;
  103.       }
  104.     first = FALSE;
  105.   }
  106.   index = qd_nr(d);
  107.   /* *Resample:   */
  108.   /* *If delay is greater than n(=60), then lay down n values at   */
  109.   /* *the appropriate delay.   */
  110.   if (m >= n)
  111.   {
  112.     for (i = 0; i < n + M1; i++)
  113.     {
  114.       y[i] = 0.0;
  115.       for (k = M1, j = 0; j < SIZE; j++)
  116.       {
  117.         y[i] += x[i+k+start-m-1] * wsinc[j][index];
  118.         k++;
  119.       }
  120.     }
  121.     for (i = 0; i < M2; i++)
  122.       x[start+i-1] = y[i];
  123.     for (i = n+M1; i < n; i++)
  124.     {
  125.       y[i] = 0.0;
  126.       for (k = M1, j = 0; j < SIZE; j++)
  127.       {
  128.         y[i] += x[i+k+start-m-1] * wsinc[j][index];
  129.         k++;
  130.       }
  131.     }
  132.   }
  133.   else
  134.   /* *If delay is less than n/2 (=30), then lay down two pitch periods  */
  135.   /* *with the appropriate delay, and part of third pitch period with */
  136.   /* *the appropriate delay. */
  137.   {
  138.     pitch = m + d;
  139.     if (m < n / 2)
  140.     {
  141.       for (i = 0; i < m + M1; i++)
  142.       {
  143.         y[i] = 0.0;
  144.         for (k = M1, j = 0; j < SIZE; j++)
  145.         {
  146.           y[i] += x[i+k+start-m-1] * wsinc[j][index];
  147.           k++;
  148.         }
  149.       }
  150.       for (i = 0; i < M2 + 1; i++)
  151.       {
  152.         x[start+i-1] = y[i];
  153.       }
  154.       for (i = m + M1; i < m; i++)
  155.       {
  156.         y[i] = 0.0;
  157.         for (k = M1, j = 0; j < SIZE; j++)
  158.         {
  159.           y[i] += x[i+k+start-m-1] * wsinc[j][index];
  160.           k++;
  161.         }
  162.        }
  163.       pitch2 = 2 * pitch;
  164.       k2 = (int)(pitch2 - 2 * m);
  165.       mtwo = (int)(pitch2);
  166.       d = pitch2 - (2 * m + k2);
  167.       if (fabs(d) > 0.1 && fabs(d) < 0.9)
  168.         index = qd_nr(d);
  169.       else 
  170.         index = 5;
  171.       for (i = m; i < mtwo; i++)
  172.       {
  173.         y[i] = 0.0;
  174.         for (k = M1, j = 0; j < SIZE; j++)
  175.         {
  176.           y[i] += x[i+k+start-2*m-k2-1] * wsinc[j][index];
  177.           k++;
  178.         }
  179.       }
  180.       pitch3 = 3 * pitch;
  181.       k3 = (int)(pitch3 - (3 * m + k2));
  182.       d = pitch3 - (3 * m + k2 + k3);
  183.       if (fabs(d) > 0.1 && fabs(d) < 0.9)
  184.         index = qd_nr(d);
  185.       else
  186.         index = 5;
  187.       for (i = mtwo; i < n; i++)
  188.       {
  189.         y[i] = 0.0;
  190.          for (k = M1, j = 0; j < SIZE; j++)
  191.          {
  192.            y[i] += x[i+k+start-m-mtwo-k3-k2-1] * wsinc[j][index];
  193.            k++;
  194.          }
  195.       }     
  196.     }
  197.     else
  198.     /* *If delay is greater than n/2 (=30), then lay down one pitch */
  199.     /* *period with the appropriate delay, and part of the second pitch */
  200.     /* *period with appropriate delay.    */
  201.     {
  202.       for (i = 0; i < m + M1; i++)
  203.       {
  204.         y[i] = 0.0;
  205.         for (k = M1, j = 0; j < SIZE; j++)
  206.         {
  207.           y[i] += x[i+k+start-m-1] * wsinc[j][index];
  208.           k++;
  209.         }
  210.       }
  211.       for (i = 0; i < M2 + 1; i++)
  212.         x[start+i-1] = y[i];
  213.       for (i = m + M1; i < m; i++)
  214.       {
  215.         y[i] = 0.0;
  216.         for (k = M1, j = 0; j < SIZE; j++)
  217.         {
  218.           y[i] += x[i+k+start-m-1] * wsinc[j][index];
  219.           k++;
  220.         }
  221.       }
  222.       pitch2 = 2 * pitch;
  223.       k2 = (int)(pitch2 - 2 * m);
  224.       d = pitch2 - (2 * m + k2);
  225.       if (fabs(d) > 0.1 && fabs(d) < 0.9)
  226.         index = qd_nr(d);
  227.       else
  228.         index = 5;
  229.       for (i = m; i < n; i ++)
  230.       {
  231.         y[i] = 0.0;
  232.         for (k = M1, j = 0; j < SIZE; j++)
  233.         {
  234.           y[i] += x[i+k+start-2*m-k2-1] * wsinc[j][index];
  235.           k++;
  236.         }
  237.       }
  238.     }
  239.   }
  240.   for (i = 0; i < M2 + 1; i++)
  241.     x[start+i-1] = 0;
  242. }