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