thirdparty/libtiff/tif_packbits.c

   1 /* $Id: tif_packbits.c,v 1.22 2012-06-20 05:25:33 fwarmerdam 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 #include "tiffiop.h"
  28 #ifdef PACKBITS_SUPPORT
  29 /*
  30  * TIFF Library.
  31  *
  32  * PackBits Compression Algorithm Support
  33  */
  34 #include <stdio.h>
  35
  36 static int
  37 PackBitsPreEncode(TIFF* tif, uint16 s)
  38 {
  39         (void) s;
  40
  41         if (!(tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t))))
  42                 return (0);
  43         /*
  44          * Calculate the scanline/tile-width size in bytes.
  45          */
  46         if (isTiled(tif))
  47                 *(tmsize_t*)tif->tif_data = TIFFTileRowSize(tif);
  48         else
  49                 *(tmsize_t*)tif->tif_data = TIFFScanlineSize(tif);
  50         return (1);
  51 }
  52
  53 static int
  54 PackBitsPostEncode(TIFF* tif)
  55 {
  56         if (tif->tif_data)
  57             _TIFFfree(tif->tif_data);
  58         return (1);
  59 }
  60
  61 /*
  62  * Encode a run of pixels.
  63  */
  64 static int
  65 PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
  66 {
  67         unsigned char* bp = (unsigned char*) buf;
  68         uint8* op;
  69         uint8* ep;
  70         uint8* lastliteral;
  71         long n, slop;
  72         int b;
  73         enum { BASE, LITERAL, RUN, LITERAL_RUN } state;
  74
  75         (void) s;
  76         op = tif->tif_rawcp;
  77         ep = tif->tif_rawdata + tif->tif_rawdatasize;
  78         state = BASE;
  79         lastliteral = 0;
  80         while (cc > 0) {
  81                 /*
  82                  * Find the longest string of identical bytes.
  83                  */
  84                 b = *bp++, cc--, n = 1;
  85                 for (; cc > 0 && b == *bp; cc--, bp++)
  86                         n++;
  87         again:
  88                 if (op + 2 >= ep) {             /* insure space for new data */
  89                         /*
  90                          * Be careful about writing the last
  91                          * literal.  Must write up to that point
  92                          * and then copy the remainder to the
  93                          * front of the buffer.
  94                          */
  95                         if (state == LITERAL || state == LITERAL_RUN) {
  96                                 slop = (long)(op - lastliteral);
  97                                 tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
  98                                 if (!TIFFFlushData1(tif))
  99                                         return (-1);
 100                                 op = tif->tif_rawcp;
 101                                 while (slop-- > 0)
 102                                         *op++ = *lastliteral++;
 103                                 lastliteral = tif->tif_rawcp;
 104                         } else {
 105                                 tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
 106                                 if (!TIFFFlushData1(tif))
 107                                         return (-1);
 108                                 op = tif->tif_rawcp;
 109                         }
 110                 }
 111                 switch (state) {
 112                 case BASE:              /* initial state, set run/literal */
 113                         if (n > 1) {
 114                                 state = RUN;
 115                                 if (n > 128) {
 116                                         *op++ = (uint8) -127;
 117                                         *op++ = (uint8) b;
 118                                         n -= 128;
 119                                         goto again;
 120                                 }
 121                                 *op++ = (uint8)(-(n-1));
 122                                 *op++ = (uint8) b;
 123                         } else {
 124                                 lastliteral = op;
 125                                 *op++ = 0;
 126                                 *op++ = (uint8) b;
 127                                 state = LITERAL;
 128                         }
 129                         break;
 130                 case LITERAL:           /* last object was literal string */
 131                         if (n > 1) {
 132                                 state = LITERAL_RUN;
 133                                 if (n > 128) {
 134                                         *op++ = (uint8) -127;
 135                                         *op++ = (uint8) b;
 136                                         n -= 128;
 137                                         goto again;
 138                                 }
 139                                 *op++ = (uint8)(-(n-1));        /* encode run */
 140                                 *op++ = (uint8) b;
 141                         } else {                        /* extend literal */
 142                                 if (++(*lastliteral) == 127)
 143                                         state = BASE;
 144                                 *op++ = (uint8) b;
 145                         }
 146                         break;
 147                 case RUN:               /* last object was run */
 148                         if (n > 1) {
 149                                 if (n > 128) {
 150                                         *op++ = (uint8) -127;
 151                                         *op++ = (uint8) b;
 152                                         n -= 128;
 153                                         goto again;
 154                                 }
 155                                 *op++ = (uint8)(-(n-1));
 156                                 *op++ = (uint8) b;
 157                         } else {
 158                                 lastliteral = op;
 159                                 *op++ = 0;
 160                                 *op++ = (uint8) b;
 161                                 state = LITERAL;
 162                         }
 163                         break;
 164                 case LITERAL_RUN:       /* literal followed by a run */
 165                         /*
 166                          * Check to see if previous run should
 167                          * be converted to a literal, in which
 168                          * case we convert literal-run-literal
 169                          * to a single literal.
 170                          */
 171                         if (n == 1 && op[-2] == (uint8) -1 &&
 172                             *lastliteral < 126) {
 173                                 state = (((*lastliteral) += 2) == 127 ?
 174                                     BASE : LITERAL);
 175                                 op[-2] = op[-1];        /* replicate */
 176                         } else
 177                                 state = RUN;
 178                         goto again;
 179                 }
 180         }
 181         tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
 182         tif->tif_rawcp = op;
 183         return (1);
 184 }
 185
 186 /*
 187  * Encode a rectangular chunk of pixels.  We break it up
 188  * into row-sized pieces to insure that encoded runs do
 189  * not span rows.  Otherwise, there can be problems with
 190  * the decoder if data is read, for example, by scanlines
 191  * when it was encoded by strips.
 192  */
 193 static int
 194 PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 195 {
 196         tmsize_t rowsize = *(tmsize_t*)tif->tif_data;
 197
 198         while (cc > 0) {
 199                 tmsize_t chunk = rowsize;
 200
 201                 if( cc < chunk )
 202                     chunk = cc;
 203
 204                 if (PackBitsEncode(tif, bp, chunk, s) < 0)
 205                     return (-1);
 206                 bp += chunk;
 207                 cc -= chunk;
 208         }
 209         return (1);
 210 }
 211
 212 static int
 213 PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 214 {
 215         static const char module[] = "PackBitsDecode";
 216         char *bp;
 217         tmsize_t cc;
 218         long n;
 219         int b;
 220
 221         (void) s;
 222         bp = (char*) tif->tif_rawcp;
 223         cc = tif->tif_rawcc;
 224         while (cc > 0 && occ > 0) {
 225                 n = (long) *bp++, cc--;
 226                 /*
 227                  * Watch out for compilers that
 228                  * don't sign extend chars...
 229                  */
 230                 if (n >= 128)
 231                         n -= 256;
 232                 if (n < 0) {            /* replicate next byte -n+1 times */
 233                         if (n == -128)  /* nop */
 234                                 continue;
 235                         n = -n + 1;
 236                         if( occ < (tmsize_t)n )
 237                         {
 238                                 TIFFWarningExt(tif->tif_clientdata, module,
 239                                     "Discarding %lu bytes to avoid buffer overrun",
 240                                     (unsigned long) ((tmsize_t)n - occ));
 241                                 n = (long)occ;
 242                         }
 243                         occ -= n;
 244                         b = *bp++, cc--;
 245                         while (n-- > 0)
 246                                 *op++ = (uint8) b;
 247                 } else {                /* copy next n+1 bytes literally */
 248                         if (occ < (tmsize_t)(n + 1))
 249                         {
 250                                 TIFFWarningExt(tif->tif_clientdata, module,
 251                                     "Discarding %lu bytes to avoid buffer overrun",
 252                                     (unsigned long) ((tmsize_t)n - occ + 1));
 253                                 n = (long)occ - 1;
 254                         }
 255                         if (cc < (tmsize_t) (n+1))
 256                         {
 257                                 TIFFWarningExt(tif->tif_clientdata, module,
 258                                                "Terminating PackBitsDecode due to lack of data.");
 259                                 break;
 260                         }
 261                         _TIFFmemcpy(op, bp, ++n);
 262                         op += n; occ -= n;
 263                         bp += n; cc -= n;
 264                 }
 265         }
 266         tif->tif_rawcp = (uint8*) bp;
 267         tif->tif_rawcc = cc;
 268         if (occ > 0) {
 269                 TIFFErrorExt(tif->tif_clientdata, module,
 270                     "Not enough data for scanline %lu",
 271                     (unsigned long) tif->tif_row);
 272                 return (0);
 273         }
 274         return (1);
 275 }
 276
 277 int
 278 TIFFInitPackBits(TIFF* tif, int scheme)
 279 {
 280         (void) scheme;
 281         tif->tif_decoderow = PackBitsDecode;
 282         tif->tif_decodestrip = PackBitsDecode;
 283         tif->tif_decodetile = PackBitsDecode;
 284         tif->tif_preencode = PackBitsPreEncode;
 285         tif->tif_postencode = PackBitsPostEncode;
 286         tif->tif_encoderow = PackBitsEncode;
 287         tif->tif_encodestrip = PackBitsEncodeChunk;
 288         tif->tif_encodetile = PackBitsEncodeChunk;
 289         return (1);
 290 }
 291 #endif /* PACKBITS_SUPPORT */
 292
 293 /* vim: set ts=8 sts=8 sw=8 noet: */
 294 /*
 295  * Local Variables:
 296  * mode: c
 297  * c-basic-offset: 8
 298  * fill-column: 78
 299  * End:
 300  */