libs/tiff/libtiff/tif_swab.c

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