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