Beispiel #1
0
        public static uint Hash(uint adler, ReadOnlySpan <byte> buff)
        {
            uint len = (uint)buff.Length;

            if (len == 0)
            {
                return(1);
            }
            if (len == 1)
            {
                uint sum2 = adler >> 16 & 0xffff;
                adler &= 0xffff;

                adler += buff[0];
                if (adler >= BASE)
                {
                    adler -= BASE;
                }

                sum2 += adler;
                if (sum2 >= BASE)
                {
                    sum2 -= BASE;
                }

                return(adler | (sum2 << 16));
            }

            if (len < 16)
            {
                uint sum2 = adler >> 16 & 0xffff;
                adler &= 0xffff;

                for (int i = 0; i < len; i++)
                {
                    adler += buff[i];
                    sum2  += adler;
                }

                if (adler >= BASE)
                {
                    adler -= BASE;
                }

                sum2 %= BASE;
                return(adler | (sum2 << 16));
            }

#if NETCOREAPP3_1 || NET5_0
            if (Avx2.IsSupported)
            {
                return(Adler32.HashAvx2(adler, buff));
            }
            if (Ssse3.IsSupported)
            {
                return(Adler32.HashSsse3(adler, buff));
            }
#endif
            unsafe
            {
                fixed(byte *bufPtr = buff)
                {
                    uint sum2 = adler >> 16 & 0xffff;

                    adler &= 0xffff;

                    int dof = 0;

                    while (len >= NMAX)
                    {
                        len -= NMAX;
                        uint n = NMAX / 16;
                        do
                        {
                            Do(ref adler, ref sum2, buff, dof, 16);
                            dof += 16;
                        } while (--n > 0);

                        adler %= BASE;
                        sum2  %= BASE;
                    }

                    if (len > 0)
                    {
                        while (len >= 16)
                        {
                            len -= 16;
                            Do(ref adler, ref sum2, buff, dof, 16);
                            dof += 16;
                        }

                        while (len-- > 0)
                        {
                            adler += bufPtr[dof++];
                            sum2  += adler;
                        }

                        adler %= BASE;
                        sum2  %= BASE;
                    }

                    return(adler | (sum2 << 16));
                }
            }
        }
Beispiel #2
0
 public static long UpdateAdler32(uint partial, ReadOnlyMemory <byte> buffer)
 {
     return(Adler32.Hash(partial, buffer.Span));
 }
Beispiel #3
0
 public static uint ComputeGoogleAdler32(ReadOnlyMemory <byte> buffer)
 {
     return(Adler32.Hash(0, buffer.Span));
 }
Beispiel #4
0
 public static uint ComputeXdelta3Adler32(ReadOnlyMemory <byte> buffer)
 {
     return(Adler32.Hash(1, buffer.Span));
 }