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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
CRC32.C
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：14k
源码类别：

模拟服务器

开发平台：

C/C++

CRC32.C：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   CRC32.C
  4. //  Creater     :   Freeway Chen
  5. //  Date        :   2000-6-15 18:25:43
  6. //  Comment     :   Get source code from Zlib Project
  7. //
  8. //////////////////////////////////////////////////////////////////////////////////////
  10. /* crc32.c -- compute the CRC-32 of a data stream
  11.  * Copyright (C) 1995-1998 Mark Adler
  12.  * For conditions of distribution and use, see copyright notice in zlib.h 
  13.  */
  16. typedef unsigned __int32 CRC_UINT32;
  17. typedef unsigned __int8  CRC_BYTE;
  19. #ifdef DYNAMIC_CRC_TABLE
  21. static int CRCTableEmptyFlag = 1;
  22. static CRC_UINT32 CRC_Table[256];
  23. static void MakeCRCTable(void);
  25. /*
  26.   Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
  27.   x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
  29.   Polynomials over GF(2) are represented in binary, one bit per coefficient,
  30.   with the lowest powers in the most significant bit.  Then adding polynomials
  31.   is just exclusive-or, and multiplying a polynomial by x is a right shift by
  32.   one.  If we call the above polynomial p, and represent a byte as the
  33.   polynomial q, also with the lowest power in the most significant bit (so the
  34.   byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
  35.   where a mod b means the remainder after dividing a by b.
  37.   This calculation is done using the shift-register method of multiplying and
  38.   taking the remainder.  The register is initialized to zero, and for each
  39.   incoming bit, x^32 is added mod p to the register if the bit is a one (where
  40.   x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
  41.   x (which is shifting right by one and adding x^32 mod p if the bit shifted
  42.   out is a one).  We start with the highest power (least significant bit) of
  43.   q and repeat for all eight bits of q.
  45.   The table is simply the CRC of all possible eight bit values.  This is all
  46.   the information needed to generate CRC's on data a byte at a time for all
  47.   combinations of CRC register values and incoming bytes.
  48. */
  49. static void MakeCRCTable()
  50. {
  51.   CRC_UINT32 CRC;
  52.   CRC_UINT32 n, k;
  53.   CRC_UINT32 poly;            /* polynomial exclusive-or pattern */
  54.   /* terms of polynomial defining this crc (except x^32): */
  55.   static const CRC_BYTE p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26};
  57.   /* make exclusive-or pattern from polynomial (0xedb88320L) */
  58.   poly = 0L;
  59.   for (n = 0; n < sizeof(p) / sizeof(CRC_BYTE); n++)
  60.     poly |= 1L << (31 - p[n]);
  61.  
  62.   for (n = 0; n < 256; n++)
  63.   {
  64.     CRC = n;
  65.     for (k = 0; k < 8; k++)
  66.     {
  67.         if (CRC & 1)
  68.             CRC = poly ^ (CRC >> 1);
  69.         else
  70.             CRC = CRC >> 1;
  71.     }
  72.     CRC_Table[n] = CRC;
  73.   }
  74.   CRCTableEmptyFlag = 0;
  75. }
  76. #else
  78. // ========================================================================
  79. // Table of CRC-32's of all single-byte values (made by make_crc_table)
  80. //
  82. static const CRC_UINT32 CRC_Table[256] = {
  83.   0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  84.   0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  85.   0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  86.   0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  87.   0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  88.   0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  89.   0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  90.   0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  91.   0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  92.   0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  93.   0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  94.   0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  95.   0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  96.   0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  97.   0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  98.   0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  99.   0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  100.   0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  101.   0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  102.   0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  103.   0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  104.   0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  105.   0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  106.   0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  107.   0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  108.   0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  109.   0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  110.   0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  111.   0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  112.   0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  113.   0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  114.   0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  115.   0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  116.   0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  117.   0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  118.   0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  119.   0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  120.   0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  121.   0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  122.   0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  123.   0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  124.   0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  125.   0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  126.   0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  127.   0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  128.   0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  129.   0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  130.   0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  131.   0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  132.   0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  133.   0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  134.   0x2d02ef8dL
  135. };
  136. #endif  // DYNAMIC_CRC_TABLE
  138. // =========================================================================
  139. // This function can be used by asm versions of crc32()
  140. //
  141. const CRC_UINT32 * GetCRCTable()
  142. {
  143. #ifdef DYNAMIC_CRC_TABLE
  144.   if (CRCTableEmptyFlag) 
  145.       MakeCRCTable();
  146. #endif
  148.   return (const CRC_UINT32 *)CRC_Table;
  149. }
  153. // Use internal CRC32 function
  154. // =========================================================================
  155. #define DO1BYTE(pBuf) CRC = CRC_Table[(CRC ^ (*pBuf++)) & 0xff] ^ (CRC >> 8);
  156. //#define DO2(pBuf)  DO1(pBuf); DO1(pBuf);
  157. //#define DO4(pBuf)  DO2(pBuf); DO2(pBuf);
  158. //#define DO8(pBuf)  DO4(pBuf); DO4(pBuf);
  159. // =========================================================================
  161. unsigned CRC32_C(unsigned CRC, const void *pvBuf, int nLen)
  162. //unsigned CRC32(unsigned CRC, const void *pvBuf, int nLen)
  163. {
  164.     const CRC_BYTE *pBuf = pvBuf;
  166.     if (pvBuf == (void *)0)
  167.         return 0L;
  169.     #ifdef DYNAMIC_CRC_TABLE
  170.     if (CRCTableEmptyFlag)
  171.         MakeCRCTable();
  172.     #endif  // DYNAMIC_CRC_TABLE
  174.     CRC = CRC ^ 0xffffffffL;    // equal CRC = ~CRC
  175.     while (nLen >= 8)
  176.     {
  177.         // It's easy to debug
  178.         DO1BYTE(pBuf);          // 0
  179.         DO1BYTE(pBuf);          // 1
  180.         DO1BYTE(pBuf);          // 2
  181.         DO1BYTE(pBuf);          // 3
  182.         DO1BYTE(pBuf);          // 4
  183.         DO1BYTE(pBuf);          // 5
  184.         DO1BYTE(pBuf);          // 6
  185.         DO1BYTE(pBuf);          // 7
  187.         nLen -= 8;
  188.     }
  189.     if (nLen)
  190.     {
  191.         do {
  192.             DO1BYTE(pBuf);
  193.         } while (--nLen);
  194.     }
  195.     return (CRC ^ 0xffffffffL);   // equal return ~CRC
  196. }
  198. // ============================================================================
  199. //
  200. // ASM Part in Visual C++
  201. //
  202. // ============================================================================
  204. //#define DO1BYTE(pBuf) CRC = CRC_Table[(CRC ^ (*pBuf++)) & 0xff] ^ (CRC >> 8);
  205. #define DO1BYTEASM() 
  206.     __asm{ mov bl, [esi] } 
  207.     __asm{ inc esi } 
  208.     __asm{ xor ebx, eax } 
  209.     __asm{ shr eax, 8 } 
  210.     __asm{ and ebx, 0xff } 
  211.     __asm{ xor eax, CRC_Table[ebx * 4] }
  214. //unsigned CRC32_ASM(unsigned CRC, const void *pvBuf, int nLen)
  215. unsigned CRC32(unsigned CRC, const void *pvBuf, int nLen)
  216. {
  217.     unsigned RetCode = 0;
  219.     if (!pvBuf)
  220.         return RetCode;
  222.     __asm mov esi, [pvBuf]
  223.     __asm mov ecx, [nLen]
  224.     __asm mov eax, [CRC]
  225.     __asm shr ecx, 3
  226.     __asm xor eax, 0xffffffff
  228.     __asm test ecx, ecx
  229.     __asm jz CRC_Last7Bytes
  230.     
  231.     __asm push ebp
  232.     __asm mov ebp, ecx
  234.     __asm xor edx, edx
  235.     __asm xor ecx, ecx
  237.     __asm align 4
  239. CRC_Loop1:
  240.     // eax = CRC
  241.     // edx first TableIndex
  242.     // ecx second TableIndex
  244.     // Process 4 bytes
  245.     __asm mov ebx, [esi]
  246.     __asm add esi, 4
  247.     
  248.     __asm mov dl, bl
  249.     __asm mov cl, bh
  250.     __asm xor dl, al
  251.     __asm shr eax, 8
  252.     __asm mov edi, CRC_Table[edx * 4]
  253.     __asm shr ebx, 16
  254.     __asm xor eax, edi
  256.     __asm xor cl, al
  257.     __asm shr eax, 8
  258.     __asm mov edi, CRC_Table[ecx * 4]
  259.     __asm mov dl, bl
  260.     __asm xor eax, edi
  262.     __asm xor dl, al
  263.     __asm shr eax, 8
  264.     __asm mov edi, CRC_Table[edx * 4] 
  265.     __asm mov cl, bh
  266.     __asm xor eax, edi
  268.     __asm mov ebx, [esi]
  269.     __asm xor cl, al
  270.     __asm shr eax, 8
  271.     __asm mov edi, CRC_Table[ecx * 4]
  272.     __asm add esi, 4
  273.     __asm xor eax, edi
  274.     
  275.     __asm mov dl, bl
  276.     __asm mov cl, bh
  277.     __asm xor dl, al
  278.     __asm shr eax, 8
  279.     __asm mov edi, CRC_Table[edx * 4]
  280.     __asm shr ebx, 16
  281.     __asm xor eax, edi
  283.     __asm xor cl, al
  284.     __asm shr eax, 8
  285.     __asm mov edi, CRC_Table[ecx * 4]
  286.     __asm mov dl, bl
  287.     __asm xor eax, edi
  289.     __asm xor dl, al
  290.     __asm shr eax, 8
  291.     __asm mov edi, CRC_Table[edx * 4] 
  292.     __asm mov cl, bh
  293.     __asm xor eax, edi
  295.     __asm xor cl, al
  296.     __asm shr eax, 8
  297.     __asm xor eax, CRC_Table[ecx * 4]
  299.     __asm dec ebp
  300.     __asm jnz CRC_Loop1
  302.     __asm pop ebp
  304. CRC_Last7Bytes:
  306.     __asm mov ecx, [nLen]
  308.     __asm xor edx, edx
  309.     __asm and ecx, 0x7
  310.     __asm jz CRC_Exit
  312. CRC_Loop2:
  314.     __asm mov dl, [esi]
  315.     __asm inc esi
  316.     __asm xor dl, al
  317.     __asm shr eax, 8
  318.     __asm xor eax, CRC_Table[edx * 4]
  320.     __asm dec ecx
  321.     __asm jnz CRC_Loop2
  323. CRC_Exit:
  325.     __asm xor eax, 0xffffffff
  326.     __asm mov [RetCode], eax
  328.     return RetCode;
  329. }
  331. /*
  332. unsigned CRC32(unsigned CRC, const void *pvBuf, int nLen)
  333. {
  334.     unsigned RetCode = 0;
  336.     if (!pvBuf)
  337.         return RetCode;
  339.     __asm mov esi, [pvBuf]
  340.     __asm mov ecx, [nLen]
  341.     __asm mov eax, [CRC]
  342.     __asm shr ecx, 3
  343.     __asm xor eax, 0xffffffff
  345.     __asm test ecx, ecx
  346.     __asm jz CRC_Last7Bytes
  348. CRC_Loop1:
  349.     __asm xor edx, edx
  351.     // Process 4 bytes
  352.     __asm mov ebx, [esi]
  353.     __asm add esi, 4
  354.     
  355.     __asm mov dl, bl
  356.     __asm shr ebx, 8
  358.     __asm xor dl, al
  359.     __asm shr eax, 8
  360.     __asm mov edi, CRC_Table[edx * 4]
  361.     
  362.     __asm mov dl, bl
  363.     __asm xor eax, edi
  364.     
  365.     __asm shr ebx, 8
  366.     __asm xor dl, al
  367.     __asm shr eax, 8
  368.     __asm mov edi, CRC_Table[edx * 4]
  370.     __asm mov dl, bl
  371.     __asm xor eax, edi
  372.     
  373.     __asm shr ebx, 8
  374.     __asm xor dl, al
  375.     __asm shr eax, 8
  376.     __asm mov edi, CRC_Table[edx * 4]
  378.     __asm mov dl, bl
  379.     __asm xor eax, edi
  380.     
  381.     __asm xor dl, al
  382.     __asm shr eax, 8
  383.     __asm xor eax, CRC_Table[edx * 4]
  384.     
  386.     // Process 4 bytes
  387.     __asm mov ebx, [esi]
  388.     __asm add esi, 4
  389.     
  390.     __asm mov dl, bl
  391.     __asm shr ebx, 8
  393.     __asm xor dl, al
  394.     __asm shr eax, 8
  395.     __asm mov edi, CRC_Table[edx * 4]
  396.     
  397.     __asm mov dl, bl
  398.     __asm xor eax, edi
  399.     
  400.     __asm shr ebx, 8
  401.     __asm xor dl, al
  402.     __asm shr eax, 8
  403.     __asm mov edi, CRC_Table[edx * 4]
  405.     __asm mov dl, bl
  406.     __asm xor eax, edi
  407.     
  408.     __asm shr ebx, 8
  409.     __asm xor dl, al
  410.     __asm shr eax, 8
  411.     __asm mov edi, CRC_Table[edx * 4]
  413.     __asm mov dl, bl
  414.     __asm xor eax, edi
  415.     
  416.     __asm xor dl, al
  417.     __asm shr eax, 8
  418.     __asm xor eax, CRC_Table[edx * 4]
  420.     __asm dec ecx
  421.     __asm jnz CRC_Loop1
  423. CRC_Last7Bytes:
  425.     __asm mov ecx, [nLen]
  426.     __asm xor edx, edx
  427.     
  428.     __asm test ecx, 0x4
  429.     __asm jz CRC_Last3Bytes
  432.     // Process 4 bytes
  433.     __asm mov ebx, [esi]
  434.     __asm add esi, 4
  435.     
  436.     __asm mov dl, bl
  437.     __asm shr ebx, 8
  439.     __asm xor dl, al
  440.     __asm shr eax, 8
  441.     __asm mov edi, CRC_Table[edx * 4]
  442.     
  443.     __asm mov dl, bl
  444.     __asm xor eax, edi
  445.     
  446.     __asm shr ebx, 8
  447.     __asm xor dl, al
  448.     __asm shr eax, 8
  449.     __asm mov edi, CRC_Table[edx * 4]
  451.     __asm mov dl, bl
  452.     __asm xor eax, edi
  453.     
  454.     __asm shr ebx, 8
  455.     __asm xor dl, al
  456.     __asm shr eax, 8
  457.     __asm mov edi, CRC_Table[edx * 4]
  459.     __asm mov dl, bl
  460.     __asm xor eax, edi
  461.     
  462.     __asm xor dl, al
  463.     __asm shr eax, 8
  464.     __asm xor eax, CRC_Table[edx * 4]
  465.     
  466. CRC_Last3Bytes:
  468.     __asm xor edx, edx
  469.     __asm and ecx, 0x3
  470.     __asm jz CRC_Exit
  472. CRC_Loop2:
  474.     __asm mov dl, [esi]
  475.     __asm inc esi
  476.     __asm xor dl, al
  477.     __asm shr eax, 8
  478.     __asm xor eax, CRC_Table[edx * 4]
  480.     __asm dec ecx
  481.     __asm jnz CRC_Loop2
  483. CRC_Exit:
  485.     __asm xor eax, 0xffffffff
  486.     __asm mov [RetCode], eax
  488.     return RetCode;
  489. }
  490. */