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

语音压缩

开发平台:

Unix_Linux

  1. /**************************************************************************
  2. *
  3. * ROUTINE
  4. *               lsp34
  5. *
  6. * FUNCTION
  7. *
  8. *               independent nonuniform scalar line spectral pair quantizer
  9. *
  10. * SYNOPSIS
  11. *               subroutine lsp34(freq, no, bits, findex)
  12. *
  13. *   formal
  14. *
  15. *                       data    I/O
  16. *       name            type    type    function
  17. *       -------------------------------------------------------------------
  18. *       freq float i/o input frequency array/
  19. * output quantized frequency array
  20. * no int i order
  21. * bits int i bit allocation
  22. * findex int o frequency index array
  23. *
  24. *
  25. ***************************************************************************
  26. *
  27. * DESCRIPTION
  28. *
  29. * Independent (nondifferential) scalar LSP quantization.  Determine
  30. * LSP quantization by refined sequential quantization.  Because the
  31. * quantization tables overlap, sequential quantization can produce a
  32. * nonmonotonic LSP vector.  For nonmonotinic LSPs, the quantization
  33. * is refined by adjusting the quantization for minimum error by
  34. * selecting 1 of the following 2 cases:
  35. * 1.  Quantize current LSP to next higher level
  36. * 2.  Quantize previous LSP to the next lower level
  37. *
  38. ***************************************************************************
  39. *
  40. * CALLED BY
  41. *
  42. * celp
  43. *
  44. * CALLS
  45. *
  46. *
  47. **************************************************************************/
  48. #define FSCALE 8000.0
  49. #define mmax(A,B) ((A)>(B)?(A):(B))
  50. #define mmin(A,B) ((A)<(B)?(A):(B))
  51. #include <math.h>
  52. #include "ccsub.h"
  53. static int lsp[MAXNO][16] =
  54. {
  55.   { 100,  170,  225,  250,  280,  340,  420,  500},
  56.   { 210,  235,  265,  295,  325,  360,  400,  440,
  57.     480,  520,  560,  610,  670,  740,  810,  880},
  58.   { 420,  460,  500,  540,  585,  640,  705,  775,
  59.     850,  950, 1050, 1150, 1250, 1350, 1450, 1550},
  60.   { 620,  660,  720,  795,  880,  970, 1080, 1170,
  61.    1270, 1370, 1470, 1570, 1670, 1770, 1870, 1970},
  62.   {1000, 1050, 1130, 1210, 1285, 1350, 1430, 1510,
  63.    1590, 1670, 1750, 1850, 1950, 2050, 2150, 2250},
  64.   {1470, 1570, 1690, 1830, 2000, 2200, 2400, 2600},
  65.   {1800, 1880, 1960, 2100, 2300, 2480, 2700, 2900},
  66.   {2225, 2400, 2525, 2650, 2800, 2950, 3150, 3350},
  67.   {2760, 2880, 3000, 3100, 3200, 3310, 3430, 3550},
  68.   {3190, 3270, 3350, 3420, 3490, 3590, 3710, 3830},
  69. };
  70. lsp34(freq, no, bits, findex)
  71. int no, bits[], findex[];
  72. float freq[];
  73. {
  74.   int levels, i, j;
  75.   float dist, low, errorup, errordn;
  76.   /* *sequentially find closest quantized LSP indicies */
  77.   for (i = 0; i < no; i++)
  78.   {
  79.     freq[i] *= FSCALE;
  80.     levels = (1 << bits[i]) - 1;
  81.     /* *Quantize to nearest output level  */
  82.     low = dist = fabs(freq[i] - *lsp[i]);
  83.     findex[i] = 0;
  84.     for (j = 1; j <= levels; j++)
  85.     {
  86.       dist = fabs(freq[i] - lsp[i][j]);
  87.       if (dist < low)
  88.       {
  89. low = dist;
  90. findex[i] = j;
  91.       }
  92.     }
  93.     /* *adjust quantization if nonmonotonically quantized
  94.        *find minimum quantization error adjustment   */
  95.     if (i > 0)
  96.     {
  97.       if (lsp[i][findex[i]] <= lsp[i - 1][findex[i - 1]])
  98.       {
  99. errorup = fabs(freq[i] - lsp[i][mmin(findex[i] + 1, levels)]) +
  100.   fabs(freq[i - 1] - lsp[i - 1][findex[i - 1]]);
  101. errordn = fabs(freq[i] - lsp[i][findex[i]]) +
  102.   fabs(freq[i - 1] - lsp[i - 1][mmax(findex[i - 1] - 1, 0)]);
  103. /* *adjust index for minimum error (and preserve monotonicity!) */
  104. if (errorup < errordn)
  105.         {
  106.           findex[i] = mmin(findex[i] + 1, levels);
  107.   while (lsp[i][findex[i]] < lsp[i-1][findex[i-1]])
  108.             findex[i] = mmin(findex[i] + 1, levels);
  109.         }
  110. else if (i == 1)
  111.   findex[i - 1] = mmax(findex[i - 1] - 1, 0);
  112. else if (lsp[i - 1][mmax(findex[i - 1] - 1, 0)] >
  113.  lsp[i - 2][findex[i - 2]])
  114.   findex[i - 1] = mmax(findex[i - 1] - 1, 0);
  115. else
  116.         {
  117.   findex[i] = mmin(findex[i] + 1, levels);
  118.           while (lsp[i][findex[i]] < lsp[i-1][findex[i-1]])
  119.             findex[i] = mmin(findex[i] + 1, levels);
  120.         }
  121.       }
  122.     }
  123.   }
  124.   /* *quantize lsp frequencies using indicies found above */
  125.   for (i = 0; i < no; i++)
  126.     freq[i] = lsp[i][findex[i]] / FSCALE;
  127. }
  128. /**************************************************************************
  129. *
  130. * ROUTINE
  131. *               lspdecode34
  132. *
  133. * FUNCTION
  134. *                
  135. *               independent nonuniform scalar lsp decoder 
  136. *
  137. * SYNOPSIS
  138. *               subroutine lspdecode34(findex,no,freq)
  139. *
  140. *   formal 
  141. *
  142. *                       data    I/O
  143. *       name            type    type    function
  144. *       -------------------------------------------------------------------
  145. *       findex int i lsp frequency index
  146. * no int i lpc order
  147. * freq float o lsp quantized frequency
  148. *
  149. ***************************************************************************
  150. *
  151. * DESCRIPTION
  152. * George Kang's tables modified for no preemphasis and bit allocation
  153. *
  154. ***************************************************************************
  155. *
  156. * CALLED BY
  157. *
  158. * celp
  159. *
  160. * CALLS
  161. *
  162. *
  163. **************************************************************************/
  164. lspdecode34(findex,no,freq)
  165. int findex[], no;
  166. float freq[];
  167. {
  168.   int i;
  169.   /* *** choose appropriate frequency by findex */
  170.   
  171.   for (i = 0; i < no; i++)
  172.   {
  173.     freq[i] = lsp[i][findex[i]]/FSCALE;
  174.   }
  175. }