diff options
author | Nicolas Pennequin <nicolas.pennequin@free.fr> | 2008-07-11 16:51:25 +0000 |
---|---|---|
committer | Nicolas Pennequin <nicolas.pennequin@free.fr> | 2008-07-11 16:51:25 +0000 |
commit | ca5bb76d2b8f65aa97e50b633f828c1deb241526 (patch) | |
tree | 453a1b2de3a0dc0d0b2f7080d10d033bf8fbcdf1 /utils/zenutils/libraries/zlib123/zlib/adler32.c | |
parent | 141774be48940d56e3ad4dbf451d245b61d4f8b2 (diff) | |
download | rockbox-ca5bb76d2b8f65aa97e50b633f828c1deb241526.tar.gz rockbox-ca5bb76d2b8f65aa97e50b633f828c1deb241526.zip |
Delete the svn:executable property and set svn:eol-style to native for all those text files.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18012 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'utils/zenutils/libraries/zlib123/zlib/adler32.c')
-rw-r--r--[-rwxr-xr-x] | utils/zenutils/libraries/zlib123/zlib/adler32.c | 298 |
1 files changed, 149 insertions, 149 deletions
diff --git a/utils/zenutils/libraries/zlib123/zlib/adler32.c b/utils/zenutils/libraries/zlib123/zlib/adler32.c index f201d6701e..007ba26277 100755..100644 --- a/utils/zenutils/libraries/zlib123/zlib/adler32.c +++ b/utils/zenutils/libraries/zlib123/zlib/adler32.c | |||
@@ -1,149 +1,149 @@ | |||
1 | /* adler32.c -- compute the Adler-32 checksum of a data stream | 1 | /* adler32.c -- compute the Adler-32 checksum of a data stream |
2 | * Copyright (C) 1995-2004 Mark Adler | 2 | * Copyright (C) 1995-2004 Mark Adler |
3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
4 | */ | 4 | */ |
5 | 5 | ||
6 | /* @(#) $Id$ */ | 6 | /* @(#) $Id$ */ |
7 | 7 | ||
8 | #define ZLIB_INTERNAL | 8 | #define ZLIB_INTERNAL |
9 | #include "zlib.h" | 9 | #include "zlib.h" |
10 | 10 | ||
11 | #define BASE 65521UL /* largest prime smaller than 65536 */ | 11 | #define BASE 65521UL /* largest prime smaller than 65536 */ |
12 | #define NMAX 5552 | 12 | #define NMAX 5552 |
13 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ | 13 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ |
14 | 14 | ||
15 | #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | 15 | #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} |
16 | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | 16 | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); |
17 | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | 17 | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); |
18 | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | 18 | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); |
19 | #define DO16(buf) DO8(buf,0); DO8(buf,8); | 19 | #define DO16(buf) DO8(buf,0); DO8(buf,8); |
20 | 20 | ||
21 | /* use NO_DIVIDE if your processor does not do division in hardware */ | 21 | /* use NO_DIVIDE if your processor does not do division in hardware */ |
22 | #ifdef NO_DIVIDE | 22 | #ifdef NO_DIVIDE |
23 | # define MOD(a) \ | 23 | # define MOD(a) \ |
24 | do { \ | 24 | do { \ |
25 | if (a >= (BASE << 16)) a -= (BASE << 16); \ | 25 | if (a >= (BASE << 16)) a -= (BASE << 16); \ |
26 | if (a >= (BASE << 15)) a -= (BASE << 15); \ | 26 | if (a >= (BASE << 15)) a -= (BASE << 15); \ |
27 | if (a >= (BASE << 14)) a -= (BASE << 14); \ | 27 | if (a >= (BASE << 14)) a -= (BASE << 14); \ |
28 | if (a >= (BASE << 13)) a -= (BASE << 13); \ | 28 | if (a >= (BASE << 13)) a -= (BASE << 13); \ |
29 | if (a >= (BASE << 12)) a -= (BASE << 12); \ | 29 | if (a >= (BASE << 12)) a -= (BASE << 12); \ |
30 | if (a >= (BASE << 11)) a -= (BASE << 11); \ | 30 | if (a >= (BASE << 11)) a -= (BASE << 11); \ |
31 | if (a >= (BASE << 10)) a -= (BASE << 10); \ | 31 | if (a >= (BASE << 10)) a -= (BASE << 10); \ |
32 | if (a >= (BASE << 9)) a -= (BASE << 9); \ | 32 | if (a >= (BASE << 9)) a -= (BASE << 9); \ |
33 | if (a >= (BASE << 8)) a -= (BASE << 8); \ | 33 | if (a >= (BASE << 8)) a -= (BASE << 8); \ |
34 | if (a >= (BASE << 7)) a -= (BASE << 7); \ | 34 | if (a >= (BASE << 7)) a -= (BASE << 7); \ |
35 | if (a >= (BASE << 6)) a -= (BASE << 6); \ | 35 | if (a >= (BASE << 6)) a -= (BASE << 6); \ |
36 | if (a >= (BASE << 5)) a -= (BASE << 5); \ | 36 | if (a >= (BASE << 5)) a -= (BASE << 5); \ |
37 | if (a >= (BASE << 4)) a -= (BASE << 4); \ | 37 | if (a >= (BASE << 4)) a -= (BASE << 4); \ |
38 | if (a >= (BASE << 3)) a -= (BASE << 3); \ | 38 | if (a >= (BASE << 3)) a -= (BASE << 3); \ |
39 | if (a >= (BASE << 2)) a -= (BASE << 2); \ | 39 | if (a >= (BASE << 2)) a -= (BASE << 2); \ |
40 | if (a >= (BASE << 1)) a -= (BASE << 1); \ | 40 | if (a >= (BASE << 1)) a -= (BASE << 1); \ |
41 | if (a >= BASE) a -= BASE; \ | 41 | if (a >= BASE) a -= BASE; \ |
42 | } while (0) | 42 | } while (0) |
43 | # define MOD4(a) \ | 43 | # define MOD4(a) \ |
44 | do { \ | 44 | do { \ |
45 | if (a >= (BASE << 4)) a -= (BASE << 4); \ | 45 | if (a >= (BASE << 4)) a -= (BASE << 4); \ |
46 | if (a >= (BASE << 3)) a -= (BASE << 3); \ | 46 | if (a >= (BASE << 3)) a -= (BASE << 3); \ |
47 | if (a >= (BASE << 2)) a -= (BASE << 2); \ | 47 | if (a >= (BASE << 2)) a -= (BASE << 2); \ |
48 | if (a >= (BASE << 1)) a -= (BASE << 1); \ | 48 | if (a >= (BASE << 1)) a -= (BASE << 1); \ |
49 | if (a >= BASE) a -= BASE; \ | 49 | if (a >= BASE) a -= BASE; \ |
50 | } while (0) | 50 | } while (0) |
51 | #else | 51 | #else |
52 | # define MOD(a) a %= BASE | 52 | # define MOD(a) a %= BASE |
53 | # define MOD4(a) a %= BASE | 53 | # define MOD4(a) a %= BASE |
54 | #endif | 54 | #endif |
55 | 55 | ||
56 | /* ========================================================================= */ | 56 | /* ========================================================================= */ |
57 | uLong ZEXPORT adler32(adler, buf, len) | 57 | uLong ZEXPORT adler32(adler, buf, len) |
58 | uLong adler; | 58 | uLong adler; |
59 | const Bytef *buf; | 59 | const Bytef *buf; |
60 | uInt len; | 60 | uInt len; |
61 | { | 61 | { |
62 | unsigned long sum2; | 62 | unsigned long sum2; |
63 | unsigned n; | 63 | unsigned n; |
64 | 64 | ||
65 | /* split Adler-32 into component sums */ | 65 | /* split Adler-32 into component sums */ |
66 | sum2 = (adler >> 16) & 0xffff; | 66 | sum2 = (adler >> 16) & 0xffff; |
67 | adler &= 0xffff; | 67 | adler &= 0xffff; |
68 | 68 | ||
69 | /* in case user likes doing a byte at a time, keep it fast */ | 69 | /* in case user likes doing a byte at a time, keep it fast */ |
70 | if (len == 1) { | 70 | if (len == 1) { |
71 | adler += buf[0]; | 71 | adler += buf[0]; |
72 | if (adler >= BASE) | 72 | if (adler >= BASE) |
73 | adler -= BASE; | 73 | adler -= BASE; |
74 | sum2 += adler; | 74 | sum2 += adler; |
75 | if (sum2 >= BASE) | 75 | if (sum2 >= BASE) |
76 | sum2 -= BASE; | 76 | sum2 -= BASE; |
77 | return adler | (sum2 << 16); | 77 | return adler | (sum2 << 16); |
78 | } | 78 | } |
79 | 79 | ||
80 | /* initial Adler-32 value (deferred check for len == 1 speed) */ | 80 | /* initial Adler-32 value (deferred check for len == 1 speed) */ |
81 | if (buf == Z_NULL) | 81 | if (buf == Z_NULL) |
82 | return 1L; | 82 | return 1L; |
83 | 83 | ||
84 | /* in case short lengths are provided, keep it somewhat fast */ | 84 | /* in case short lengths are provided, keep it somewhat fast */ |
85 | if (len < 16) { | 85 | if (len < 16) { |
86 | while (len--) { | 86 | while (len--) { |
87 | adler += *buf++; | 87 | adler += *buf++; |
88 | sum2 += adler; | 88 | sum2 += adler; |
89 | } | 89 | } |
90 | if (adler >= BASE) | 90 | if (adler >= BASE) |
91 | adler -= BASE; | 91 | adler -= BASE; |
92 | MOD4(sum2); /* only added so many BASE's */ | 92 | MOD4(sum2); /* only added so many BASE's */ |
93 | return adler | (sum2 << 16); | 93 | return adler | (sum2 << 16); |
94 | } | 94 | } |
95 | 95 | ||
96 | /* do length NMAX blocks -- requires just one modulo operation */ | 96 | /* do length NMAX blocks -- requires just one modulo operation */ |
97 | while (len >= NMAX) { | 97 | while (len >= NMAX) { |
98 | len -= NMAX; | 98 | len -= NMAX; |
99 | n = NMAX / 16; /* NMAX is divisible by 16 */ | 99 | n = NMAX / 16; /* NMAX is divisible by 16 */ |
100 | do { | 100 | do { |
101 | DO16(buf); /* 16 sums unrolled */ | 101 | DO16(buf); /* 16 sums unrolled */ |
102 | buf += 16; | 102 | buf += 16; |
103 | } while (--n); | 103 | } while (--n); |
104 | MOD(adler); | 104 | MOD(adler); |
105 | MOD(sum2); | 105 | MOD(sum2); |
106 | } | 106 | } |
107 | 107 | ||
108 | /* do remaining bytes (less than NMAX, still just one modulo) */ | 108 | /* do remaining bytes (less than NMAX, still just one modulo) */ |
109 | if (len) { /* avoid modulos if none remaining */ | 109 | if (len) { /* avoid modulos if none remaining */ |
110 | while (len >= 16) { | 110 | while (len >= 16) { |
111 | len -= 16; | 111 | len -= 16; |
112 | DO16(buf); | 112 | DO16(buf); |
113 | buf += 16; | 113 | buf += 16; |
114 | } | 114 | } |
115 | while (len--) { | 115 | while (len--) { |
116 | adler += *buf++; | 116 | adler += *buf++; |
117 | sum2 += adler; | 117 | sum2 += adler; |
118 | } | 118 | } |
119 | MOD(adler); | 119 | MOD(adler); |
120 | MOD(sum2); | 120 | MOD(sum2); |
121 | } | 121 | } |
122 | 122 | ||
123 | /* return recombined sums */ | 123 | /* return recombined sums */ |
124 | return adler | (sum2 << 16); | 124 | return adler | (sum2 << 16); |
125 | } | 125 | } |
126 | 126 | ||
127 | /* ========================================================================= */ | 127 | /* ========================================================================= */ |
128 | uLong ZEXPORT adler32_combine(adler1, adler2, len2) | 128 | uLong ZEXPORT adler32_combine(adler1, adler2, len2) |
129 | uLong adler1; | 129 | uLong adler1; |
130 | uLong adler2; | 130 | uLong adler2; |
131 | z_off_t len2; | 131 | z_off_t len2; |
132 | { | 132 | { |
133 | unsigned long sum1; | 133 | unsigned long sum1; |
134 | unsigned long sum2; | 134 | unsigned long sum2; |
135 | unsigned rem; | 135 | unsigned rem; |
136 | 136 | ||
137 | /* the derivation of this formula is left as an exercise for the reader */ | 137 | /* the derivation of this formula is left as an exercise for the reader */ |
138 | rem = (unsigned)(len2 % BASE); | 138 | rem = (unsigned)(len2 % BASE); |
139 | sum1 = adler1 & 0xffff; | 139 | sum1 = adler1 & 0xffff; |
140 | sum2 = rem * sum1; | 140 | sum2 = rem * sum1; |
141 | MOD(sum2); | 141 | MOD(sum2); |
142 | sum1 += (adler2 & 0xffff) + BASE - 1; | 142 | sum1 += (adler2 & 0xffff) + BASE - 1; |
143 | sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; | 143 | sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; |
144 | if (sum1 > BASE) sum1 -= BASE; | 144 | if (sum1 > BASE) sum1 -= BASE; |
145 | if (sum1 > BASE) sum1 -= BASE; | 145 | if (sum1 > BASE) sum1 -= BASE; |
146 | if (sum2 > (BASE << 1)) sum2 -= (BASE << 1); | 146 | if (sum2 > (BASE << 1)) sum2 -= (BASE << 1); |
147 | if (sum2 > BASE) sum2 -= BASE; | 147 | if (sum2 > BASE) sum2 -= BASE; |
148 | return sum1 | (sum2 << 16); | 148 | return sum1 | (sum2 << 16); |
149 | } | 149 | } |