├── Crc32.cpp ├── README.md ├── benchmark.txt └── crc32ctables.cc /Crc32.cpp: -------------------------------------------------------------------------------- 1 | // ////////////////////////////////////////////////////////// 2 | // Crc32.cpp 3 | // Copyright (c) 2011-2013 Stephan Brumme. All rights reserved. 4 | // see http://create.stephan-brumme.com/disclaimer.html 5 | // Slice-by-16 code added by Bulat Ziganshin 6 | 7 | // g++ -o Crc32 Crc32.cpp -O3 -march=native -mtune=native 8 | 9 | #include 10 | 11 | // define endianess and some integer data types 12 | #include 13 | #define __LITTLE_ENDIAN 1234 14 | #define __BIG_ENDIAN 4321 15 | #define __BYTE_ORDER __LITTLE_ENDIAN 16 | 17 | /// zlib's CRC32 polynomial 18 | const uint32_t Polynomial = 0xEDB88320; 19 | 20 | /// swap endianess 21 | static inline uint32_t swap(uint32_t x) 22 | { 23 | return (x >> 24) | 24 | ((x >> 8) & 0x0000FF00) | 25 | ((x << 8) & 0x00FF0000) | 26 | (x << 24); 27 | } 28 | 29 | /// forward declaration, table is at the end of this file 30 | uint32_t Crc32Lookup[16][256]; // extern is needed to keep compiler happey 31 | 32 | 33 | /// compute CRC32 (bitwise algorithm) 34 | uint32_t crc32_bitwise(const void* data, size_t length, uint32_t previousCrc32 = 0) 35 | { 36 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 37 | const uint8_t* current = (const uint8_t*) data; 38 | 39 | while (length-- > 0) 40 | { 41 | crc ^= *current++; 42 | 43 | for (int j = 0; j < 8; j++) 44 | { 45 | // branch-free, version 1 46 | //crc = (crc >> 1) ^ (crc & 1)*Polynomial; 47 | // branch-free, version 2 48 | crc = (crc >> 1) ^ (-int32_t(crc & 1) & Polynomial); 49 | 50 | // branching, much slower: 51 | //if (crc & 1) 52 | // crc = (crc >> 1) ^ Polynomial; 53 | //else 54 | // crc = crc >> 1; 55 | } 56 | } 57 | 58 | return ~crc; // same as crc ^ 0xFFFFFFFF 59 | } 60 | 61 | 62 | /// compute CRC32 (half-byte algoritm) 63 | uint32_t crc32_halfbyte(const void* data, size_t length, uint32_t previousCrc32 = 0) 64 | { 65 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 66 | const uint8_t* current = (const uint8_t*) data; 67 | 68 | /// look-up table for half-byte, same as crc32Lookup[0][16*i] 69 | static const uint32_t Crc32Lookup16[16] = 70 | { 71 | 0x00000000,0x1DB71064,0x3B6E20C8,0x26D930AC,0x76DC4190,0x6B6B51F4,0x4DB26158,0x5005713C, 72 | 0xEDB88320,0xF00F9344,0xD6D6A3E8,0xCB61B38C,0x9B64C2B0,0x86D3D2D4,0xA00AE278,0xBDBDF21C 73 | }; 74 | 75 | while (length-- > 0) 76 | { 77 | crc = Crc32Lookup16[(crc ^ *current ) & 0x0F] ^ (crc >> 4); 78 | crc = Crc32Lookup16[(crc ^ (*current >> 4)) & 0x0F] ^ (crc >> 4); 79 | current++; 80 | } 81 | 82 | return ~crc; // same as crc ^ 0xFFFFFFFF 83 | } 84 | 85 | 86 | /// compute CRC32 (standard algorithm) 87 | uint32_t crc32_1byte(const void* data, size_t length, uint32_t previousCrc32 = 0) 88 | { 89 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 90 | const uint8_t* current = (const uint8_t*) data; 91 | 92 | while (length-- > 0) 93 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *current++]; 94 | 95 | return ~crc; // same as crc ^ 0xFFFFFFFF 96 | } 97 | 98 | 99 | /// compute CRC32 (Slicing-by-4 algorithm) 100 | uint32_t crc32_4bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 101 | { 102 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 103 | const uint32_t* current = (const uint32_t*) data; 104 | 105 | // process four bytes at once (Slicing-by-4) 106 | while (length >= 4) 107 | { 108 | { 109 | #if __BYTE_ORDER == __BIG_ENDIAN 110 | uint32_t one = *current++ ^ swap(crc); 111 | crc = Crc32Lookup[0][ one & 0xFF] ^ 112 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 113 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 114 | Crc32Lookup[3][(one>>24) & 0xFF]; 115 | #else 116 | uint32_t one = *current++ ^ crc; 117 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 118 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 119 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 120 | Crc32Lookup[3][ one & 0xFF]; 121 | #endif 122 | 123 | } 124 | length -= 4; 125 | } 126 | 127 | const uint8_t* currentChar = (const uint8_t*) current; 128 | // remaining 1 to 3 bytes (standard algorithm) 129 | while (length-- > 0) 130 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 131 | 132 | return ~crc; // same as crc ^ 0xFFFFFFFF 133 | } 134 | 135 | 136 | /// compute CRC32 (Slicing-by-4 algorithm) 137 | uint32_t crc32_2x4bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 138 | { 139 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 140 | const uint32_t* current = (const uint32_t*) data; 141 | 142 | // process four bytes at once (Slicing-by-4) 143 | while (length >= 8) 144 | { 145 | { 146 | #if __BYTE_ORDER == __BIG_ENDIAN 147 | uint32_t one = *current++ ^ swap(crc); 148 | crc = Crc32Lookup[0][ one & 0xFF] ^ 149 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 150 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 151 | Crc32Lookup[3][(one>>24) & 0xFF]; 152 | #else 153 | uint32_t one = *current++ ^ crc; 154 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 155 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 156 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 157 | Crc32Lookup[3][ one & 0xFF]; 158 | #endif 159 | 160 | } 161 | { 162 | #if __BYTE_ORDER == __BIG_ENDIAN 163 | uint32_t one = *current++ ^ swap(crc); 164 | crc = Crc32Lookup[0][ one & 0xFF] ^ 165 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 166 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 167 | Crc32Lookup[3][(one>>24) & 0xFF]; 168 | #else 169 | uint32_t one = *current++ ^ crc; 170 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 171 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 172 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 173 | Crc32Lookup[3][ one & 0xFF]; 174 | #endif 175 | 176 | } 177 | length -= 8; 178 | } 179 | 180 | const uint8_t* currentChar = (const uint8_t*) current; 181 | // remaining 1 to 3 bytes (standard algorithm) 182 | while (length-- > 0) 183 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 184 | 185 | return ~crc; // same as crc ^ 0xFFFFFFFF 186 | } 187 | 188 | 189 | /// compute CRC32 (Slicing-by-4 algorithm) 190 | uint32_t crc32_4x4bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 191 | { 192 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 193 | const uint32_t* current = (const uint32_t*) data; 194 | 195 | // process four bytes at once (Slicing-by-4) 196 | while (length >= 16) 197 | { 198 | { 199 | #if __BYTE_ORDER == __BIG_ENDIAN 200 | uint32_t one = *current++ ^ swap(crc); 201 | crc = Crc32Lookup[0][ one & 0xFF] ^ 202 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 203 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 204 | Crc32Lookup[3][(one>>24) & 0xFF]; 205 | #else 206 | uint32_t one = *current++ ^ crc; 207 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 208 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 209 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 210 | Crc32Lookup[3][ one & 0xFF]; 211 | #endif 212 | 213 | } 214 | { 215 | #if __BYTE_ORDER == __BIG_ENDIAN 216 | uint32_t one = *current++ ^ swap(crc); 217 | crc = Crc32Lookup[0][ one & 0xFF] ^ 218 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 219 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 220 | Crc32Lookup[3][(one>>24) & 0xFF]; 221 | #else 222 | uint32_t one = *current++ ^ crc; 223 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 224 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 225 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 226 | Crc32Lookup[3][ one & 0xFF]; 227 | #endif 228 | 229 | } 230 | { 231 | #if __BYTE_ORDER == __BIG_ENDIAN 232 | uint32_t one = *current++ ^ swap(crc); 233 | crc = Crc32Lookup[0][ one & 0xFF] ^ 234 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 235 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 236 | Crc32Lookup[3][(one>>24) & 0xFF]; 237 | #else 238 | uint32_t one = *current++ ^ crc; 239 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 240 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 241 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 242 | Crc32Lookup[3][ one & 0xFF]; 243 | #endif 244 | 245 | } 246 | { 247 | #if __BYTE_ORDER == __BIG_ENDIAN 248 | uint32_t one = *current++ ^ swap(crc); 249 | crc = Crc32Lookup[0][ one & 0xFF] ^ 250 | Crc32Lookup[1][(one>> 8) & 0xFF] ^ 251 | Crc32Lookup[2][(one>>16) & 0xFF] ^ 252 | Crc32Lookup[3][(one>>24) & 0xFF]; 253 | #else 254 | uint32_t one = *current++ ^ crc; 255 | crc = Crc32Lookup[0][(one>>24) & 0xFF] ^ 256 | Crc32Lookup[1][(one>>16) & 0xFF] ^ 257 | Crc32Lookup[2][(one>> 8) & 0xFF] ^ 258 | Crc32Lookup[3][ one & 0xFF]; 259 | #endif 260 | 261 | } 262 | length -= 16; 263 | } 264 | 265 | const uint8_t* currentChar = (const uint8_t*) current; 266 | // remaining 1 to 3 bytes (standard algorithm) 267 | while (length-- > 0) 268 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 269 | 270 | return ~crc; // same as crc ^ 0xFFFFFFFF 271 | } 272 | 273 | 274 | /// compute CRC32 (Slicing-by-8 algorithm) /////////////////////////////////////////////////////////////////////////////////////////// 275 | uint32_t crc32_88bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 276 | { 277 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 278 | const uint32_t* current = (const uint32_t*) data; 279 | 280 | // process eight bytes at once (Slicing-by-8) 281 | while (length >= 16) 282 | { 283 | { 284 | uint32_t one = current[0] ^ crc; 285 | uint32_t two = current[1]; 286 | uint32_t a1 = Crc32Lookup[0][(two>>24) & 0xFF] ^ 287 | Crc32Lookup[1][(two>>16) & 0xFF]; 288 | uint32_t a2 = Crc32Lookup[2][(two>> 8) & 0xFF] ^ 289 | Crc32Lookup[3][ two & 0xFF]; 290 | uint32_t a3 = Crc32Lookup[4][(one>>24) & 0xFF] ^ 291 | Crc32Lookup[5][(one>>16) & 0xFF]; 292 | uint32_t a4 = Crc32Lookup[6][(one>> 8) & 0xFF] ^ 293 | Crc32Lookup[7][ one & 0xFF]; 294 | 295 | crc = (a1^a2)^(a3^a4); 296 | } 297 | uint32_t two = current[3]; 298 | uint32_t a1 = Crc32Lookup[0][(two>>24) & 0xFF] ^ 299 | Crc32Lookup[1][(two>>16) & 0xFF]; 300 | uint32_t a2 = Crc32Lookup[2][(two>> 8) & 0xFF] ^ 301 | Crc32Lookup[3][ two & 0xFF]; 302 | { 303 | uint32_t one = current[2] ^ crc; 304 | current += 4; 305 | uint32_t a3 = Crc32Lookup[4][(one>>24) & 0xFF] ^ 306 | Crc32Lookup[5][(one>>16) & 0xFF]; 307 | uint32_t a4 = Crc32Lookup[6][(one>> 8) & 0xFF] ^ 308 | Crc32Lookup[7][ one & 0xFF]; 309 | 310 | crc = (a1^a2)^(a3^a4); 311 | } 312 | 313 | length -= 16; 314 | } 315 | 316 | const uint8_t* currentChar = (const uint8_t*) current; 317 | // remaining 1 to 7 bytes (standard algorithm) 318 | while (length-- > 0) 319 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 320 | 321 | return ~crc; // same as crc ^ 0xFFFFFFFF 322 | } 323 | 324 | 325 | /// compute CRC32 (Slicing-by-8 algorithm) 326 | uint32_t crc32_8bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 327 | { 328 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 329 | const uint32_t* current = (const uint32_t*) data; 330 | 331 | // process eight bytes at once (Slicing-by-8) 332 | while (length >= 8) 333 | { 334 | #if __BYTE_ORDER == __BIG_ENDIAN 335 | uint32_t one = *current++ ^ swap(crc); 336 | uint32_t two = *current++; 337 | crc = Crc32Lookup[0][ two & 0xFF] ^ 338 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 339 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 340 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 341 | Crc32Lookup[4][ one & 0xFF] ^ 342 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 343 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 344 | Crc32Lookup[7][(one>>24) & 0xFF]; 345 | #else 346 | uint32_t one = *current++ ^ crc; 347 | uint32_t two = *current++; 348 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 349 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 350 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 351 | Crc32Lookup[3][ two & 0xFF] ^ 352 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 353 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 354 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 355 | Crc32Lookup[7][ one & 0xFF]; 356 | #endif 357 | 358 | length -= 8; 359 | } 360 | 361 | const uint8_t* currentChar = (const uint8_t*) current; 362 | // remaining 1 to 7 bytes (standard algorithm) 363 | while (length-- > 0) 364 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 365 | 366 | return ~crc; // same as crc ^ 0xFFFFFFFF 367 | } 368 | 369 | 370 | /// compute CRC32 (Slicing-by-8 algorithm) ////////////////////////////////////////////////////////////////////////////////////////// 371 | uint32_t crc32_16bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 372 | { 373 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 374 | const uint32_t* current = (const uint32_t*) data; 375 | 376 | // process eight bytes at once (Slicing-by-8) 377 | while (length >= 16) 378 | { 379 | uint32_t one = *current++ ^ crc; 380 | uint32_t two = *current++; 381 | uint32_t a3 = *current++; 382 | uint32_t a4 = *current++; 383 | crc = Crc32Lookup[ 0][( a4>>24) & 0xFF] ^ 384 | Crc32Lookup[ 1][( a4>>16) & 0xFF] ^ 385 | Crc32Lookup[ 2][( a4>> 8) & 0xFF] ^ 386 | Crc32Lookup[ 3][ a4 & 0xFF] ^ 387 | Crc32Lookup[ 4][( a3>>24) & 0xFF] ^ 388 | Crc32Lookup[ 5][( a3>>16) & 0xFF] ^ 389 | Crc32Lookup[ 6][( a3>> 8) & 0xFF] ^ 390 | Crc32Lookup[ 7][ a3 & 0xFF] ^ 391 | Crc32Lookup[ 8][(two>>24) & 0xFF] ^ 392 | Crc32Lookup[ 9][(two>>16) & 0xFF] ^ 393 | Crc32Lookup[10][(two>> 8) & 0xFF] ^ 394 | Crc32Lookup[11][ two & 0xFF] ^ 395 | Crc32Lookup[12][(one>>24) & 0xFF] ^ 396 | Crc32Lookup[13][(one>>16) & 0xFF] ^ 397 | Crc32Lookup[14][(one>> 8) & 0xFF] ^ 398 | Crc32Lookup[15][ one & 0xFF]; 399 | 400 | length -= 16; 401 | } 402 | 403 | const uint8_t* currentChar = (const uint8_t*) current; 404 | // remaining 1 to 7 bytes (standard algorithm) 405 | while (length-- > 0) 406 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 407 | 408 | return ~crc; // same as crc ^ 0xFFFFFFFF 409 | } 410 | 411 | 412 | /// compute CRC32 (Slicing-by-8 algorithm) ////////////////////////////////////////////////////////////////////////////////////////// 413 | uint32_t crc32_2x16bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 414 | { 415 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 416 | const uint32_t* current = (const uint32_t*) data; 417 | 418 | // process eight bytes at once (Slicing-by-8) 419 | while (length >= 32) 420 | { 421 | { 422 | uint32_t one = *current++ ^ crc; 423 | uint32_t two = *current++; 424 | uint32_t a3 = *current++; 425 | uint32_t a4 = *current++; 426 | crc = Crc32Lookup[ 0][( a4>>24) & 0xFF] ^ 427 | Crc32Lookup[ 1][( a4>>16) & 0xFF] ^ 428 | Crc32Lookup[ 2][( a4>> 8) & 0xFF] ^ 429 | Crc32Lookup[ 3][ a4 & 0xFF] ^ 430 | Crc32Lookup[ 4][( a3>>24) & 0xFF] ^ 431 | Crc32Lookup[ 5][( a3>>16) & 0xFF] ^ 432 | Crc32Lookup[ 6][( a3>> 8) & 0xFF] ^ 433 | Crc32Lookup[ 7][ a3 & 0xFF] ^ 434 | Crc32Lookup[ 8][(two>>24) & 0xFF] ^ 435 | Crc32Lookup[ 9][(two>>16) & 0xFF] ^ 436 | Crc32Lookup[10][(two>> 8) & 0xFF] ^ 437 | Crc32Lookup[11][ two & 0xFF] ^ 438 | Crc32Lookup[12][(one>>24) & 0xFF] ^ 439 | Crc32Lookup[13][(one>>16) & 0xFF] ^ 440 | Crc32Lookup[14][(one>> 8) & 0xFF] ^ 441 | Crc32Lookup[15][ one & 0xFF]; 442 | } 443 | { 444 | uint32_t one = *current++ ^ crc; 445 | uint32_t two = *current++; 446 | uint32_t a3 = *current++; 447 | uint32_t a4 = *current++; 448 | crc = Crc32Lookup[ 0][( a4>>24) & 0xFF] ^ 449 | Crc32Lookup[ 1][( a4>>16) & 0xFF] ^ 450 | Crc32Lookup[ 2][( a4>> 8) & 0xFF] ^ 451 | Crc32Lookup[ 3][ a4 & 0xFF] ^ 452 | Crc32Lookup[ 4][( a3>>24) & 0xFF] ^ 453 | Crc32Lookup[ 5][( a3>>16) & 0xFF] ^ 454 | Crc32Lookup[ 6][( a3>> 8) & 0xFF] ^ 455 | Crc32Lookup[ 7][ a3 & 0xFF] ^ 456 | Crc32Lookup[ 8][(two>>24) & 0xFF] ^ 457 | Crc32Lookup[ 9][(two>>16) & 0xFF] ^ 458 | Crc32Lookup[10][(two>> 8) & 0xFF] ^ 459 | Crc32Lookup[11][ two & 0xFF] ^ 460 | Crc32Lookup[12][(one>>24) & 0xFF] ^ 461 | Crc32Lookup[13][(one>>16) & 0xFF] ^ 462 | Crc32Lookup[14][(one>> 8) & 0xFF] ^ 463 | Crc32Lookup[15][ one & 0xFF]; 464 | } 465 | length -= 32; 466 | } 467 | 468 | const uint8_t* currentChar = (const uint8_t*) current; 469 | // remaining 1 to 7 bytes (standard algorithm) 470 | while (length-- > 0) 471 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 472 | 473 | return ~crc; // same as crc ^ 0xFFFFFFFF 474 | } 475 | 476 | 477 | /// compute CRC32 (Slicing-by-8 algorithm) 478 | uint32_t crc32_2x8bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 479 | { 480 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 481 | const uint32_t* current = (const uint32_t*) data; 482 | 483 | // process eight bytes at once (Slicing-by-8) 484 | while (length >= 16) 485 | { 486 | { 487 | #if __BYTE_ORDER == __BIG_ENDIAN 488 | uint32_t one = *current++ ^ swap(crc); 489 | uint32_t two = *current++; 490 | crc = Crc32Lookup[0][ two & 0xFF] ^ 491 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 492 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 493 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 494 | Crc32Lookup[4][ one & 0xFF] ^ 495 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 496 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 497 | Crc32Lookup[7][(one>>24) & 0xFF]; 498 | #else 499 | uint32_t one = *current++ ^ crc; 500 | uint32_t two = *current++; 501 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 502 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 503 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 504 | Crc32Lookup[3][ two & 0xFF] ^ 505 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 506 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 507 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 508 | Crc32Lookup[7][ one & 0xFF]; 509 | #endif 510 | } 511 | { 512 | #if __BYTE_ORDER == __BIG_ENDIAN 513 | uint32_t one = *current++ ^ swap(crc); 514 | uint32_t two = *current++; 515 | crc = Crc32Lookup[0][ two & 0xFF] ^ 516 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 517 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 518 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 519 | Crc32Lookup[4][ one & 0xFF] ^ 520 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 521 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 522 | Crc32Lookup[7][(one>>24) & 0xFF]; 523 | #else 524 | uint32_t one = *current++ ^ crc; 525 | uint32_t two = *current++; 526 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 527 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 528 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 529 | Crc32Lookup[3][ two & 0xFF] ^ 530 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 531 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 532 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 533 | Crc32Lookup[7][ one & 0xFF]; 534 | #endif 535 | } 536 | length -= 16; 537 | } 538 | 539 | const uint8_t* currentChar = (const uint8_t*) current; 540 | // remaining 1 to 7 bytes (standard algorithm) 541 | while (length-- > 0) 542 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 543 | 544 | return ~crc; // same as crc ^ 0xFFFFFFFF 545 | } 546 | 547 | 548 | /// compute CRC32 (Slicing-by-8 algorithm) 549 | uint32_t crc32_4x8bytes(const void* data, size_t length, uint32_t previousCrc32 = 0) 550 | { 551 | uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF 552 | const uint32_t* current = (const uint32_t*) data; 553 | 554 | // process eight bytes at once (Slicing-by-8) 555 | while (length >= 32) 556 | { 557 | { 558 | #if __BYTE_ORDER == __BIG_ENDIAN 559 | uint32_t one = *current++ ^ swap(crc); 560 | uint32_t two = *current++; 561 | crc = Crc32Lookup[0][ two & 0xFF] ^ 562 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 563 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 564 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 565 | Crc32Lookup[4][ one & 0xFF] ^ 566 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 567 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 568 | Crc32Lookup[7][(one>>24) & 0xFF]; 569 | #else 570 | uint32_t one = *current++ ^ crc; 571 | uint32_t two = *current++; 572 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 573 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 574 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 575 | Crc32Lookup[3][ two & 0xFF] ^ 576 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 577 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 578 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 579 | Crc32Lookup[7][ one & 0xFF]; 580 | #endif 581 | } 582 | { 583 | #if __BYTE_ORDER == __BIG_ENDIAN 584 | uint32_t one = *current++ ^ swap(crc); 585 | uint32_t two = *current++; 586 | crc = Crc32Lookup[0][ two & 0xFF] ^ 587 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 588 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 589 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 590 | Crc32Lookup[4][ one & 0xFF] ^ 591 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 592 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 593 | Crc32Lookup[7][(one>>24) & 0xFF]; 594 | #else 595 | uint32_t one = *current++ ^ crc; 596 | uint32_t two = *current++; 597 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 598 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 599 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 600 | Crc32Lookup[3][ two & 0xFF] ^ 601 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 602 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 603 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 604 | Crc32Lookup[7][ one & 0xFF]; 605 | #endif 606 | } 607 | { 608 | #if __BYTE_ORDER == __BIG_ENDIAN 609 | uint32_t one = *current++ ^ swap(crc); 610 | uint32_t two = *current++; 611 | crc = Crc32Lookup[0][ two & 0xFF] ^ 612 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 613 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 614 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 615 | Crc32Lookup[4][ one & 0xFF] ^ 616 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 617 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 618 | Crc32Lookup[7][(one>>24) & 0xFF]; 619 | #else 620 | uint32_t one = *current++ ^ crc; 621 | uint32_t two = *current++; 622 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 623 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 624 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 625 | Crc32Lookup[3][ two & 0xFF] ^ 626 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 627 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 628 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 629 | Crc32Lookup[7][ one & 0xFF]; 630 | #endif 631 | } 632 | { 633 | #if __BYTE_ORDER == __BIG_ENDIAN 634 | uint32_t one = *current++ ^ swap(crc); 635 | uint32_t two = *current++; 636 | crc = Crc32Lookup[0][ two & 0xFF] ^ 637 | Crc32Lookup[1][(two>> 8) & 0xFF] ^ 638 | Crc32Lookup[2][(two>>16) & 0xFF] ^ 639 | Crc32Lookup[3][(two>>24) & 0xFF] ^ 640 | Crc32Lookup[4][ one & 0xFF] ^ 641 | Crc32Lookup[5][(one>> 8) & 0xFF] ^ 642 | Crc32Lookup[6][(one>>16) & 0xFF] ^ 643 | Crc32Lookup[7][(one>>24) & 0xFF]; 644 | #else 645 | uint32_t one = *current++ ^ crc; 646 | uint32_t two = *current++; 647 | crc = Crc32Lookup[0][(two>>24) & 0xFF] ^ 648 | Crc32Lookup[1][(two>>16) & 0xFF] ^ 649 | Crc32Lookup[2][(two>> 8) & 0xFF] ^ 650 | Crc32Lookup[3][ two & 0xFF] ^ 651 | Crc32Lookup[4][(one>>24) & 0xFF] ^ 652 | Crc32Lookup[5][(one>>16) & 0xFF] ^ 653 | Crc32Lookup[6][(one>> 8) & 0xFF] ^ 654 | Crc32Lookup[7][ one & 0xFF]; 655 | #endif 656 | } 657 | length -= 32; 658 | } 659 | 660 | const uint8_t* currentChar = (const uint8_t*) current; 661 | // remaining 1 to 7 bytes (standard algorithm) 662 | while (length-- > 0) 663 | crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++]; 664 | 665 | return ~crc; // same as crc ^ 0xFFFFFFFF 666 | } 667 | 668 | #include "crc32ctables.cc" 669 | 670 | uint32_t crc32cSlicingBy4(const void* data, size_t length, uint32_t crc) { 671 | const char* p_buf = (const char*) data; 672 | 673 | // Handle leading misaligned bytes 674 | size_t initial_bytes = (sizeof(int32_t) - (intptr_t)p_buf) & (sizeof(int32_t) - 1); 675 | if (length < initial_bytes) initial_bytes = length; 676 | for (size_t li = 0; li < initial_bytes; li++) { 677 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 678 | } 679 | 680 | length -= initial_bytes; 681 | size_t running_length = length & ~(sizeof(int32_t) - 1); 682 | size_t end_bytes = length - running_length; 683 | 684 | for (size_t li = 0; li < running_length/4; li++) { 685 | { 686 | crc ^= *(uint32_t*) p_buf; 687 | p_buf += 4; 688 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 689 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 690 | uint32_t term2 = crc >> 16; 691 | crc = term1 ^ 692 | crc_tableil8_o40[term2 & 0x000000FF] ^ 693 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 694 | } 695 | } 696 | 697 | for (size_t li=0; li < end_bytes; li++) { 698 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 699 | } 700 | 701 | return crc; 702 | } 703 | 704 | 705 | uint32_t crc32cSlicingBy2x4(const void* data, size_t length, uint32_t crc) { 706 | const char* p_buf = (const char*) data; 707 | 708 | // Handle leading misaligned bytes 709 | size_t initial_bytes = (sizeof(int32_t) - (intptr_t)p_buf) & (sizeof(int32_t) - 1); 710 | if (length < initial_bytes) initial_bytes = length; 711 | for (size_t li = 0; li < initial_bytes; li++) { 712 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 713 | } 714 | 715 | length -= initial_bytes; 716 | size_t running_length = length & ~(sizeof(int32_t) - 1); 717 | size_t end_bytes = length - running_length; 718 | 719 | for (size_t li = 0; li < running_length/8; li++) { 720 | { 721 | crc ^= *(uint32_t*) p_buf; 722 | p_buf += 4; 723 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 724 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 725 | uint32_t term2 = crc >> 16; 726 | crc = term1 ^ 727 | crc_tableil8_o40[term2 & 0x000000FF] ^ 728 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 729 | } 730 | { 731 | crc ^= *(uint32_t*) p_buf; 732 | p_buf += 4; 733 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 734 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 735 | uint32_t term2 = crc >> 16; 736 | crc = term1 ^ 737 | crc_tableil8_o40[term2 & 0x000000FF] ^ 738 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 739 | } 740 | } 741 | 742 | for (size_t li=0; li < end_bytes; li++) { 743 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 744 | } 745 | 746 | return crc; 747 | } 748 | 749 | 750 | uint32_t crc32cSlicingBy4x4(const void* data, size_t length, uint32_t crc) { 751 | const char* p_buf = (const char*) data; 752 | 753 | // Handle leading misaligned bytes 754 | size_t initial_bytes = (sizeof(int32_t) - (intptr_t)p_buf) & (sizeof(int32_t) - 1); 755 | if (length < initial_bytes) initial_bytes = length; 756 | for (size_t li = 0; li < initial_bytes; li++) { 757 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 758 | } 759 | 760 | length -= initial_bytes; 761 | size_t running_length = length & ~(sizeof(int32_t) - 1); 762 | size_t end_bytes = length - running_length; 763 | 764 | for (size_t li = 0; li < running_length/16; li++) { 765 | { 766 | crc ^= *(uint32_t*) p_buf; 767 | p_buf += 4; 768 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 769 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 770 | uint32_t term2 = crc >> 16; 771 | crc = term1 ^ 772 | crc_tableil8_o40[term2 & 0x000000FF] ^ 773 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 774 | } 775 | { 776 | crc ^= *(uint32_t*) p_buf; 777 | p_buf += 4; 778 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 779 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 780 | uint32_t term2 = crc >> 16; 781 | crc = term1 ^ 782 | crc_tableil8_o40[term2 & 0x000000FF] ^ 783 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 784 | } 785 | { 786 | crc ^= *(uint32_t*) p_buf; 787 | p_buf += 4; 788 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 789 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 790 | uint32_t term2 = crc >> 16; 791 | crc = term1 ^ 792 | crc_tableil8_o40[term2 & 0x000000FF] ^ 793 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 794 | } 795 | { 796 | crc ^= *(uint32_t*) p_buf; 797 | p_buf += 4; 798 | uint32_t term1 = crc_tableil8_o56[crc & 0x000000FF] ^ 799 | crc_tableil8_o48[(crc >> 8) & 0x000000FF]; 800 | uint32_t term2 = crc >> 16; 801 | crc = term1 ^ 802 | crc_tableil8_o40[term2 & 0x000000FF] ^ 803 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 804 | } 805 | } 806 | 807 | for (size_t li=0; li < end_bytes; li++) { 808 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 809 | } 810 | 811 | return crc; 812 | } 813 | 814 | 815 | uint32_t crc32cSlicingBy8(const void* data, size_t length, uint32_t crc) { 816 | const char* p_buf = (const char*) data; 817 | 818 | // Handle leading misaligned bytes 819 | size_t initial_bytes = (sizeof(int32_t) - (intptr_t)p_buf) & (sizeof(int32_t) - 1); 820 | if (length < initial_bytes) initial_bytes = length; 821 | for (size_t li = 0; li < initial_bytes; li++) { 822 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 823 | } 824 | 825 | length -= initial_bytes; 826 | size_t running_length = length & ~(sizeof(uint64_t) - 1); 827 | size_t end_bytes = length - running_length; 828 | 829 | for (size_t li = 0; li < running_length/8; li++) { 830 | { 831 | crc ^= *(uint32_t*) p_buf; 832 | p_buf += 4; 833 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 834 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 835 | uint32_t term2 = crc >> 16; 836 | crc = term1 ^ 837 | crc_tableil8_o72[term2 & 0x000000FF] ^ 838 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 839 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 840 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 841 | 842 | term2 = (*(uint32_t *)p_buf) >> 16; 843 | crc = crc ^ term1 ^ 844 | crc_tableil8_o40[term2 & 0x000000FF] ^ 845 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 846 | p_buf += 4; 847 | } 848 | } 849 | 850 | for (size_t li=0; li < end_bytes; li++) { 851 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 852 | } 853 | 854 | return crc; 855 | } 856 | 857 | uint32_t crc32cSlicingBy16(const void* data, size_t length, uint32_t crc) { 858 | const char* p_buf = (const char*) data; 859 | 860 | // Handle leading misaligned bytes 861 | size_t initial_bytes = (sizeof(int32_t) - (intptr_t)p_buf) & (sizeof(int32_t) - 1); 862 | if (length < initial_bytes) initial_bytes = length; 863 | for (size_t li = 0; li < initial_bytes; li++) { 864 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 865 | } 866 | 867 | length -= initial_bytes; 868 | size_t running_length = length & ~(sizeof(uint64_t) - 1); 869 | size_t end_bytes = length - running_length; 870 | 871 | for (size_t li = 0; li < running_length/16; li++) { 872 | { 873 | crc ^= *(uint32_t*) p_buf; 874 | p_buf += 4; 875 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 876 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 877 | uint32_t term2 = crc >> 16; 878 | crc = term1 ^ 879 | crc_tableil8_o72[term2 & 0x000000FF] ^ 880 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 881 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 882 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 883 | 884 | term2 = (*(uint32_t *)p_buf) >> 16; 885 | crc = crc ^ term1 ^ 886 | crc_tableil8_o40[term2 & 0x000000FF] ^ 887 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 888 | p_buf += 4; 889 | } 890 | { 891 | crc ^= *(uint32_t*) p_buf; 892 | p_buf += 4; 893 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 894 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 895 | uint32_t term2 = crc >> 16; 896 | crc = term1 ^ 897 | crc_tableil8_o72[term2 & 0x000000FF] ^ 898 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 899 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 900 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 901 | 902 | term2 = (*(uint32_t *)p_buf) >> 16; 903 | crc = crc ^ term1 ^ 904 | crc_tableil8_o40[term2 & 0x000000FF] ^ 905 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 906 | p_buf += 4; 907 | } 908 | } 909 | 910 | for (size_t li=0; li < end_bytes; li++) { 911 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 912 | } 913 | 914 | return crc; 915 | } 916 | 917 | uint32_t crc32cSlicingBy32(const void* data, size_t length, uint32_t crc) { 918 | const char* p_buf = (const char*) data; 919 | 920 | // Handle leading misaligned bytes 921 | size_t initial_bytes = (sizeof(int32_t) - (intptr_t)p_buf) & (sizeof(int32_t) - 1); 922 | if (length < initial_bytes) initial_bytes = length; 923 | for (size_t li = 0; li < initial_bytes; li++) { 924 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 925 | } 926 | 927 | length -= initial_bytes; 928 | size_t running_length = length & ~(sizeof(uint64_t) - 1); 929 | size_t end_bytes = length - running_length; 930 | 931 | for (size_t li = 0; li < running_length/32; li++) { 932 | { 933 | crc ^= *(uint32_t*) p_buf; 934 | p_buf += 4; 935 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 936 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 937 | uint32_t term2 = crc >> 16; 938 | crc = term1 ^ 939 | crc_tableil8_o72[term2 & 0x000000FF] ^ 940 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 941 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 942 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 943 | 944 | term2 = (*(uint32_t *)p_buf) >> 16; 945 | crc = crc ^ term1 ^ 946 | crc_tableil8_o40[term2 & 0x000000FF] ^ 947 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 948 | p_buf += 4; 949 | } 950 | { 951 | crc ^= *(uint32_t*) p_buf; 952 | p_buf += 4; 953 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 954 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 955 | uint32_t term2 = crc >> 16; 956 | crc = term1 ^ 957 | crc_tableil8_o72[term2 & 0x000000FF] ^ 958 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 959 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 960 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 961 | 962 | term2 = (*(uint32_t *)p_buf) >> 16; 963 | crc = crc ^ term1 ^ 964 | crc_tableil8_o40[term2 & 0x000000FF] ^ 965 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 966 | p_buf += 4; 967 | } 968 | { 969 | crc ^= *(uint32_t*) p_buf; 970 | p_buf += 4; 971 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 972 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 973 | uint32_t term2 = crc >> 16; 974 | crc = term1 ^ 975 | crc_tableil8_o72[term2 & 0x000000FF] ^ 976 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 977 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 978 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 979 | 980 | term2 = (*(uint32_t *)p_buf) >> 16; 981 | crc = crc ^ term1 ^ 982 | crc_tableil8_o40[term2 & 0x000000FF] ^ 983 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 984 | p_buf += 4; 985 | } 986 | { 987 | crc ^= *(uint32_t*) p_buf; 988 | p_buf += 4; 989 | uint32_t term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 990 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 991 | uint32_t term2 = crc >> 16; 992 | crc = term1 ^ 993 | crc_tableil8_o72[term2 & 0x000000FF] ^ 994 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 995 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 996 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 997 | 998 | term2 = (*(uint32_t *)p_buf) >> 16; 999 | crc = crc ^ term1 ^ 1000 | crc_tableil8_o40[term2 & 0x000000FF] ^ 1001 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 1002 | p_buf += 4; 1003 | } 1004 | } 1005 | 1006 | for (size_t li=0; li < end_bytes; li++) { 1007 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 1008 | } 1009 | 1010 | return crc; 1011 | } 1012 | 1013 | // ////////////////////////////////////////////////////////// 1014 | // constants 1015 | 1016 | void init() 1017 | { 1018 | // same algorithm as crc32_bitwise 1019 | for (int i = 0; i <= 0xFF; i++) 1020 | { 1021 | uint32_t crc = i; 1022 | for (int j = 0; j < 8; j++) 1023 | crc = (crc >> 1) ^ ((crc & 1) * Polynomial); 1024 | Crc32Lookup[0][i] = crc; 1025 | } 1026 | // ... and the following slicing-by-8 algorithm (from Intel): 1027 | // http://www.intel.com/technology/comms/perfnet/download/CRC_generators.pdf 1028 | // http://sourceforge.net/projects/slicing-by-8/ 1029 | for (int i = 0; i <= 0xFF; i++) 1030 | { 1031 | for (int j=0; j<15; j++) 1032 | Crc32Lookup[j+1][i] = (Crc32Lookup[j][i] >> 8) ^ Crc32Lookup[0][Crc32Lookup[j][i] & 0xFF]; 1033 | } 1034 | } 1035 | 1036 | // ////////////////////////////////////////////////////////// 1037 | // test code 1038 | 1039 | 1040 | /// one gigabyte 1041 | const size_t NumBytes = 1024*1024*1024; 1042 | /// 4k chunks during last test 1043 | const size_t DefaultChunkSize = 4*1024; 1044 | 1045 | 1046 | #include 1047 | #include 1048 | #ifdef _MSC_VER 1049 | #include 1050 | #endif 1051 | 1052 | // timing 1053 | static double seconds() 1054 | { 1055 | #ifdef _MSC_VER 1056 | LARGE_INTEGER frequency, now; 1057 | QueryPerformanceFrequency(&frequency); 1058 | QueryPerformanceCounter (&now); 1059 | return now.QuadPart / double(frequency.QuadPart); 1060 | #else 1061 | return clock() / double(CLOCKS_PER_SEC); 1062 | #endif 1063 | } 1064 | 1065 | 1066 | int main(int, char**) 1067 | { 1068 | printf("Please wait ...\n"); 1069 | init(); 1070 | 1071 | // initialize 1072 | char* data = new char[NumBytes]; 1073 | for (size_t i = 0; i < NumBytes; i++) 1074 | data[i] = char(i & 0xFF); 1075 | 1076 | // re-use variables 1077 | double startTime, duration; 1078 | uint32_t crc; 1079 | /* 1080 | // bitwise 1081 | startTime = seconds(); 1082 | crc = crc32_bitwise(data, NumBytes); 1083 | duration = seconds() - startTime; 1084 | printf("bitwise : CRC=%08X, %.3fs, %.3f MB/s\n", 1085 | crc, duration, (NumBytes / (1024*1024)) / duration); 1086 | 1087 | // half-byte 1088 | startTime = seconds(); 1089 | crc = crc32_halfbyte(data, NumBytes); 1090 | duration = seconds() - startTime; 1091 | printf("half-byte : CRC=%08X, %.3fs, %.3f MB/s\n", 1092 | crc, duration, (NumBytes / (1024*1024)) / duration); 1093 | */ 1094 | // eight bytes at once 1095 | startTime = seconds(); 1096 | crc = crc32_88bytes(data, NumBytes); 1097 | duration = seconds() - startTime; 1098 | printf(" 88 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1099 | crc, duration, (NumBytes / (1024*1024)) / duration); 1100 | 1101 | // one byte at once 1102 | startTime = seconds(); 1103 | crc = crc32_1byte(data, NumBytes); 1104 | duration = seconds() - startTime; 1105 | printf(" 1 byte at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1106 | crc, duration, (NumBytes / (1024*1024)) / duration); 1107 | 1108 | // four bytes at once 1109 | startTime = seconds(); 1110 | crc = crc32cSlicingBy4(data, NumBytes, 0); 1111 | duration = seconds() - startTime; 1112 | printf("+ 4 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1113 | crc, duration, (NumBytes / (1024*1024)) / duration); 1114 | 1115 | // four bytes at once 1116 | startTime = seconds(); 1117 | crc = crc32cSlicingBy2x4(data, NumBytes, 0); 1118 | duration = seconds() - startTime; 1119 | printf("+2*4 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1120 | crc, duration, (NumBytes / (1024*1024)) / duration); 1121 | 1122 | // four bytes at once 1123 | startTime = seconds(); 1124 | crc = crc32cSlicingBy4x4(data, NumBytes, 0); 1125 | duration = seconds() - startTime; 1126 | printf("+4*4 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1127 | crc, duration, (NumBytes / (1024*1024)) / duration); 1128 | 1129 | // four bytes at once 1130 | startTime = seconds(); 1131 | crc = crc32cSlicingBy8(data, NumBytes, 0); 1132 | duration = seconds() - startTime; 1133 | printf("+ 8 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1134 | crc, duration, (NumBytes / (1024*1024)) / duration); 1135 | 1136 | // four bytes at once 1137 | startTime = seconds(); 1138 | crc = crc32cSlicingBy16(data, NumBytes, 0); 1139 | duration = seconds() - startTime; 1140 | printf("+2*8 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1141 | crc, duration, (NumBytes / (1024*1024)) / duration); 1142 | 1143 | // four bytes at once 1144 | startTime = seconds(); 1145 | crc = crc32cSlicingBy32(data, NumBytes, 0); 1146 | duration = seconds() - startTime; 1147 | printf("+4*8 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1148 | crc, duration, (NumBytes / (1024*1024)) / duration); 1149 | 1150 | // four bytes at once 1151 | startTime = seconds(); 1152 | crc = crc32_4bytes(data, NumBytes); 1153 | duration = seconds() - startTime; 1154 | printf(" 4 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1155 | crc, duration, (NumBytes / (1024*1024)) / duration); 1156 | 1157 | // four bytes at once 1158 | startTime = seconds(); 1159 | crc = crc32_2x4bytes(data, NumBytes); 1160 | duration = seconds() - startTime; 1161 | printf("2*4 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1162 | crc, duration, (NumBytes / (1024*1024)) / duration); 1163 | 1164 | // four bytes at once 1165 | startTime = seconds(); 1166 | crc = crc32_4x4bytes(data, NumBytes); 1167 | duration = seconds() - startTime; 1168 | printf("4*4 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1169 | crc, duration, (NumBytes / (1024*1024)) / duration); 1170 | 1171 | // eight bytes at once 1172 | startTime = seconds(); 1173 | crc = crc32_8bytes(data, NumBytes); 1174 | duration = seconds() - startTime; 1175 | printf(" 8 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1176 | crc, duration, (NumBytes / (1024*1024)) / duration); 1177 | 1178 | // eight bytes at once 1179 | startTime = seconds(); 1180 | crc = crc32_16bytes(data, NumBytes); 1181 | duration = seconds() - startTime; 1182 | printf(" 16 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1183 | crc, duration, (NumBytes / (1024*1024)) / duration); 1184 | 1185 | // eight bytes at once 1186 | startTime = seconds(); 1187 | crc = crc32_2x16bytes(data, NumBytes); 1188 | duration = seconds() - startTime; 1189 | printf("2*16 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1190 | crc, duration, (NumBytes / (1024*1024)) / duration); 1191 | 1192 | // eight bytes at once 1193 | startTime = seconds(); 1194 | crc = crc32_2x8bytes(data, NumBytes); 1195 | duration = seconds() - startTime; 1196 | printf("2*8 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1197 | crc, duration, (NumBytes / (1024*1024)) / duration); 1198 | 1199 | // eight bytes at once 1200 | startTime = seconds(); 1201 | crc = crc32_4x8bytes(data, NumBytes); 1202 | duration = seconds() - startTime; 1203 | printf("4*8 bytes at once: CRC=%08X, %.3fs, %.3f MB/s\n", 1204 | crc, duration, (NumBytes / (1024*1024)) / duration); 1205 | 1206 | // eight bytes at once, process in 4k chunks 1207 | startTime = seconds(); 1208 | crc = 0; // also default parameter of crc32_xx functions 1209 | size_t bytesProcessed = 0; 1210 | while (bytesProcessed < NumBytes) 1211 | { 1212 | size_t bytesLeft = NumBytes - bytesProcessed; 1213 | size_t chunkSize = (DefaultChunkSize < bytesLeft) ? DefaultChunkSize : bytesLeft; 1214 | 1215 | crc = crc32_8bytes(data, chunkSize, crc); 1216 | 1217 | bytesProcessed += chunkSize; 1218 | } 1219 | duration = seconds() - startTime; 1220 | printf("chunked : CRC=%08X, %.3fs, %.3f MB/s\n", 1221 | crc, duration, (NumBytes / (1024*1024)) / duration); 1222 | 1223 | delete[] data; 1224 | return 0; 1225 | } 1226 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Slice-by-16*2 and gcc 4.9.2 x64 allows to reach speed of 1 byte/cycle. A few most interestong results: 2 | ``` 3 | C:\Testing\Crc32>Crc32_vc2013_x64.exe 4 | 8 bytes at once: CRC=00EE2DAA, 0.590s, 1736.712 MB/s 5 | 16 bytes at once: CRC=00EE2DAA, 0.419s, 2441.144 MB/s 6 | 7 | C:\Testing\Crc32>Crc32_gcc492_x64.exe 8 | 8 bytes at once: CRC=00EE2DAA, 0.541s, 1892.791 MB/s 9 | 16 bytes at once: CRC=00EE2DAA, 0.303s, 3379.538 MB/s 10 | 2*16 bytes at once: CRC=00EE2DAA, 0.273s, 3750.916 MB/s 11 | ``` 12 | See full tests in the benchmark.txt 13 | 14 | Also incorporated to http://create.stephan-brumme.com/crc32/ 15 | -------------------------------------------------------------------------------- /benchmark.txt: -------------------------------------------------------------------------------- 1 | C:\Testing\Crc32>benchmark.cmd 2 | 3 | C:\Testing\Crc32>Crc32_vc2013_x64.exe 4 | Please wait ... 5 | 88 bytes at once: CRC=00EE2DAA, 0.535s, 1912.348 MB/s 6 | 1 byte at once: CRC=00EE2DAA, 2.036s, 503.055 MB/s 7 | + 4 bytes at once: CRC=17560371, 0.887s, 1154.272 MB/s 8 | +2*4 bytes at once: CRC=17560371, 0.870s, 1177.518 MB/s 9 | +4*4 bytes at once: CRC=17560371, 0.923s, 1109.023 MB/s 10 | + 8 bytes at once: CRC=17560371, 0.529s, 1937.230 MB/s 11 | +2*8 bytes at once: CRC=17560371, 0.500s, 2049.615 MB/s 12 | +4*8 bytes at once: CRC=17560371, 0.460s, 2226.977 MB/s 13 | 4 bytes at once: CRC=00EE2DAA, 0.889s, 1151.639 MB/s 14 | 2*4 bytes at once: CRC=00EE2DAA, 0.863s, 1186.265 MB/s 15 | 4*4 bytes at once: CRC=00EE2DAA, 0.878s, 1165.674 MB/s 16 | 8 bytes at once: CRC=00EE2DAA, 0.591s, 1733.887 MB/s 17 | 16 bytes at once: CRC=00EE2DAA, 0.436s, 2349.154 MB/s 18 | 2*16 bytes at once: CRC=00EE2DAA, 0.432s, 2371.657 MB/s 19 | 2*8 bytes at once: CRC=00EE2DAA, 0.602s, 1700.503 MB/s 20 | 4*8 bytes at once: CRC=00EE2DAA, 0.594s, 1725.200 MB/s 21 | chunked : CRC=00EE2DAA, 0.588s, 1741.428 MB/s 22 | 23 | C:\Testing\Crc32>Crc32_vc2013_x86.exe 24 | Please wait ... 25 | 88 bytes at once: CRC=00EE2DAA, 0.562s, 1820.504 MB/s 26 | 1 byte at once: CRC=00EE2DAA, 2.075s, 493.556 MB/s 27 | + 4 bytes at once: CRC=17560371, 1.045s, 979.657 MB/s 28 | +2*4 bytes at once: CRC=17560371, 1.085s, 944.044 MB/s 29 | +4*4 bytes at once: CRC=17560371, 1.155s, 886.648 MB/s 30 | + 8 bytes at once: CRC=17560371, 0.517s, 1982.498 MB/s 31 | +2*8 bytes at once: CRC=17560371, 0.518s, 1978.612 MB/s 32 | +4*8 bytes at once: CRC=17560371, 0.570s, 1796.303 MB/s 33 | 4 bytes at once: CRC=00EE2DAA, 0.921s, 1112.061 MB/s 34 | 2*4 bytes at once: CRC=00EE2DAA, 0.913s, 1121.325 MB/s 35 | 4*4 bytes at once: CRC=00EE2DAA, 0.929s, 1101.724 MB/s 36 | 8 bytes at once: CRC=00EE2DAA, 0.515s, 1987.816 MB/s 37 | 16 bytes at once: CRC=00EE2DAA, 0.423s, 2421.350 MB/s 38 | 2*16 bytes at once: CRC=00EE2DAA, 0.432s, 2369.345 MB/s 39 | 2*8 bytes at once: CRC=00EE2DAA, 0.609s, 1680.462 MB/s 40 | 4*8 bytes at once: CRC=00EE2DAA, 0.633s, 1618.188 MB/s 41 | chunked : CRC=00EE2DAA, 0.509s, 2010.500 MB/s 42 | 43 | C:\Testing\Crc32>Crc32_gcc492_x64.exe 44 | Please wait ... 45 | 88 bytes at once: CRC=00EE2DAA, 0.407s, 2515.971 MB/s 46 | 1 byte at once: CRC=00EE2DAA, 2.285s, 448.140 MB/s 47 | + 4 bytes at once: CRC=17560371, 0.853s, 1200.469 MB/s 48 | +2*4 bytes at once: CRC=17560371, 0.820s, 1248.780 MB/s 49 | +4*4 bytes at once: CRC=17560371, 0.815s, 1256.442 MB/s 50 | + 8 bytes at once: CRC=17560371, 0.534s, 1917.603 MB/s 51 | +2*8 bytes at once: CRC=17560371, 0.543s, 1885.820 MB/s 52 | +4*8 bytes at once: CRC=17560371, 0.444s, 2306.306 MB/s 53 | 4 bytes at once: CRC=00EE2DAA, 0.826s, 1239.709 MB/s 54 | 2*4 bytes at once: CRC=00EE2DAA, 0.832s, 1230.769 MB/s 55 | 4*4 bytes at once: CRC=00EE2DAA, 0.793s, 1291.299 MB/s 56 | 8 bytes at once: CRC=00EE2DAA, 0.548s, 1868.613 MB/s 57 | 16 bytes at once: CRC=00EE2DAA, 0.322s, 3180.124 MB/s 58 | 2*16 bytes at once: CRC=00EE2DAA, 0.273s, 3750.916 MB/s 59 | 2*8 bytes at once: CRC=00EE2DAA, 0.402s, 2547.264 MB/s 60 | 4*8 bytes at once: CRC=00EE2DAA, 0.405s, 2528.395 MB/s 61 | chunked : CRC=00EE2DAA, 0.531s, 1928.437 MB/s 62 | 63 | C:\Testing\Crc32>Crc32_gcc492_x86.exe 64 | Please wait ... 65 | 88 bytes at once: CRC=00EE2DAA, 0.427s, 2398.126 MB/s 66 | 1 byte at once: CRC=00EE2DAA, 2.286s, 447.944 MB/s 67 | + 4 bytes at once: CRC=17560371, 0.871s, 1175.660 MB/s 68 | +2*4 bytes at once: CRC=17560371, 0.853s, 1200.469 MB/s 69 | +4*4 bytes at once: CRC=17560371, 0.816s, 1254.902 MB/s 70 | + 8 bytes at once: CRC=17560371, 0.537s, 1906.890 MB/s 71 | +2*8 bytes at once: CRC=17560371, 0.436s, 2348.624 MB/s 72 | +4*8 bytes at once: CRC=17560371, 0.436s, 2348.624 MB/s 73 | 4 bytes at once: CRC=00EE2DAA, 0.885s, 1157.062 MB/s 74 | 2*4 bytes at once: CRC=00EE2DAA, 0.806s, 1270.471 MB/s 75 | 4*4 bytes at once: CRC=00EE2DAA, 0.781s, 1311.140 MB/s 76 | 8 bytes at once: CRC=00EE2DAA, 0.566s, 1809.187 MB/s 77 | 16 bytes at once: CRC=00EE2DAA, 0.304s, 3368.421 MB/s 78 | 2*16 bytes at once: CRC=00EE2DAA, 0.343s, 2985.423 MB/s 79 | 2*8 bytes at once: CRC=00EE2DAA, 0.399s, 2566.416 MB/s 80 | 4*8 bytes at once: CRC=00EE2DAA, 0.411s, 2491.484 MB/s 81 | chunked : CRC=00EE2DAA, 0.569s, 1799.649 MB/s 82 | 83 | C:\Testing\Crc32>Crc32_gcc345.exe 84 | Please wait ... 85 | 88 bytes at once: CRC=00EE2DAA, 0.455s, 2250.549 MB/s 86 | 1 byte at once: CRC=00EE2DAA, 2.305s, 444.252 MB/s 87 | + 4 bytes at once: CRC=17560371, 0.849s, 1206.125 MB/s 88 | +2*4 bytes at once: CRC=17560371, 0.860s, 1190.698 MB/s 89 | +4*4 bytes at once: CRC=17560371, 0.848s, 1207.547 MB/s 90 | + 8 bytes at once: CRC=17560371, 0.534s, 1917.603 MB/s 91 | +2*8 bytes at once: CRC=17560371, 0.533s, 1921.201 MB/s 92 | +4*8 bytes at once: CRC=17560371, 0.555s, 1845.045 MB/s 93 | 4 bytes at once: CRC=00EE2DAA, 0.854s, 1199.063 MB/s 94 | 2*4 bytes at once: CRC=00EE2DAA, 0.850s, 1204.706 MB/s 95 | 4*4 bytes at once: CRC=00EE2DAA, 0.863s, 1186.559 MB/s 96 | 8 bytes at once: CRC=00EE2DAA, 0.452s, 2265.487 MB/s 97 | 16 bytes at once: CRC=00EE2DAA, 0.370s, 2767.568 MB/s 98 | 2*16 bytes at once: CRC=00EE2DAA, 0.420s, 2438.095 MB/s 99 | 2*8 bytes at once: CRC=00EE2DAA, 0.442s, 2316.742 MB/s 100 | 4*8 bytes at once: CRC=00EE2DAA, 0.439s, 2332.574 MB/s 101 | chunked : CRC=00EE2DAA, 0.429s, 2386.946 MB/s 102 | -------------------------------------------------------------------------------- /crc32ctables.cc: -------------------------------------------------------------------------------- 1 | // Copyright 2008,2009,2010 Massachusetts Institute of Technology. 2 | // All rights reserved. Use of this source code is governed by a 3 | // BSD-style license that can be found in the LICENSE file. 4 | 5 | // Implementations adapted from Intel's Slicing By 8 Sourceforge Project 6 | // http://sourceforge.net/projects/slicing-by-8/ 7 | /* 8 | * Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved 9 | * 10 | * 11 | * This software program is licensed subject to the BSD License, 12 | * available at http://www.opensource.org/licenses/bsd-license.html. 13 | * 14 | * Abstract: 15 | * 16 | * Tables for software CRC generation 17 | */ 18 | 19 | //#include "logging/crc32ctables.h" 20 | 21 | //namespace logging { 22 | 23 | /* Tables generated with code like the following: 24 | 25 | #define CRCPOLY 0x82f63b78 // reversed 0x1EDC6F41 26 | #define CRCINIT 0xFFFFFFFF 27 | 28 | void init() { 29 | for (uint32_t i = 0; i <= 0xFF; i++) { 30 | uint32_t x = i; 31 | for (uint32_t j = 0; j < 8; j++) 32 | x = (x>>1) ^ (CRCPOLY & (-(int32_t)(x & 1))); 33 | g_crc_slicing[0][i] = x; 34 | } 35 | 36 | for (uint32_t i = 0; i <= 0xFF; i++) { 37 | uint32_t c = g_crc_slicing[0][i]; 38 | for (uint32_t j = 1; j < 8; j++) { 39 | c = g_crc_slicing[0][c & 0xFF] ^ (c >> 8); 40 | g_crc_slicing[j][i] = c; 41 | } 42 | } 43 | } 44 | */ 45 | 46 | /* 47 | * The following CRC lookup table was generated automagically 48 | * using the following model parameters: 49 | * 50 | * Generator Polynomial = ................. 0x1EDC6F41 51 | * Generator Polynomial Length = .......... 32 bits 52 | * Reflected Bits = ....................... TRUE 53 | * Table Generation Offset = .............. 32 bits 54 | * Number of Slices = ..................... 8 slices 55 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 56 | * Directory Name = ....................... .\ 57 | * File Name = ............................ 8x256_tables.c 58 | */ 59 | 60 | const uint32_t crc_tableil8_o32[256] = 61 | { 62 | 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 63 | 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, 64 | 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 65 | 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, 66 | 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 67 | 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, 68 | 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 69 | 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, 70 | 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 71 | 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, 72 | 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 73 | 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, 74 | 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 75 | 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, 76 | 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 77 | 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, 78 | 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 79 | 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, 80 | 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 81 | 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, 82 | 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 83 | 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, 84 | 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 85 | 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, 86 | 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 87 | 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, 88 | 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 89 | 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, 90 | 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 91 | 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, 92 | 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 93 | 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 94 | }; 95 | 96 | /* 97 | * end of the CRC lookup table crc_tableil8_o32 98 | */ 99 | 100 | 101 | 102 | /* 103 | * The following CRC lookup table was generated automagically 104 | * using the following model parameters: 105 | * 106 | * Generator Polynomial = ................. 0x1EDC6F41 107 | * Generator Polynomial Length = .......... 32 bits 108 | * Reflected Bits = ....................... TRUE 109 | * Table Generation Offset = .............. 32 bits 110 | * Number of Slices = ..................... 8 slices 111 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 112 | * Directory Name = ....................... .\ 113 | * File Name = ............................ 8x256_tables.c 114 | */ 115 | 116 | const uint32_t crc_tableil8_o40[256] = 117 | { 118 | 0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899, 0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945, 119 | 0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21, 0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD, 120 | 0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918, 0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4, 121 | 0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0, 0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C, 122 | 0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B, 0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47, 123 | 0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823, 0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF, 124 | 0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A, 0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6, 125 | 0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2, 0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E, 126 | 0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D, 0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41, 127 | 0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25, 0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9, 128 | 0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C, 0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0, 129 | 0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4, 0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78, 130 | 0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F, 0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43, 131 | 0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27, 0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB, 132 | 0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E, 0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2, 133 | 0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6, 0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A, 134 | 0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260, 0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC, 135 | 0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8, 0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004, 136 | 0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1, 0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D, 137 | 0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059, 0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185, 138 | 0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162, 0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE, 139 | 0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA, 0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306, 140 | 0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3, 0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F, 141 | 0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B, 0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287, 142 | 0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464, 0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8, 143 | 0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC, 0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600, 144 | 0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5, 0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439, 145 | 0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D, 0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781, 146 | 0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766, 0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA, 147 | 0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE, 0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502, 148 | 0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7, 0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B, 149 | 0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F, 0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483 150 | }; 151 | 152 | /* 153 | * end of the CRC lookup table crc_tableil8_o40 154 | */ 155 | 156 | 157 | 158 | /* 159 | * The following CRC lookup table was generated automagically 160 | * using the following model parameters: 161 | * 162 | * Generator Polynomial = ................. 0x1EDC6F41 163 | * Generator Polynomial Length = .......... 32 bits 164 | * Reflected Bits = ....................... TRUE 165 | * Table Generation Offset = .............. 32 bits 166 | * Number of Slices = ..................... 8 slices 167 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 168 | * Directory Name = ....................... .\ 169 | * File Name = ............................ 8x256_tables.c 170 | */ 171 | 172 | const uint32_t crc_tableil8_o48[256] = 173 | { 174 | 0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073, 0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469, 175 | 0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6, 0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC, 176 | 0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9, 0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3, 177 | 0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C, 0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726, 178 | 0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67, 0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D, 179 | 0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2, 0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8, 180 | 0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED, 0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7, 181 | 0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828, 0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32, 182 | 0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA, 0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0, 183 | 0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F, 0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75, 184 | 0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20, 0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A, 185 | 0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5, 0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF, 186 | 0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE, 0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4, 187 | 0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B, 0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161, 188 | 0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634, 0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E, 189 | 0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1, 0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB, 190 | 0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730, 0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A, 191 | 0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5, 0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF, 192 | 0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA, 0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0, 193 | 0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F, 0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065, 194 | 0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24, 0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E, 195 | 0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1, 0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB, 196 | 0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE, 0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4, 197 | 0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B, 0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71, 198 | 0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9, 0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3, 199 | 0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C, 0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36, 200 | 0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63, 0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79, 201 | 0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6, 0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC, 202 | 0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD, 0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7, 203 | 0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238, 0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622, 204 | 0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177, 0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D, 205 | 0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2, 0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8 206 | }; 207 | 208 | /* 209 | * end of the CRC lookup table crc_tableil8_o48 210 | */ 211 | 212 | 213 | 214 | /* 215 | * The following CRC lookup table was generated automagically 216 | * using the following model parameters: 217 | * 218 | * Generator Polynomial = ................. 0x1EDC6F41 219 | * Generator Polynomial Length = .......... 32 bits 220 | * Reflected Bits = ....................... TRUE 221 | * Table Generation Offset = .............. 32 bits 222 | * Number of Slices = ..................... 8 slices 223 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 224 | * Directory Name = ....................... .\ 225 | * File Name = ............................ 8x256_tables.c 226 | */ 227 | 228 | const uint32_t crc_tableil8_o56[256] = 229 | { 230 | 0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939, 0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA, 231 | 0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF, 0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C, 232 | 0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804, 0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7, 233 | 0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2, 0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11, 234 | 0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2, 0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41, 235 | 0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54, 0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7, 236 | 0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F, 0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C, 237 | 0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69, 0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A, 238 | 0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE, 0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D, 239 | 0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538, 0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB, 240 | 0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3, 0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610, 241 | 0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405, 0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6, 242 | 0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255, 0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6, 243 | 0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3, 0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040, 244 | 0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368, 0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B, 245 | 0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E, 0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D, 246 | 0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006, 0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5, 247 | 0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0, 0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213, 248 | 0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B, 0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8, 249 | 0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD, 0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E, 250 | 0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D, 0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E, 251 | 0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B, 0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698, 252 | 0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0, 0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443, 253 | 0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656, 0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5, 254 | 0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1, 0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12, 255 | 0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07, 0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4, 256 | 0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC, 0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F, 257 | 0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A, 0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9, 258 | 0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A, 0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99, 259 | 0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C, 0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F, 260 | 0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57, 0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4, 261 | 0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1, 0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842 262 | }; 263 | 264 | /* 265 | * end of the CRC lookup table crc_tableil8_o56 266 | */ 267 | 268 | 269 | 270 | /* 271 | * The following CRC lookup table was generated automagically 272 | * using the following model parameters: 273 | * 274 | * Generator Polynomial = ................. 0x1EDC6F41 275 | * Generator Polynomial Length = .......... 32 bits 276 | * Reflected Bits = ....................... TRUE 277 | * Table Generation Offset = .............. 32 bits 278 | * Number of Slices = ..................... 8 slices 279 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 280 | * Directory Name = ....................... .\ 281 | * File Name = ............................ 8x256_tables.c 282 | */ 283 | 284 | const uint32_t crc_tableil8_o64[256] = 285 | { 286 | 0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4, 0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44, 287 | 0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65, 0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5, 288 | 0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127, 0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97, 289 | 0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6, 0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406, 290 | 0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3, 0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13, 291 | 0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32, 0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082, 292 | 0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470, 0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0, 293 | 0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1, 0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151, 294 | 0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A, 0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA, 295 | 0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB, 0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B, 296 | 0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89, 0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539, 297 | 0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018, 0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8, 298 | 0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D, 0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD, 299 | 0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C, 0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C, 300 | 0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE, 0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E, 301 | 0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F, 0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF, 302 | 0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8, 0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18, 303 | 0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39, 0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089, 304 | 0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B, 0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB, 305 | 0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA, 0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A, 306 | 0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF, 0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F, 307 | 0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E, 0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE, 308 | 0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C, 0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C, 309 | 0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD, 0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D, 310 | 0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06, 0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6, 311 | 0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497, 0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27, 312 | 0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5, 0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065, 313 | 0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544, 0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4, 314 | 0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51, 0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1, 315 | 0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0, 0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70, 316 | 0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82, 0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532, 317 | 0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013, 0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3 318 | }; 319 | 320 | /* 321 | * end of the CRC lookup table crc_tableil8_o64 322 | */ 323 | 324 | 325 | 326 | /* 327 | * The following CRC lookup table was generated automagically 328 | * using the following model parameters: 329 | * 330 | * Generator Polynomial = ................. 0x1EDC6F41 331 | * Generator Polynomial Length = .......... 32 bits 332 | * Reflected Bits = ....................... TRUE 333 | * Table Generation Offset = .............. 32 bits 334 | * Number of Slices = ..................... 8 slices 335 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 336 | * Directory Name = ....................... .\ 337 | * File Name = ............................ 8x256_tables.c 338 | */ 339 | 340 | const uint32_t crc_tableil8_o72[256] = 341 | { 342 | 0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA, 0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD, 343 | 0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5, 0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2, 344 | 0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4, 0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93, 345 | 0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB, 0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C, 346 | 0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57, 0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20, 347 | 0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548, 0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F, 348 | 0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69, 0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E, 349 | 0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576, 0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201, 350 | 0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031, 0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746, 351 | 0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E, 0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59, 352 | 0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F, 0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778, 353 | 0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810, 0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67, 354 | 0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC, 0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB, 355 | 0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3, 0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4, 356 | 0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682, 0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5, 357 | 0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D, 0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA, 358 | 0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C, 0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B, 359 | 0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413, 0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364, 360 | 0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32, 0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45, 361 | 0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D, 0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A, 362 | 0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81, 0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6, 363 | 0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E, 0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9, 364 | 0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF, 0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8, 365 | 0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0, 0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7, 366 | 0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7, 0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090, 367 | 0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8, 0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F, 368 | 0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9, 0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE, 369 | 0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6, 0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1, 370 | 0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A, 0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D, 371 | 0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975, 0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02, 372 | 0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154, 0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623, 373 | 0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B, 0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C 374 | }; 375 | 376 | /* 377 | * end of the CRC lookup table crc_tableil8_o72 378 | */ 379 | 380 | 381 | 382 | /* 383 | * The following CRC lookup table was generated automagically 384 | * using the following model parameters: 385 | * 386 | * Generator Polynomial = ................. 0x1EDC6F41 387 | * Generator Polynomial Length = .......... 32 bits 388 | * Reflected Bits = ....................... TRUE 389 | * Table Generation Offset = .............. 32 bits 390 | * Number of Slices = ..................... 8 slices 391 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 392 | * Directory Name = ....................... .\ 393 | * File Name = ............................ 8x256_tables.c 394 | */ 395 | 396 | const uint32_t crc_tableil8_o80[256] = 397 | { 398 | 0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558, 0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089, 399 | 0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B, 0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA, 400 | 0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE, 0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F, 401 | 0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD, 0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C, 402 | 0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5, 0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334, 403 | 0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6, 0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67, 404 | 0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43, 0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992, 405 | 0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110, 0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1, 406 | 0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222, 0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3, 407 | 0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71, 0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0, 408 | 0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884, 0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55, 409 | 0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7, 0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006, 410 | 0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F, 0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E, 411 | 0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC, 0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D, 412 | 0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39, 0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8, 413 | 0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A, 0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB, 414 | 0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC, 0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D, 415 | 0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF, 0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E, 416 | 0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A, 0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB, 417 | 0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59, 0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988, 418 | 0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811, 0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0, 419 | 0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542, 0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093, 420 | 0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7, 0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766, 421 | 0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4, 0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35, 422 | 0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6, 0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907, 423 | 0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185, 0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454, 424 | 0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670, 0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1, 425 | 0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23, 0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2, 426 | 0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B, 0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA, 427 | 0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238, 0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9, 428 | 0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD, 0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C, 429 | 0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E, 0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F 430 | }; 431 | 432 | /* 433 | * end of the CRC lookup table crc_tableil8_o80 434 | */ 435 | 436 | 437 | 438 | /* 439 | * The following CRC lookup table was generated automagically 440 | * using the following model parameters: 441 | * 442 | * Generator Polynomial = ................. 0x1EDC6F41 443 | * Generator Polynomial Length = .......... 32 bits 444 | * Reflected Bits = ....................... TRUE 445 | * Table Generation Offset = .............. 32 bits 446 | * Number of Slices = ..................... 8 slices 447 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 448 | * Directory Name = ....................... .\ 449 | * File Name = ............................ 8x256_tables.c 450 | */ 451 | 452 | const uint32_t crc_tableil8_o88[256] = 453 | { 454 | 0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769, 0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504, 455 | 0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3, 0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE, 456 | 0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD, 0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0, 457 | 0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07, 0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A, 458 | 0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0, 0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D, 459 | 0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A, 0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447, 460 | 0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44, 0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929, 461 | 0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E, 0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3, 462 | 0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B, 0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36, 463 | 0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881, 0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC, 464 | 0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF, 0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782, 465 | 0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135, 0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358, 466 | 0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2, 0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF, 467 | 0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18, 0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75, 468 | 0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076, 0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B, 469 | 0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC, 0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1, 470 | 0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D, 0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360, 471 | 0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7, 0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA, 472 | 0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9, 0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4, 473 | 0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63, 0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E, 474 | 0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494, 0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9, 475 | 0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E, 0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223, 476 | 0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20, 0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D, 477 | 0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA, 0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97, 478 | 0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F, 0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852, 479 | 0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5, 0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88, 480 | 0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B, 0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6, 481 | 0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751, 0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C, 482 | 0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6, 0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB, 483 | 0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C, 0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911, 484 | 0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612, 0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F, 485 | 0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8, 0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5 486 | }; 487 | 488 | /* 489 | * end of the CRC lookup table crc_tableil8_o88 490 | */ 491 | 492 | //} // namespace logging 493 | --------------------------------------------------------------------------------