reactos/dll/3rdparty/libtiff/tif_swab.c

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