blob: f37e33f1c9925113b9a9cc1b87feba6d07bca064
1 | /* $Id: tif_swab.c,v 1.13 2010-03-10 18:56:49 bfriesen Exp $ */ |
2 | |
3 | /* |
4 | * Copyright (c) 1988-1997 Sam Leffler |
5 | * Copyright (c) 1991-1997 Silicon Graphics, Inc. |
6 | * |
7 | * Permission to use, copy, modify, distribute, and sell this software and |
8 | * its documentation for any purpose is hereby granted without fee, provided |
9 | * that (i) the above copyright notices and this permission notice appear in |
10 | * all copies of the software and related documentation, and (ii) the names of |
11 | * Sam Leffler and Silicon Graphics may not be used in any advertising or |
12 | * publicity relating to the software without the specific, prior written |
13 | * permission of Sam Leffler and Silicon Graphics. |
14 | * |
15 | * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, |
16 | * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY |
17 | * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. |
18 | * |
19 | * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR |
20 | * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, |
21 | * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
22 | * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF |
23 | * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
24 | * OF THIS SOFTWARE. |
25 | */ |
26 | |
27 | /* |
28 | * TIFF Library Bit & Byte Swapping Support. |
29 | * |
30 | * XXX We assume short = 16-bits and long = 32-bits XXX |
31 | */ |
32 | #include "tiffiop.h" |
33 | |
34 | #ifndef TIFFSwabShort |
35 | void |
36 | TIFFSwabShort(uint16* wp) |
37 | { |
38 | register unsigned char* cp = (unsigned char*) wp; |
39 | unsigned char t; |
40 | assert(sizeof(uint16)==2); |
41 | t = cp[1]; cp[1] = cp[0]; cp[0] = t; |
42 | } |
43 | #endif |
44 | |
45 | #ifndef TIFFSwabLong |
46 | void |
47 | TIFFSwabLong(uint32* lp) |
48 | { |
49 | register unsigned char* cp = (unsigned char*) lp; |
50 | unsigned char t; |
51 | assert(sizeof(uint32)==4); |
52 | t = cp[3]; cp[3] = cp[0]; cp[0] = t; |
53 | t = cp[2]; cp[2] = cp[1]; cp[1] = t; |
54 | } |
55 | #endif |
56 | |
57 | #ifndef TIFFSwabLong8 |
58 | void |
59 | TIFFSwabLong8(uint64* lp) |
60 | { |
61 | register unsigned char* cp = (unsigned char*) lp; |
62 | unsigned char t; |
63 | assert(sizeof(uint64)==8); |
64 | t = cp[7]; cp[7] = cp[0]; cp[0] = t; |
65 | t = cp[6]; cp[6] = cp[1]; cp[1] = t; |
66 | t = cp[5]; cp[5] = cp[2]; cp[2] = t; |
67 | t = cp[4]; cp[4] = cp[3]; cp[3] = t; |
68 | } |
69 | #endif |
70 | |
71 | #ifndef TIFFSwabArrayOfShort |
72 | void |
73 | TIFFSwabArrayOfShort(register uint16* wp, tmsize_t n) |
74 | { |
75 | register unsigned char* cp; |
76 | register unsigned char t; |
77 | assert(sizeof(uint16)==2); |
78 | /* XXX unroll loop some */ |
79 | while (n-- > 0) { |
80 | cp = (unsigned char*) wp; |
81 | t = cp[1]; cp[1] = cp[0]; cp[0] = t; |
82 | wp++; |
83 | } |
84 | } |
85 | #endif |
86 | |
87 | #ifndef TIFFSwabArrayOfTriples |
88 | void |
89 | TIFFSwabArrayOfTriples(register uint8* tp, tmsize_t n) |
90 | { |
91 | unsigned char* cp; |
92 | unsigned char t; |
93 | |
94 | /* XXX unroll loop some */ |
95 | while (n-- > 0) { |
96 | cp = (unsigned char*) tp; |
97 | t = cp[2]; cp[2] = cp[0]; cp[0] = t; |
98 | tp += 3; |
99 | } |
100 | } |
101 | #endif |
102 | |
103 | #ifndef TIFFSwabArrayOfLong |
104 | void |
105 | TIFFSwabArrayOfLong(register uint32* lp, tmsize_t n) |
106 | { |
107 | register unsigned char *cp; |
108 | register unsigned char t; |
109 | assert(sizeof(uint32)==4); |
110 | /* XXX unroll loop some */ |
111 | while (n-- > 0) { |
112 | cp = (unsigned char *)lp; |
113 | t = cp[3]; cp[3] = cp[0]; cp[0] = t; |
114 | t = cp[2]; cp[2] = cp[1]; cp[1] = t; |
115 | lp++; |
116 | } |
117 | } |
118 | #endif |
119 | |
120 | #ifndef TIFFSwabArrayOfLong8 |
121 | void |
122 | TIFFSwabArrayOfLong8(register uint64* lp, tmsize_t n) |
123 | { |
124 | register unsigned char *cp; |
125 | register unsigned char t; |
126 | assert(sizeof(uint64)==8); |
127 | /* XXX unroll loop some */ |
128 | while (n-- > 0) { |
129 | cp = (unsigned char *)lp; |
130 | t = cp[7]; cp[7] = cp[0]; cp[0] = t; |
131 | t = cp[6]; cp[6] = cp[1]; cp[1] = t; |
132 | t = cp[5]; cp[5] = cp[2]; cp[2] = t; |
133 | t = cp[4]; cp[4] = cp[3]; cp[3] = t; |
134 | lp++; |
135 | } |
136 | } |
137 | #endif |
138 | |
139 | #ifndef TIFFSwabFloat |
140 | void |
141 | TIFFSwabFloat(float* fp) |
142 | { |
143 | register unsigned char* cp = (unsigned char*) fp; |
144 | unsigned char t; |
145 | assert(sizeof(float)==4); |
146 | t = cp[3]; cp[3] = cp[0]; cp[0] = t; |
147 | t = cp[2]; cp[2] = cp[1]; cp[1] = t; |
148 | } |
149 | #endif |
150 | |
151 | #ifndef TIFFSwabArrayOfFloat |
152 | void |
153 | TIFFSwabArrayOfFloat(register float* fp, tmsize_t n) |
154 | { |
155 | register unsigned char *cp; |
156 | register unsigned char t; |
157 | assert(sizeof(float)==4); |
158 | /* XXX unroll loop some */ |
159 | while (n-- > 0) { |
160 | cp = (unsigned char *)fp; |
161 | t = cp[3]; cp[3] = cp[0]; cp[0] = t; |
162 | t = cp[2]; cp[2] = cp[1]; cp[1] = t; |
163 | fp++; |
164 | } |
165 | } |
166 | #endif |
167 | |
168 | #ifndef TIFFSwabDouble |
169 | void |
170 | TIFFSwabDouble(double *dp) |
171 | { |
172 | register unsigned char* cp = (unsigned char*) dp; |
173 | unsigned char t; |
174 | assert(sizeof(double)==8); |
175 | t = cp[7]; cp[7] = cp[0]; cp[0] = t; |
176 | t = cp[6]; cp[6] = cp[1]; cp[1] = t; |
177 | t = cp[5]; cp[5] = cp[2]; cp[2] = t; |
178 | t = cp[4]; cp[4] = cp[3]; cp[3] = t; |
179 | } |
180 | #endif |
181 | |
182 | #ifndef TIFFSwabArrayOfDouble |
183 | void |
184 | TIFFSwabArrayOfDouble(double* dp, tmsize_t n) |
185 | { |
186 | register unsigned char *cp; |
187 | register unsigned char t; |
188 | assert(sizeof(double)==8); |
189 | /* XXX unroll loop some */ |
190 | while (n-- > 0) { |
191 | cp = (unsigned char *)dp; |
192 | t = cp[7]; cp[7] = cp[0]; cp[0] = t; |
193 | t = cp[6]; cp[6] = cp[1]; cp[1] = t; |
194 | t = cp[5]; cp[5] = cp[2]; cp[2] = t; |
195 | t = cp[4]; cp[4] = cp[3]; cp[3] = t; |
196 | dp++; |
197 | } |
198 | } |
199 | #endif |
200 | |
201 | /* |
202 | * Bit reversal tables. TIFFBitRevTable[<byte>] gives |
203 | * the bit reversed value of <byte>. Used in various |
204 | * places in the library when the FillOrder requires |
205 | * bit reversal of byte values (e.g. CCITT Fax 3 |
206 | * encoding/decoding). TIFFNoBitRevTable is provided |
207 | * for algorithms that want an equivalent table that |
208 | * do not reverse bit values. |
209 | */ |
210 | static const unsigned char TIFFBitRevTable[256] = { |
211 | 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, |
212 | 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, |
213 | 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, |
214 | 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, |
215 | 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, |
216 | 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, |
217 | 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, |
218 | 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, |
219 | 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, |
220 | 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, |
221 | 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, |
222 | 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, |
223 | 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, |
224 | 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, |
225 | 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, |
226 | 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, |
227 | 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, |
228 | 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, |
229 | 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, |
230 | 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, |
231 | 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, |
232 | 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, |
233 | 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, |
234 | 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, |
235 | 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, |
236 | 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, |
237 | 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, |
238 | 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, |
239 | 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, |
240 | 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, |
241 | 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, |
242 | 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff |
243 | }; |
244 | static const unsigned char TIFFNoBitRevTable[256] = { |
245 | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, |
246 | 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, |
247 | 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, |
248 | 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, |
249 | 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, |
250 | 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, |
251 | 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, |
252 | 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, |
253 | 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, |
254 | 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, |
255 | 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, |
256 | 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, |
257 | 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, |
258 | 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, |
259 | 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, |
260 | 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, |
261 | 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, |
262 | 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, |
263 | 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, |
264 | 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, |
265 | 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, |
266 | 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, |
267 | 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, |
268 | 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, |
269 | 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, |
270 | 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, |
271 | 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, |
272 | 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, |
273 | 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, |
274 | 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, |
275 | 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, |
276 | 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, |
277 | }; |
278 | |
279 | const unsigned char* |
280 | TIFFGetBitRevTable(int reversed) |
281 | { |
282 | return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable); |
283 | } |
284 | |
285 | void |
286 | TIFFReverseBits(uint8* cp, tmsize_t n) |
287 | { |
288 | for (; n > 8; n -= 8) { |
289 | cp[0] = TIFFBitRevTable[cp[0]]; |
290 | cp[1] = TIFFBitRevTable[cp[1]]; |
291 | cp[2] = TIFFBitRevTable[cp[2]]; |
292 | cp[3] = TIFFBitRevTable[cp[3]]; |
293 | cp[4] = TIFFBitRevTable[cp[4]]; |
294 | cp[5] = TIFFBitRevTable[cp[5]]; |
295 | cp[6] = TIFFBitRevTable[cp[6]]; |
296 | cp[7] = TIFFBitRevTable[cp[7]]; |
297 | cp += 8; |
298 | } |
299 | while (n-- > 0) |
300 | *cp = TIFFBitRevTable[*cp], cp++; |
301 | } |
302 | |
303 | /* vim: set ts=8 sts=8 sw=8 noet: */ |
304 | /* |
305 | * Local Variables: |
306 | * mode: c |
307 | * c-basic-offset: 8 |
308 | * fill-column: 78 |
309 | * End: |
310 | */ |
311 |