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