2c2
< * Copyright (C) 1995-2003 Mark Adler
---
> * Copyright (C) 1995-2004 Mark Adler
15c15
< #define DO1(buf,i) {s1 += buf[i]; s2 += s1;}
---
> #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
20a21
> /* use NO_DIVIDE if your processor does not do division in hardware */
41a43,50
> # define MOD4(a) \
> do { \
> if (a >= (BASE << 4)) a -= (BASE << 4); \
> if (a >= (BASE << 3)) a -= (BASE << 3); \
> if (a >= (BASE << 2)) a -= (BASE << 2); \
> if (a >= (BASE << 1)) a -= (BASE << 1); \
> if (a >= BASE) a -= BASE; \
> } while (0)
43a53
> # define MOD4(a) a %= BASE
52,54c62,63
< unsigned long s1 = adler & 0xffff;
< unsigned long s2 = (adler >> 16) & 0xffff;
< int k;
---
> unsigned long sum2;
> unsigned n;
56c65,67
< if (buf == Z_NULL) return 1L;
---
> /* split Adler-32 into component sums */
> sum2 = (adler >> 16) & 0xffff;
> adler &= 0xffff;
58,61c69,111
< while (len > 0) {
< k = len < NMAX ? (int)len : NMAX;
< len -= k;
< while (k >= 16) {
---
> /* in case user likes doing a byte at a time, keep it fast */
> if (len == 1) {
> adler += buf[0];
> if (adler >= BASE)
> adler -= BASE;
> sum2 += adler;
> if (sum2 >= BASE)
> sum2 -= BASE;
> return adler | (sum2 << 16);
> }
>
> /* initial Adler-32 value (deferred check for len == 1 speed) */
> if (buf == Z_NULL)
> return 1L;
>
> /* in case short lengths are provided, keep it somewhat fast */
> if (len < 16) {
> while (len--) {
> adler += *buf++;
> sum2 += adler;
> }
> if (adler >= BASE)
> adler -= BASE;
> MOD4(sum2); /* only added so many BASE's */
> return adler | (sum2 << 16);
> }
>
> /* do length NMAX blocks -- requires just one modulo operation */
> while (len >= NMAX) {
> len -= NMAX;
> n = NMAX / 16; /* NMAX is divisible by 16 */
> do {
> DO16(buf); /* 16 sums unrolled */
> buf += 16;
> } while (--n);
> MOD(adler);
> MOD(sum2);
> }
>
> /* do remaining bytes (less than NMAX, still just one modulo) */
> if (len) { /* avoid modulos if none remaining */
> while (len >= 16) {
> len -= 16;
64d113
< k -= 16;
66,71c115,120
< if (k != 0) do {
< s1 += *buf++;
< s2 += s1;
< } while (--k);
< MOD(s1);
< MOD(s2);
---
> while (len--) {
> adler += *buf++;
> sum2 += adler;
> }
> MOD(adler);
> MOD(sum2);
73c122,124
< return (s2 << 16) | s1;
---
>
> /* return recombined sums */
> return adler | (sum2 << 16);
74a126,149
>
> /* ========================================================================= */
> uLong ZEXPORT adler32_combine(adler1, adler2, len2)
> uLong adler1;
> uLong adler2;
> z_off_t len2;
> {
> unsigned long sum1;
> unsigned long sum2;
> unsigned rem;
>
> /* the derivation of this formula is left as an exercise for the reader */
> rem = (unsigned)(len2 % BASE);
> sum1 = adler1 & 0xffff;
> sum2 = rem * sum1;
> MOD(sum2);
> sum1 += (adler2 & 0xffff) + BASE - 1;
> sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
> if (sum1 > BASE) sum1 -= BASE;
> if (sum1 > BASE) sum1 -= BASE;
> if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
> if (sum2 > BASE) sum2 -= BASE;
> return sum1 | (sum2 << 16);
> }