src/tiff/libtiff/tif_swab.c

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