Home | History | Annotate | Download | only in libtiff
      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  */
    311