← Back to branch summary

~ubuntu-branches/ubuntu/vivid/grass/vivid-proposed

« back to all changes in this revision

Viewing changes to raster/r.out.bin/tif_swab.c

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-02-20 23:12:08 UTC
  • mfrom: (8.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20150220231208-1u6qvqm84v430b10
Tags: 7.0.0-1~exp1
* New upstream release.
* Update python-ctypes-ternary.patch to use if/else instead of and/or.
* Drop check4dev patch, rely on upstream check.
* Add build dependency on libpq-dev to grass-dev for libpq-fe.h.
* Drop patches applied upstream, refresh remaining patches.
* Update symlinks for images switched from jpg to png.

Show diffs side-by-side

added added

removed removed

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