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