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)
33 void
TIFFSwabShort(uint16_t * wp)34 TIFFSwabShort(uint16_t* wp)
35 {
36 register unsigned char* cp = (unsigned char*) wp;
37 unsigned char t;
38 assert(sizeof(uint16_t) == 2);
39 t = cp[1]; cp[1] = cp[0]; cp[0] = t;
40 }
41 #endif
42
43 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong)
44 void
TIFFSwabLong(uint32_t * lp)45 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]; cp[3] = cp[0]; cp[0] = t;
51 t = cp[2]; cp[2] = cp[1]; cp[1] = t;
52 }
53 #endif
54
55 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong8)
56 void
TIFFSwabLong8(uint64_t * lp)57 TIFFSwabLong8(uint64_t* lp)
58 {
59 register unsigned char* cp = (unsigned char*) lp;
60 unsigned char t;
61 assert(sizeof(uint64_t) == 8);
62 t = cp[7]; cp[7] = cp[0]; cp[0] = t;
63 t = cp[6]; cp[6] = cp[1]; cp[1] = t;
64 t = cp[5]; cp[5] = cp[2]; cp[2] = t;
65 t = cp[4]; cp[4] = cp[3]; cp[3] = t;
66 }
67 #endif
68
69 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfShort)
70 void
TIFFSwabArrayOfShort(register uint16_t * wp,tmsize_t n)71 TIFFSwabArrayOfShort(register uint16_t* wp, tmsize_t n)
72 {
73 register unsigned char* cp;
74 register unsigned char t;
75 assert(sizeof(uint16_t) == 2);
76 /* XXX unroll loop some */
77 while (n-- > 0) {
78 cp = (unsigned char*) wp;
79 t = cp[1]; cp[1] = cp[0]; cp[0] = t;
80 wp++;
81 }
82 }
83 #endif
84
85 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfTriples)
86 void
TIFFSwabArrayOfTriples(register uint8_t * tp,tmsize_t n)87 TIFFSwabArrayOfTriples(register uint8_t* tp, tmsize_t n)
88 {
89 unsigned char* cp;
90 unsigned char t;
91
92 /* XXX unroll loop some */
93 while (n-- > 0) {
94 cp = (unsigned char*) tp;
95 t = cp[2]; cp[2] = cp[0]; cp[0] = t;
96 tp += 3;
97 }
98 }
99 #endif
100
101 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong)
102 void
TIFFSwabArrayOfLong(register uint32_t * lp,tmsize_t n)103 TIFFSwabArrayOfLong(register uint32_t* lp, tmsize_t n)
104 {
105 register unsigned char *cp;
106 register unsigned char t;
107 assert(sizeof(uint32_t) == 4);
108 /* XXX unroll loop some */
109 while (n-- > 0) {
110 cp = (unsigned char *)lp;
111 t = cp[3]; cp[3] = cp[0]; cp[0] = t;
112 t = cp[2]; cp[2] = cp[1]; cp[1] = t;
113 lp++;
114 }
115 }
116 #endif
117
118 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong8)
119 void
TIFFSwabArrayOfLong8(register uint64_t * lp,tmsize_t n)120 TIFFSwabArrayOfLong8(register uint64_t* lp, tmsize_t n)
121 {
122 register unsigned char *cp;
123 register unsigned char t;
124 assert(sizeof(uint64_t) == 8);
125 /* XXX unroll loop some */
126 while (n-- > 0) {
127 cp = (unsigned char *)lp;
128 t = cp[7]; cp[7] = cp[0]; cp[0] = t;
129 t = cp[6]; cp[6] = cp[1]; cp[1] = t;
130 t = cp[5]; cp[5] = cp[2]; cp[2] = t;
131 t = cp[4]; cp[4] = cp[3]; cp[3] = t;
132 lp++;
133 }
134 }
135 #endif
136
137 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabFloat)
138 void
TIFFSwabFloat(float * fp)139 TIFFSwabFloat(float* fp)
140 {
141 register unsigned char* cp = (unsigned char*) fp;
142 unsigned char t;
143 assert(sizeof(float)==4);
144 t = cp[3]; cp[3] = cp[0]; cp[0] = t;
145 t = cp[2]; cp[2] = cp[1]; cp[1] = t;
146 }
147 #endif
148
149 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfFloat)
150 void
TIFFSwabArrayOfFloat(register float * fp,tmsize_t n)151 TIFFSwabArrayOfFloat(register float* fp, tmsize_t n)
152 {
153 register unsigned char *cp;
154 register unsigned char t;
155 assert(sizeof(float)==4);
156 /* XXX unroll loop some */
157 while (n-- > 0) {
158 cp = (unsigned char *)fp;
159 t = cp[3]; cp[3] = cp[0]; cp[0] = t;
160 t = cp[2]; cp[2] = cp[1]; cp[1] = t;
161 fp++;
162 }
163 }
164 #endif
165
166 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabDouble)
167 void
TIFFSwabDouble(double * dp)168 TIFFSwabDouble(double *dp)
169 {
170 register unsigned char* cp = (unsigned char*) dp;
171 unsigned char t;
172 assert(sizeof(double)==8);
173 t = cp[7]; cp[7] = cp[0]; cp[0] = t;
174 t = cp[6]; cp[6] = cp[1]; cp[1] = t;
175 t = cp[5]; cp[5] = cp[2]; cp[2] = t;
176 t = cp[4]; cp[4] = cp[3]; cp[3] = t;
177 }
178 #endif
179
180 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfDouble)
181 void
TIFFSwabArrayOfDouble(double * dp,tmsize_t n)182 TIFFSwabArrayOfDouble(double* dp, tmsize_t n)
183 {
184 register unsigned char *cp;
185 register unsigned char t;
186 assert(sizeof(double)==8);
187 /* XXX unroll loop some */
188 while (n-- > 0) {
189 cp = (unsigned char *)dp;
190 t = cp[7]; cp[7] = cp[0]; cp[0] = t;
191 t = cp[6]; cp[6] = cp[1]; cp[1] = t;
192 t = cp[5]; cp[5] = cp[2]; cp[2] = t;
193 t = cp[4]; cp[4] = cp[3]; cp[3] = t;
194 dp++;
195 }
196 }
197 #endif
198
199 /*
200 * Bit reversal tables. TIFFBitRevTable[<byte>] gives
201 * the bit reversed value of <byte>. Used in various
202 * places in the library when the FillOrder requires
203 * bit reversal of byte values (e.g. CCITT Fax 3
204 * encoding/decoding). TIFFNoBitRevTable is provided
205 * for algorithms that want an equivalent table that
206 * do not reverse bit values.
207 */
208 static const unsigned char TIFFBitRevTable[256] = {
209 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
210 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
211 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
212 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
213 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
214 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
215 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
216 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
217 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
218 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
219 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
220 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
221 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
222 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
223 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
224 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
225 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
226 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
227 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
228 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
229 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
230 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
231 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
232 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
233 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
234 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
235 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
236 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
237 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
238 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
239 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
240 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
241 };
242 static const unsigned char TIFFNoBitRevTable[256] = {
243 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
244 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
245 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
246 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
247 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
248 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
249 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
250 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
251 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
252 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
253 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
254 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
255 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
256 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
257 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
258 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
259 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
260 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
261 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
262 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
263 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
264 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
265 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
266 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
267 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
268 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
269 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
270 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
271 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
272 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
273 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
274 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
275 };
276
277 const unsigned char*
TIFFGetBitRevTable(int reversed)278 TIFFGetBitRevTable(int reversed)
279 {
280 return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
281 }
282
283 void
TIFFReverseBits(uint8_t * cp,tmsize_t n)284 TIFFReverseBits(uint8_t* cp, tmsize_t n)
285 {
286 for (; n > 8; n -= 8) {
287 cp[0] = TIFFBitRevTable[cp[0]];
288 cp[1] = TIFFBitRevTable[cp[1]];
289 cp[2] = TIFFBitRevTable[cp[2]];
290 cp[3] = TIFFBitRevTable[cp[3]];
291 cp[4] = TIFFBitRevTable[cp[4]];
292 cp[5] = TIFFBitRevTable[cp[5]];
293 cp[6] = TIFFBitRevTable[cp[6]];
294 cp[7] = TIFFBitRevTable[cp[7]];
295 cp += 8;
296 }
297 while (n-- > 0) {
298 *cp = TIFFBitRevTable[*cp];
299 cp++;
300 }
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