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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
mtrxgen.c
资源名称：celp32c.rar　[点击查看]
上传用户：tsjrly
上传日期：2021-02-19
资源大小：107k
文件大小：4k
源码类别：

语音压缩

开发平台：

C/C++

mtrxgen.c：源码内容
  1. /**************************************************************************
  2. *
  3. * ROUTINE
  4. * matrixgen
  5. *
  6. * FUNCTION
  7. *  
  8. * This routine is used to generate the H matrix and 
  9. * syndrome table necessary for Hamming encode and decode.  
  10. * This routine should be called once before calling
  11. *   encodeham and decodeham.
  12. *
  13. * SYNOPSIS
  14. * subroutine matrixgen(codelength1,codelength2,
  15. * hmatrix,syndrometable)
  16. *
  17. *   formal 
  18. *
  19. *                       data    I/O
  20. *       name            type    type    function
  21. *       -------------------------------------------------------------------
  22. * codelength1 int i number of data bits (63)
  23. * codelength2 int i number of information bits (57)
  24. * hmatrix int o vector to encode and decode by
  25. * syndrometable  int o table containing error masks
  26. *
  27. ***************************************************************************
  28. *
  29. * DESCRIPTION
  30. *
  31. * This subroutine is part of a set of subroutines which perform
  32. * a Generalized Hamming Code.  As you know, Hamming codes are perfect
  33. * codes and can only detect and correct one error.  We added an overall
  34. *  parity checkbit, which allows us to detect 2 errors.  When 2 errors 
  35. * are detected, (in subroutine decodeham) no correction attempt is
  36. * made.  This would most likely result in more errors.  Instead, a flag
  37. * is sent to the calling program notifying it of multiple errors so
  38. * that smoothing may be attempted.  The Hamming codes presently 
  39. * supported by the routines are (63,57), (31,26), (15,11), and
  40. *  shortened variations thereof.  It could be made even more general 
  41. * by making minor modifications to the decimal to binary output vector 
  42. * code in the encodeham procedure.  This routine at present will 
  43. * calculate a maximum of 6 bits.
  44. *
  45. * Hamming routines consist of the following files:
  46. *
  47. * matrixgen - generates the hmatrix and sydrometable.
  48. * encodeham - generates the codeword and overall paritybit.
  49. * decodeham - recovers infobits, checks for errors, corrects 1
  50. *     error, and sends out flag for smoothing.
  51. *
  52. * This routine initializes all of the tables necessary to perform
  53. * the Hamming code (G Matrix, Syndrome Table) .  
  54. *
  55. ***************************************************************************
  56. *
  57. * CALLED BY
  58. *
  59. * celp
  60. *
  61. * CALLS
  62. *
  63. *
  64. ***************************************************************************
  65. *
  66. * REFERENCES
  67. *
  68. * Lin and Costello:  Error Control Coding
  69. * Berlekamp:  Algebraic Coding Theory
  70. *
  71. **************************************************************************/
  72. matrixgen(codelength1, codelength2, hmatrix, syndrometable)
  73. int codelength1, codelength2, hmatrix[], syndrometable[];
  74. {
  75.   int i, temp1;
  77.   /* This is the data necessary to construct the G Matrix and the 
  78.         Syndrome Table.  If a larger code is desired, this table can 
  79.         be easily added to.  All other routines, except the syndrome 
  80.         table construction,  are general enough to calculate any size 
  81.         Hamming Code. */
  83.   static int itemplate[] = { 1,  2,  4,  8, 16, 32};
  84.   static int ptemplate[] = 
  85.       { 3,  5,  6,  7,  9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20,
  86.        21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 33, 34, 35, 36,
  87.        37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
  88.        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63};
  90.   /* Construct the parity portion of the hmatrix */
  91.   
  92.   for (i = 0; i < codelength2; i++)
  93.     hmatrix[i] = ptemplate[i];
  95.   /* Construct the identity portion of the hmatrix. */
  97.   for (i = 0; i < codelength1 - codelength2; i++)
  98.     hmatrix[codelength2 + i] = itemplate[i];
  99.     
  100.   /* Construct the syndrometable.  This routine is rather simple because
  101. I chose to arrange my G matrix sequentially (Berlekamp method).  
  102. I placed the parity bits in front in ascending order then added the 
  103. bits left over in ascending order.  Since our code is linear I can
  104. get away with this.  If a larger Hamming code is needed, then a new 
  105. exception must be generated for each parity bit.   */
  107.   temp1 = 1;
  108.   for (i = 1; i <= codelength1; i++)
  109.   {
  110.     switch (i)
  111.     {
  112.       case 1:
  113.         syndrometable[i - 1] = codelength2 + 1;
  114.         break;
  115.       case 2:
  116.         syndrometable[i - 1] = codelength2 + 2;
  117.         break;
  118.       case 4:
  119.         syndrometable[i - 1] = codelength2 + 3;
  120.         break;
  121.       case 8:
  122.         syndrometable[i - 1] = codelength2 + 4;
  123.         break;
  124.       case 16:
  125.         syndrometable[i - 1] = codelength2 + 5;
  126.         break;
  127.       case 32:
  128.         syndrometable[i - 1] = codelength2 + 6;
  129.         break;
  130.       default:
  131.         syndrometable[i - 1] = temp1++;
  132.     };
  133.   }
  134. }