public static uint Digest(XxHashState32 state)
{
#if DEBUG
unchecked
{
#endif
uint h32;
int index = 0;
if (state.TotalLen >= 16)
{
h32 = RotateLeft(state.V1, 1) + RotateLeft(state.V2, 7) + RotateLeft(state.V3, 12) +
RotateLeft(state.V4, 18);
}
else
{
h32 = state.Seed + PRIME32_5;
}
h32 += (uint)state.TotalLen;
while (index <= state.Memsize - 4)
{
h32 += *(uint *)(state.Memory + index) * PRIME32_3;
h32 = RotateLeft(h32, 17) * PRIME32_4;
index += 4;
}
while (index < state.Memsize)
{
h32 += state.Memory[index] * PRIME32_5;
h32 = RotateLeft(h32, 11) * PRIME32_1;
index++;
}
h32 ^= h32 >> 15;
h32 *= PRIME32_2;
h32 ^= h32 >> 13;
h32 *= PRIME32_3;
h32 ^= h32 >> 16;
return(h32);
#if DEBUG
}
#endif
}
public static bool Update(ref XxHashState32 state, IntPtr input, int len)
{
int index = 0;
state.TotalLen += (uint)len;
if (state.Memsize + len < 16)
{
fixed(byte *ptr = state.Memory)
{
ByteUtil.MemoryCopy(ptr + state.Memsize, (byte *)input, (uint)len);
}
//Array.Copy(input, 0, state.Memory, state.Memsize, len);
state.Memsize += (uint)len;
return(true);
}
if (state.Memsize > 0)
{
fixed(byte *ptr = state.Memory)
{
ByteUtil.MemoryCopy(ptr + state.Memsize, (byte *)input, (uint)(16 - state.Memsize));
}
//Array.Copy(input, 0, state.Memory, state.Memsize, 16 - state.Memsize);
fixed(byte *ptr = state.Memory)
{
state.V1 = CalcSubHash(state.V1, (IntPtr)ptr, index);
index += 4;
state.V2 = CalcSubHash(state.V2, (IntPtr)ptr, index);
index += 4;
state.V3 = CalcSubHash(state.V3, (IntPtr)ptr, index);
index += 4;
state.V4 = CalcSubHash(state.V4, (IntPtr)ptr, index);
//index += 4;
}
index = 0;
state.Memsize = 0;
}
if (index <= len - 16)
{
int limit = len - 16;
uint v1 = state.V1;
uint v2 = state.V2;
uint v3 = state.V3;
uint v4 = state.V4;
do
{
v1 = CalcSubHash(v1, input, index);
index += 4;
v2 = CalcSubHash(v2, input, index);
index += 4;
v3 = CalcSubHash(v3, input, index);
index += 4;
v4 = CalcSubHash(v4, input, index);
index += 4;
} while (index <= limit);
state.V1 = v1;
state.V2 = v2;
state.V3 = v3;
state.V4 = v4;
}
if (index < len)
{
fixed(byte *ptr = state.Memory)
{
ByteUtil.MemoryCopy(ptr + 0, (byte *)(input + index), (uint)(len - index));
}
//Array.Copy(input, index, state.Memory, 0, len - index);
state.Memsize = (uint)(len - index);
}
return(true);
}
public static bool Update(ref XxHashState32 state, byte *input, int len)
{
#if DEBUG
unchecked
{
#endif
int index = 0;
state.TotalLen += (uint)len;
if (state.Memsize + len < 16)
{
var ptr = (byte *)Unsafe.AsPointer(ref state);
// fixed (byte* ptr = state.Memory)
{
Unsafe.CopyBlockUnaligned(ptr + state.Memsize, (byte *)input, (uint)len);
}
//Array.Copy(input, 0, state.Memory, state.Memsize, len);
state.Memsize += (uint)len;
return(true);
}
if (state.Memsize > 0)
{
var ptr = (byte *)Unsafe.AsPointer(ref state);
// fixed (byte* ptr = state.Memory)
{
Unsafe.CopyBlockUnaligned(ptr + state.Memsize, (byte *)input, (uint)(16 - state.Memsize));
}
//Array.Copy(input, 0, state.Memory, state.Memsize, 16 - state.Memsize);
// fixed (byte* ptr = state.Memory)
{
state.V1 = CalcSubHash(state.V1, ptr, index);
index += 4;
state.V2 = CalcSubHash(state.V2, ptr, index);
index += 4;
state.V3 = CalcSubHash(state.V3, ptr, index);
index += 4;
state.V4 = CalcSubHash(state.V4, ptr, index);
//index += 4;
}
index = 0;
state.Memsize = 0;
}
if (index <= len - 16)
{
int limit = len - 16;
uint v1 = state.V1;
uint v2 = state.V2;
uint v3 = state.V3;
uint v4 = state.V4;
do
{
v1 = CalcSubHash(v1, input, index);
index += 4;
v2 = CalcSubHash(v2, input, index);
index += 4;
v3 = CalcSubHash(v3, input, index);
index += 4;
v4 = CalcSubHash(v4, input, index);
index += 4;
} while (index <= limit);
state.V1 = v1;
state.V2 = v2;
state.V3 = v3;
state.V4 = v4;
}
if (index < len)
{
var ptr = (byte *)Unsafe.AsPointer(ref state);
// fixed (byte* ptr = state.Memory)
{
Unsafe.CopyBlockUnaligned(ptr + 0, (byte *)(input + index), (uint)(len - index));
}
//Array.Copy(input, index, state.Memory, 0, len - index);
state.Memsize = (uint)(len - index);
}
return(true);
#if DEBUG
}
#endif
}
