opencv

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
{
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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

305
const unsigned char *TIFFGetBitRevTable(int reversed)
306
{
307
    return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
308
}
309

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