void Adler32::Hash(const uint8 * buffer, uint32 size) { if (!buffer || !size) return; len += size; // Faster implementation const uint32 nMax = 5552; while (size >= nMax) { for (int i = 0; i < nMax / 16; i++) { DO16(buffer); buffer += 16; } MOD(a); MOD(b); size -= nMax; } while (size >= 16) { DO16(buffer); buffer += 16; size -= 16; } while (size > 0) { DO1(buffer, 0); buffer ++; size --; } MOD(a); MOD(b); }
// This should be more efficient unsigned long int ChecksumAdler32(ADLER_STRUCTURE *adlerhold, unsigned char *data, size_t len) { unsigned long int a; unsigned long int b; int k; a=adlerhold->a; b=adlerhold->b; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(data); data += 16; k -= 16; } if (k != 0) do { a += *data++; b += a; } while (--k); a %= MOD_ADLER; b %= MOD_ADLER; } adlerhold->a=a; adlerhold->b=b; return (b << 16) | a; }
DWORD GetCRC32(const char * buf, size_t len) { DWORD crc = 0xffffffff; if (len >= 16) { do { DO16(buf, 0); buf += 16; len -= 16; } while (len >= 16); } if (len != 0) { do { DO1(buf, 0); ++buf; --len; } while (len > 0); } crc ^= 0xffffffff; return crc; }
/* ========================================================================= */ ZEXPORT(uLong) adler32( /* adler, buf, len) */ uLong adler, const Bytef *buf, uInt len ) { unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; int k; if (buf == Z_NULL) return 1L; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); buf += 16; k -= 16; } if (k != 0) do { s1 += *buf++; s2 += s1; } while (--k); s1 %= BASE; s2 %= BASE; } return (s2 << 16) | s1; }
unsigned long Adler32(unsigned char *buf, long len) { unsigned long s1 = 1; // adler & 0xffff; unsigned long s2 = 0; // (adler >> 16) & 0xffff; unsigned long result; int k; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); buf += 16; k -= 16; } if (k != 0) do { s1 += *buf++; s2 += s1; } while (--k); s1 %= BASE; s2 %= BASE; } result = (s2 << 16) | s1; return OSSwapHostToBigInt32(result); }
uint32_t lzadler32(uint8_t * buf, int32_t len) { unsigned long s1 = 1; // adler & 0xffff; unsigned long s2 = 0; // (adler >> 16) & 0xffff; int k; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); buf += 16; k -= 16; } if (k != 0) do { s1 += *buf++; s2 += s1; } while (--k); s1 %= BASE; s2 %= BASE; } return (s2 << 16) | s1; }
unsigned long xdl_adler32(unsigned long adler, unsigned char const *buf, unsigned int len) { int k; unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; if (!buf) return 1; while (len > 0) { k = len < NMAX ? len :NMAX; len -= k; while (k >= 16) { DO16(buf); buf += 16; k -= 16; } if (k != 0) do { s1 += *buf++; s2 += s1; } while (--k); s1 %= BASE; s2 %= BASE; } return (s2 << 16) | s1; }
crc_t GetCRC32(const char * buf, size_t len) { crc_t crc = 0xffffffff; if (16 <= len) { do { DO16(buf, 0); buf += 16; len -= 16; } while (len >= 16); } if (0 != len) { do { DO1(buf, 0); ++buf; --len; } while (len > 0); } crc ^= 0xffffffff; return crc; }
/* ========================================================================= */ unsigned int adler32(unsigned int adler, const char *buf, unsigned int len) { unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; int k; if (buf == 0) return 1L; while (len > 0) { k = len < NMAX ? (int)len : NMAX; len -= k; while (k >= 16) { DO16(buf); buf += 16; k -= 16; } if (k != 0) do { s1 += *buf++; s2 += s1; } while (--k); MOD(s1); MOD(s2); } return (s2 << 16) | s1; }
//----------------------------------------------------------------------------- // Name : HashName (Function) /// <summary> /// Relatively simple hash of arbitrary text string into a /// 32-bit identifier Output value is /// input-valid-deterministic, but no guarantees are made /// about the uniqueness of the output per-input /// /// Input value is treated as lower-case to cut down on false /// separations cause by human mistypes. Sure, it could be /// construed as a programming error to mix up your cases, and /// it cuts down on permutations, but in Real World Usage /// making this text case-sensitive will likely just lead to /// Pain and Suffering. /// /// This code lossely based upon the adler32 checksum by Mark /// Adler and published as part of the zlib compression /// library sources. /// </summary> //----------------------------------------------------------------------------- void * skyHashedString::HashName( char const * pIdentStr ) { // largest prime smaller than 65536 unsigned long BASE = 65521L; // NMAX is the largest n such that 255n(n+1)/2 + // (n+1)(BASE-1) <= 2^32-1 unsigned long NMAX = 5552; #define DO1(buf,i) {s1 += tolower(buf[i]); s2 += s1;} #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); #define DO16(buf) DO8(buf,0); DO8(buf,8); if (pIdentStr == NULL) return NULL; unsigned long s1 = 0; unsigned long s2 = 0; for ( size_t len = strlen( pIdentStr ); len > 0 ; ) { unsigned long k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(pIdentStr); pIdentStr += 16; k -= 16; } if (k != 0) do { s1 += tolower( *pIdentStr++ ); s2 += s1; } while (--k); s1 %= BASE; s2 %= BASE; } #pragma warning(push) #pragma warning(disable : 4312) return reinterpret_cast<void *>( (s2 << 16) | s1 ); #pragma warning(pop) #undef DO1 #undef DO2 #undef DO4 #undef DO8 #undef DO16 }
unsigned long Adler32(unsigned char *buf, long len) { #define BASE 65521L // largest prime smaller than 65536 #define NMAX 5000 // NMAX (was 5521) the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 #define DO1(buf, i) {s1 += buf[i]; s2 += s1;} #define DO2(buf, i) DO1(buf, i); DO1(buf, i + 1); #define DO4(buf, i) DO2(buf, i); DO2(buf, i + 2); #define DO8(buf, i) DO4(buf, i); DO4(buf, i + 4); #define DO16(buf) DO8(buf, 0); DO8(buf, 8); int k; unsigned long s1 = 1; // adler & 0xffff; unsigned long s2 = 0; // (adler >> 16) & 0xffff; unsigned long result; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); buf += 16; k -= 16; } if (k != 0) { do { s1 += *buf++; s2 += s1; } while (--k); } s1 %= BASE; s2 %= BASE; } result = (s2 << 16) | s1; return OSSwapHostToBigInt32(result); }
void rollsumUpdate(trollsum *sum,const unsigned char *buf,unsigned int len) { unsigned long s1 = sum->s1; unsigned long s2 = sum->s2; sum->count+=len; /* increment sum count */ while (len >= 16) { DO16(buf); OF16(ROLLSUM_CHAR_OFFSET); buf += 16; len -= 16; } while (len != 0) { s1 += (*buf++ + ROLLSUM_CHAR_OFFSET); s2 += s1; len--; } sum->s1=s1; sum->s2=s2; }
void rs_rollsum_update(rs_rollsum_t *sum,const char *buf,int len) { /* ANSI C says no overflow for unsigned */ unsigned long s1 = sum->s1; unsigned long s2 = sum->s2; sum->count+=len; /* increment sum count */ while (len >= 16) { DO16(buf); OF16(RS_CHAR_OFFSET); buf += 16; len -= 16; } while (len != 0) { s1 += (*buf++ + RS_CHAR_OFFSET); s2 += s1; len--; } sum->s1=s1; sum->s2=s2; }
void RollsumUpdate(Rollsum *sum,const unsigned char *buf,unsigned int len) { /* ANSI C says no overflow for unsigned. zlib's adler 32 goes to extra effort to avoid overflow*/ unsigned long s1 = sum->s1; unsigned long s2 = sum->s2; sum->count+=len; /* increment sum count */ while (len >= 16) { DO16(buf); OF16(ROLLSUM_CHAR_OFFSET); buf += 16; len -= 16; } while (len != 0) { s1 += (*buf++ + ROLLSUM_CHAR_OFFSET); s2 += s1; len--; } sum->s1=s1; sum->s2=s2; }
// (1, frame, height(include padding), width(include padding) ) static unsigned long av_adler32_update(unsigned long adler, const unsigned char *buf, int ylen, int xlen) { unsigned long s1 = adler & 0xffff; unsigned long s2 = adler >> 16; unsigned char *pbuf; int xlenorg = xlen; while(ylen>0){ pbuf = ( unsigned char * )buf; while (xlen>0) { #ifdef CONFIG_SMALL while(xlen>4 && s2 < (1U<<31)){ DO4(buf); xlen-=4; #else while(xlen>0 && s2 < (1U<<31) && (xlen>16) ){ DO16(buf); xlen-=16; #endif } DO1(buf); xlen--; s1 %= BASE; s2 %= BASE; } ylen--; xlen = xlenorg; //buf = pbuf; } return (s2 << 16) | s1; } static int to_sched_priority(UINT8 ui1_priority) { int sched_priority; sched_priority = 100 - (int)ui1_priority * 100 / 256; if (sched_priority < 1) sched_priority = 1; if (sched_priority > 99) sched_priority = 99; return sched_priority; }
unsigned long update_adler32(unsigned long adler, const uint8_t *buf, unsigned int len) { unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; int k; if (buf == NULL) return 1L; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); k -= 16; } if (k != 0) do { DO1(buf); } while (--k); s1 %= BASE; s2 %= BASE; } return (s2 << 16) | s1; }
void *HashedString::hash_name(char const *pIdentStr) { // Relatively simple hash of arbitrary text string into a // 32-bit identifier Output value is // input-valid-deterministic, but no guarantees are made // about the uniqueness of the output per-input // // Input value is treated as lower-case to cut down on false // separations cause by human mistypes. Sure, it could be // construed as a programming error to mix up your cases, and // it cuts down on permutations, but in Real World Usage // making this text case-sensitive will likely just lead to // Pain and Suffering. // // This code lossely based upon the adler32 checksum by Mark // Adler and published as part of the zlib compression // library sources. // largest prime smaller than 65536 U64 BASE = 65521L; // NMAX is the largest n such that 255n(n+1)/2 + // (n+1)(BASE-1) <= 2^32-1 U64 NMAX = 5552; #define DO1(buf,i) {s1 += tolower(buf[i]); s2 += s1;} #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); #define DO16(buf) DO8(buf,0); DO8(buf,8); if(pIdentStr == NULL) { return NULL; } // Missing reference to kpWildcardEventType string here, compare with pg276 of GCC3. U64 s1 = 0; U64 s2 = 0; for(size_t len = strlen(pIdentStr); len > 0 ;) { U64 k = len < NMAX ? len : NMAX; len -= k; while(k >= 16) { DO16(pIdentStr); pIdentStr += 16; k -= 16; } if(k != 0) do { s1 += tolower(*pIdentStr++); s2 += s1; } while(--k); s1 %= BASE; s2 %= BASE; } return reinterpret_cast<void *>((s2 << 16) | s1); #undef DO1 #undef DO2 #undef DO4 #undef DO8 #undef DO16 }