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 #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  */