src/tiff/libtiff/tif_swab.c

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