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
}
