XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_zip.c

-/* $Id: tif_zip.c,v 1.31 2011-01-06 16:00:23 fwarmerdam Exp $ */
+/* $Id: tif_zip.c,v 1.33 2014-12-25 18:29:11 erouault Exp $ */
 
 /*
  * Copyright (c) 1995-1997 Sam Leffler
  * Copyright (c) 1995-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 ZIP_SUPPORT
 /*
  * TIFF Library.
  *
  * ZIP (aka Deflate) Compression Support
  *
  * This file is simply an interface to the zlib library written by
  * Jean-loup Gailly and Mark Adler.  You must use version 1.0 or later
  * of the library: this code assumes the 1.0 API and also depends on
  * the ability to write the zlib header multiple times (one per strip)
  * which was not possible with versions prior to 0.95.  Note also that
- * older versions of this codec avoided this bug by supressing the header
+ * older versions of this codec avoided this bug by suppressing the header
  * entirely.  This means that files written with the old library cannot
  * be read; they should be converted to a different compression scheme
  * and then reconverted.
  *
  * The data format used by the zlib library is described in the files
  * zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available in the
  * directory ftp://ftp.uu.net/pub/archiving/zip/doc.  The library was
  * last found at ftp://ftp.uu.net/pub/archiving/zip/zlib/zlib-0.99.tar.gz.
  */
 #include "tif_predict.h"
 #include "../zlib_v128/zlib.h"
 
 #include <stdio.h>
 
 /*
  * Sigh, ZLIB_VERSION is defined as a string so there's no
  * way to do a proper check here.  Instead we guess based
  * on the presence of #defines that were added between the
  * 0.95 and 1.0 distributions.
  */
 #if !defined(Z_NO_COMPRESSION) || !defined(Z_DEFLATED)
 #error "Antiquated ZLIB software; you must use version 1.0 or later"
 #endif
 
+#define SAFE_MSG(sp)   ((sp)->stream.msg == NULL ? "" : (sp)->stream.msg)
+
 /*
  * State block for each open TIFF
  * file using ZIP compression/decompression.
  */
 typedef struct {
         TIFFPredictorState predict;
         z_stream        stream;
         int             zipquality;            /* compression level */
         int             state;                 /* state flags */
 #define ZSTATE_INIT_DECODE 0x01
@@ skipping 25 matching lines @@
 
         assert(sp != NULL);
         
         /* if we were last encoding, terminate this mode */
         if (sp->state & ZSTATE_INIT_ENCODE) {
             deflateEnd(&sp->stream);
             sp->state = 0;
         }
 
         if (inflateInit(&sp->stream) != Z_OK) {
-                TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
+                TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp));
                 return (0);
         } else {
                 sp->state |= ZSTATE_INIT_DECODE;
                 return (1);
         }
 }
 
 /*
  * Setup state for decoding a strip.
  */
@@ skipping 47 matching lines @@
                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
                 return (0);
         }
         do {
                 int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
                 if (state == Z_STREAM_END)
                         break;
                 if (state == Z_DATA_ERROR) {
                         TIFFErrorExt(tif->tif_clientdata, module,
                             "Decoding error at scanline %lu, %s",
-                            (unsigned long) tif->tif_row, sp->stream.msg);
+                             (unsigned long) tif->tif_row, SAFE_MSG(sp));
                         if (inflateSync(&sp->stream) != Z_OK)
                                 return (0);
                         continue;
                 }
                 if (state != Z_OK) {
-                        TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
-                            sp->stream.msg);
+                        TIFFErrorExt(tif->tif_clientdata, module, 
+                                     "ZLib error: %s", SAFE_MSG(sp));
                         return (0);
                 }
         } while (sp->stream.avail_out > 0);
         if (sp->stream.avail_out != 0) {
                 TIFFErrorExt(tif->tif_clientdata, module,
                     "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)",
                     (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out);
                 return (0);
         }
 
         tif->tif_rawcp = sp->stream.next_in;
         tif->tif_rawcc = sp->stream.avail_in;
 
         return (1);
 }
 
 static int
 ZIPSetupEncode(TIFF* tif)
 {
         static const char module[] = "ZIPSetupEncode";
         ZIPState* sp = EncoderState(tif);
 
         assert(sp != NULL);
         if (sp->state & ZSTATE_INIT_DECODE) {
                 inflateEnd(&sp->stream);
                 sp->state = 0;
         }
 
         if (deflateInit(&sp->stream, sp->zipquality) != Z_OK) {
-                TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
+                TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp));
                 return (0);
         } else {
                 sp->state |= ZSTATE_INIT_ENCODE;
                 return (1);
         }
 }
 
 /*
  * Reset encoding state at the start of a strip.
  */
 static int
 ZIPPreEncode(TIFF* tif, uint16 s)
 {
         static const char module[] = "ZIPPreEncode";
         ZIPState *sp = EncoderState(tif);
 
         (void) s;
         assert(sp != NULL);
         if( sp->state != ZSTATE_INIT_ENCODE )
             tif->tif_setupencode( tif );
 
         sp->stream.next_out = tif->tif_rawdata;
         assert(sizeof(sp->stream.avail_out)==4);  /* if this assert gets raised,
             we need to simplify this code to reflect a ZLib that is likely updated
             to deal with 8byte memory sizes, though this code will respond
             apropriately even before we simplify it */
-        sp->stream.avail_out = (uInt)tif->tif_rawdatasize;
+        sp->stream.avail_out = tif->tif_rawdatasize;
         if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
         {
                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
                 return (0);
         }
         return (deflateReset(&sp->stream) == Z_OK);
 }
 
 /*
  * Encode a chunk of pixels.
@@ skipping 14 matching lines @@
             to deal with 8byte memory sizes, though this code will respond
             apropriately even before we simplify it */
         sp->stream.avail_in = (uInt) cc;
         if ((tmsize_t)sp->stream.avail_in != cc)
         {
                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
                 return (0);
         }
         do {
                 if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) {
-                        TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s",
-                            sp->stream.msg);
+                        TIFFErrorExt(tif->tif_clientdata, module, 
+                                     "Encoder error: %s",
+                                     SAFE_MSG(sp));
                         return (0);
                 }
                 if (sp->stream.avail_out == 0) {
                         tif->tif_rawcc = tif->tif_rawdatasize;
                         TIFFFlushData1(tif);
                         sp->stream.next_out = tif->tif_rawdata;
                         sp->stream.avail_out = (uInt) tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in ZIPPreEncode */
                 }
         } while (sp->stream.avail_in > 0);
         return (1);
@@ skipping 18 matching lines @@
                 case Z_OK:
                         if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
                         {
                                 tif->tif_rawcc =  tif->tif_rawdatasize - sp->stream.avail_out;
                                 TIFFFlushData1(tif);
                                 sp->stream.next_out = tif->tif_rawdata;
                                 sp->stream.avail_out = (uInt) tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in ZIPPreEncode */
                         }
                         break;
                 default:
-                        TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
-                            sp->stream.msg);
+                        TIFFErrorExt(tif->tif_clientdata, module, 
+                                     "ZLib error: %s", SAFE_MSG(sp));
                         return (0);
                 }
         } while (state != Z_STREAM_END);
         return (1);
 }
 
 static void
 ZIPCleanup(TIFF* tif)
 {
         ZIPState* sp = ZState(tif);
@@ skipping 24 matching lines @@
         static const char module[] = "ZIPVSetField";
         ZIPState* sp = ZState(tif);
 
         switch (tag) {
         case TIFFTAG_ZIPQUALITY:
                 sp->zipquality = (int) va_arg(ap, int);
                 if ( sp->state&ZSTATE_INIT_ENCODE ) {
                         if (deflateParams(&sp->stream,
                             sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) {
                                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
-                                    sp->stream.msg);
+                                             SAFE_MSG(sp));
                                 return (0);
                         }
                 }
                 return (1);
         default:
                 return (*sp->vsetparent)(tif, tag, ap);
         }
         /*NOTREACHED*/
 }
 
@@ skipping 87 matching lines @@
 #endif /* ZIP_SUPORT */
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-