XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_lzw.c

-/* $Id: tif_lzw.c,v 1.45 2011-04-02 20:54:09 bfriesen Exp $ */
+/* $Id: tif_lzw.c,v 1.49 2015-08-30 21:07:44 erouault Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  *
  * Permission to use, copy, modify, distribute, and sell this software and 
  * its documentation for any purpose is hereby granted without fee, provided
  * that (i) the above copyright notices and this permission notice appear in
  * all copies of the software and related documentation, and (ii) the names of
  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  * publicity relating to the software without the specific, prior written
  * permission of Sam Leffler and Silicon Graphics.
  * 
  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  * 
  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  * OF THIS SOFTWARE.
  */
+
 #include "tiffiop.h"
 #ifdef LZW_SUPPORT
 /*
  * TIFF Library.  
  * Rev 5.0 Lempel-Ziv & Welch Compression Support
  *
  * This code is derived from the compress program whose code is
  * derived from software contributed to Berkeley by James A. Woods,
  * derived from original work by Spencer Thomas and Joseph Orost.
  *
@@ skipping 50 matching lines @@
  * State block for each open TIFF file using LZW
  * compression/decompression.  Note that the predictor
  * state block must be first in this data structure.
  */
 typedef struct {
         TIFFPredictorState predict;     /* predictor super class */
 
         unsigned short  nbits;          /* # of bits/code */
         unsigned short  maxcode;        /* maximum code for lzw_nbits */
         unsigned short  free_ent;       /* next free entry in hash table */
-        long            nextdata;       /* next bits of i/o */
+        unsigned long   nextdata;       /* next bits of i/o */
         long            nextbits;       /* # of valid bits in lzw_nextdata */
 
         int             rw_mode;        /* preserve rw_mode from init */
 } LZWBaseState;
 
 #define lzw_nbits       base.nbits
 #define lzw_maxcode     base.maxcode
 #define lzw_free_ent    base.free_ent
 #define lzw_nextdata    base.nextdata
 #define lzw_nextbits    base.nextbits
@@ skipping 153 matching lines @@
 LZWPreDecode(TIFF* tif, uint16 s)
 {
         static const char module[] = "LZWPreDecode";
         LZWCodecState *sp = DecoderState(tif);
 
         (void) s;
         assert(sp != NULL);
         if( sp->dec_codetab == NULL )
         {
             tif->tif_setupdecode( tif );
+            if( sp->dec_codetab == NULL )
+                return (0);
         }
 
         /*
          * Check for old bit-reversed codes.
          */
         if (tif->tif_rawdata[0] == 0 && (tif->tif_rawdata[1] & 0x1)) {
 #ifdef LZW_COMPAT
                 if (!sp->dec_decode) {
                         TIFFWarningExt(tif->tif_clientdata, module,
                             "Old-style LZW codes, convert file");
@@ skipping 77 matching lines @@
 LZWDecode(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s)
 {
         static const char module[] = "LZWDecode";
         LZWCodecState *sp = DecoderState(tif);
         char *op = (char*) op0;
         long occ = (long) occ0;
         char *tp;
         unsigned char *bp;
         hcode_t code;
         int len;
-        long nbits, nextbits, nextdata, nbitsmask;
+        long nbits, nextbits, nbitsmask;
+        unsigned long nextdata;
         code_t *codep, *free_entp, *maxcodep, *oldcodep;
 
         (void) s;
         assert(sp != NULL);
         assert(sp->dec_codetab != NULL);
 
         /*
           Fail if value does not fit in long.
         */
         if ((tmsize_t) occ != occ0)
@@ skipping 48 matching lines @@
         nbitsmask = sp->dec_nbitsmask;
         oldcodep = sp->dec_oldcodep;
         free_entp = sp->dec_free_entp;
         maxcodep = sp->dec_maxcodep;
 
         while (occ > 0) {
                 NextCode(tif, sp, bp, code, GetNextCode);
                 if (code == CODE_EOI)
                         break;
                 if (code == CODE_CLEAR) {
-                        free_entp = sp->dec_codetab + CODE_FIRST;
-                        _TIFFmemset(free_entp, 0,
-                                    (CSIZE - CODE_FIRST) * sizeof (code_t));
-                        nbits = BITS_MIN;
-                        nbitsmask = MAXCODE(BITS_MIN);
-                        maxcodep = sp->dec_codetab + nbitsmask-1;
-                        NextCode(tif, sp, bp, code, GetNextCode);
+                        do {
+                                free_entp = sp->dec_codetab + CODE_FIRST;
+                                _TIFFmemset(free_entp, 0,
+                                            (CSIZE - CODE_FIRST) * sizeof (code_t));
+                                nbits = BITS_MIN;
+                                nbitsmask = MAXCODE(BITS_MIN);
+                                maxcodep = sp->dec_codetab + nbitsmask-1;
+                                NextCode(tif, sp, bp, code, GetNextCode);
+                        } while (code == CODE_CLEAR);   /* consecutive CODE_CLEAR codes */
                         if (code == CODE_EOI)
                                 break;
-                        if (code >= CODE_CLEAR) {
+                        if (code > CODE_CLEAR) {
                                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                                 "LZWDecode: Corrupted LZW table at scanline %d",
                                              tif->tif_row);
                                 return (0);
                         }
                         *op++ = (char)code, occ--;
                         oldcodep = sp->dec_codetab + code;
                         continue;
                 }
                 codep = sp->dec_codetab + code;
@@ skipping 189 matching lines @@
         nbitsmask = sp->dec_nbitsmask;
         oldcodep = sp->dec_oldcodep;
         free_entp = sp->dec_free_entp;
         maxcodep = sp->dec_maxcodep;
 
         while (occ > 0) {
                 NextCode(tif, sp, bp, code, GetNextCodeCompat);
                 if (code == CODE_EOI)
                         break;
                 if (code == CODE_CLEAR) {
-                        free_entp = sp->dec_codetab + CODE_FIRST;
-                        _TIFFmemset(free_entp, 0,
-                                    (CSIZE - CODE_FIRST) * sizeof (code_t));
-                        nbits = BITS_MIN;
-                        nbitsmask = MAXCODE(BITS_MIN);
-                        maxcodep = sp->dec_codetab + nbitsmask;
-                        NextCode(tif, sp, bp, code, GetNextCodeCompat);
+                        do {
+                                free_entp = sp->dec_codetab + CODE_FIRST;
+                                _TIFFmemset(free_entp, 0,
+                                            (CSIZE - CODE_FIRST) * sizeof (code_t));
+                                nbits = BITS_MIN;
+                                nbitsmask = MAXCODE(BITS_MIN);
+                                maxcodep = sp->dec_codetab + nbitsmask;
+                                NextCode(tif, sp, bp, code, GetNextCodeCompat);
+                        } while (code == CODE_CLEAR);   /* consecutive CODE_CLEAR codes */
                         if (code == CODE_EOI)
                                 break;
-                        if (code >= CODE_CLEAR) {
+                        if (code > CODE_CLEAR) {
                                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                                 "LZWDecode: Corrupted LZW table at scanline %d",
                                              tif->tif_row);
                                 return (0);
                         }
                         *op++ = code, occ--;
                         oldcodep = sp->dec_codetab + code;
                         continue;
                 }
                 codep = sp->dec_codetab + code;
@@ skipping 147 matching lines @@
         return (1);
 }
 
 #define CALCRATIO(sp, rat) {                                    \
         if (incount > 0x007fffff) { /* NB: shift will overflow */\
                 rat = outcount >> 8;                            \
                 rat = (rat == 0 ? 0x7fffffff : incount/rat);    \
         } else                                                  \
                 rat = (incount<<8) / outcount;                  \
 }
+
+/* Explicit 0xff masking to make icc -check=conversions happy */
 #define PutNextCode(op, c) {                                    \
         nextdata = (nextdata << nbits) | c;                     \
         nextbits += nbits;                                      \
-        *op++ = (unsigned char)(nextdata >> (nextbits-8));              \
+        *op++ = (unsigned char)((nextdata >> (nextbits-8))&0xff);               \
         nextbits -= 8;                                          \
         if (nextbits >= 8) {                                    \
-                *op++ = (unsigned char)(nextdata >> (nextbits-8));      \
+                *op++ = (unsigned char)((nextdata >> (nextbits-8))&0xff);       \
                 nextbits -= 8;                                  \
         }                                                       \
         outcount += nbits;                                      \
 }
 
 /*
  * Encode a chunk of pixels.
  *
  * Uses an open addressing double hashing (no chaining) on the 
  * prefix code/next character combination.  We do a variant of
  * Knuth's algorithm D (vol. 3, sec. 6.4) along with G. Knott's
  * relatively-prime secondary probe.  Here, the modular division
  * first probe is gives way to a faster exclusive-or manipulation. 
  * Also do block compression with an adaptive reset, whereby the
  * code table is cleared when the compression ratio decreases,
  * but after the table fills.  The variable-length output codes
  * are re-sized at this point, and a CODE_CLEAR is generated
  * for the decoder. 
  */
 static int
 LZWEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 {
         register LZWCodecState *sp = EncoderState(tif);
         register long fcode;
         register hash_t *hp;
         register int h, c;
         hcode_t ent;
         long disp;
         long incount, outcount, checkpoint;
-        long nextdata, nextbits;
+        unsigned long nextdata;
+        long nextbits;
         int free_ent, maxcode, nbits;
         uint8* op;
         uint8* limit;
 
         (void) s;
         if (sp == NULL)
                 return (0);
 
         assert(sp->enc_hashtab != NULL);
 
@@ skipping 141 matching lines @@
 /*
  * Finish off an encoded strip by flushing the last
  * string and tacking on an End Of Information code.
  */
 static int
 LZWPostEncode(TIFF* tif)
 {
         register LZWCodecState *sp = EncoderState(tif);
         uint8* op = tif->tif_rawcp;
         long nextbits = sp->lzw_nextbits;
-        long nextdata = sp->lzw_nextdata;
+        unsigned long nextdata = sp->lzw_nextdata;
         long outcount = sp->enc_outcount;
         int nbits = sp->lzw_nbits;
 
         if (op > sp->enc_rawlimit) {
                 tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata);
                 TIFFFlushData1(tif);
                 op = tif->tif_rawdata;
         }
         if (sp->enc_oldcode != (hcode_t) -1) {
                 PutNextCode(op, sp->enc_oldcode);
                 sp->enc_oldcode = (hcode_t) -1;
         }
         PutNextCode(op, CODE_EOI);
+        /* Explicit 0xff masking to make icc -check=conversions happy */
         if (nextbits > 0) 
-                *op++ = (unsigned char)(nextdata << (8-nextbits));
+                *op++ = (unsigned char)((nextdata << (8-nextbits))&0xff);
         tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata);
         return (1);
 }
 
 /*
  * Reset encoding hash table.
  */
 static void
 cl_hash(LZWCodecState* sp)
 {
@@ skipping 101 matching lines @@
 #endif /* LZW_SUPPORT */
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-