XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_read.c

-/* $Id: tif_read.c,v 1.41 2012-07-06 19:22:58 bfriesen Exp $ */
+/* $Id: tif_read.c,v 1.45 2015-06-07 22:35:40 bfriesen 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
@@ skipping 28 matching lines @@
 TIFFReadRawStrip1(TIFF* tif, uint32 strip, void* buf, tmsize_t size,const char* module);
 
 #define NOSTRIP ((uint32)(-1))       /* undefined state */
 #define NOTILE ((uint32)(-1))         /* undefined state */
 
 static int
 TIFFFillStripPartial( TIFF *tif, int strip, tmsize_t read_ahead, int restart )
 {
         static const char module[] = "TIFFFillStripPartial";
         register TIFFDirectory *td = &tif->tif_dir;
-        uint64 unused_data;
+        tmsize_t unused_data;
         uint64 read_offset;
         tmsize_t cc, to_read;
         /* tmsize_t bytecountm; */
         
         if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount)
             return 0;
         
         /*
          * Expand raw data buffer, if needed, to hold data
          * strip coming from file (perhaps should set upper
@@ skipping 26 matching lines @@
         ** start of the buffer.
         */
         if( tif->tif_rawdataloaded > 0 )
                 unused_data = tif->tif_rawdataloaded - (tif->tif_rawcp - tif->tif_rawdata);
         else
                 unused_data = 0;
         
         if( unused_data > 0 )
         {
                 assert((tif->tif_flags&TIFF_BUFFERMMAP)==0);
-                memmove( tif->tif_rawdata, tif->tif_rawcp, (size_t)unused_data );
+                memmove( tif->tif_rawdata, tif->tif_rawcp, unused_data );
         }
 
         /*
         ** Seek to the point in the file where more data should be read.
         */
         read_offset = td->td_stripoffset[strip]
                 + tif->tif_rawdataoff + tif->tif_rawdataloaded;
 
         if (!SeekOK(tif, read_offset)) {
                 TIFFErrorExt(tif->tif_clientdata, module,
                              "Seek error at scanline %lu, strip %lu",
                              (unsigned long) tif->tif_row, (unsigned long) strip);
                 return 0;
         }
 
         /*
         ** How much do we want to read?
         */
-        to_read = (tmsize_t)(tif->tif_rawdatasize - unused_data);
+        to_read = tif->tif_rawdatasize - unused_data;
         if( (uint64) to_read > td->td_stripbytecount[strip] 
             - tif->tif_rawdataoff - tif->tif_rawdataloaded )
         {
-                to_read = (tmsize_t)(td->td_stripbytecount[strip]
-                        - tif->tif_rawdataoff - tif->tif_rawdataloaded);
+                to_read = (tmsize_t) td->td_stripbytecount[strip]
+                        - tif->tif_rawdataoff - tif->tif_rawdataloaded;
         }
 
         assert((tif->tif_flags&TIFF_BUFFERMMAP)==0);
         cc = TIFFReadFile(tif, tif->tif_rawdata + unused_data, to_read);
 
         if (cc != to_read) {
 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
                 TIFFErrorExt(tif->tif_clientdata, module,
                              "Read error at scanline %lu; got %I64u bytes, expected %I64u",
                              (unsigned long) tif->tif_row,
                              (unsigned __int64) cc,
                              (unsigned __int64) to_read);
 #else
                 TIFFErrorExt(tif->tif_clientdata, module,
                              "Read error at scanline %lu; got %llu bytes, expected %llu",
                              (unsigned long) tif->tif_row,
                              (unsigned long long) cc,
                              (unsigned long long) to_read);
 #endif
                 return 0;
         }
         
-        tif->tif_rawdataoff = (tmsize_t)(tif->tif_rawdataoff + tif->tif_rawdataloaded - unused_data) ;
-        tif->tif_rawdataloaded = (tmsize_t)unused_data + to_read;
+        tif->tif_rawdataoff = tif->tif_rawdataoff + tif->tif_rawdataloaded - unused_data ;
+        tif->tif_rawdataloaded = unused_data + to_read;
 
         tif->tif_rawcp = tif->tif_rawdata;
                         
         if (!isFillOrder(tif, td->td_fillorder) &&
             (tif->tif_flags & TIFF_NOBITREV) == 0) {
                 assert((tif->tif_flags&TIFF_BUFFERMMAP)==0);
                 TIFFReverseBits(tif->tif_rawdata + unused_data, to_read );
         }
 
         /*
@@ skipping 158 matching lines @@
  * amount into the user-supplied buffer.
  */
 tmsize_t
 TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size)
 {
         static const char module[] = "TIFFReadEncodedStrip";
         TIFFDirectory *td = &tif->tif_dir;
         uint32 rowsperstrip;
         uint32 stripsperplane;
         uint32 stripinplane;
-        uint16 plane, comp;
+        uint16 plane;
         uint32 rows;
         tmsize_t stripsize;
         if (!TIFFCheckRead(tif,0))
                 return((tmsize_t)(-1));
         if (strip>=td->td_nstrips)
         {
                 TIFFErrorExt(tif->tif_clientdata,module,
                     "%lu: Strip out of range, max %lu",(unsigned long)strip,
                     (unsigned long)td->td_nstrips);
                 return((tmsize_t)(-1));
@@ skipping 10 matching lines @@
         stripinplane=(strip%stripsperplane);
         plane=(strip/stripsperplane);
         rows=td->td_imagelength-stripinplane*rowsperstrip;
         if (rows>rowsperstrip)
                 rows=rowsperstrip;
         stripsize=TIFFVStripSize(tif,rows);
         if (stripsize==0)
                 return((tmsize_t)(-1));
         if ((size!=(tmsize_t)(-1))&&(size<stripsize))
                 stripsize=size;
-
-        /*
-         * discard those.
-         * keep code modified by Changjin Gao.
-         * Xiaochuan Liu 20100828.
-         */
-        /*if (!TIFFFillStrip(tif,strip))
+        if (!TIFFFillStrip(tif,strip))
                 return((tmsize_t)(-1));
         if ((*tif->tif_decodestrip)(tif,buf,stripsize,plane)<=0)
                 return((tmsize_t)(-1));
         (*tif->tif_postdecode)(tif,buf,stripsize);
-        return(stripsize);*/
-        
-        /*
-        * Changjin Gao 20110726 fixed decode error issue.
-        * Test file: mantis #27308 020511-1158450.tiff.
-        */
-        comp = COMPRESSION_NONE;
-StripDecode:
-        if (TIFFFillStrip(tif, strip) && (*tif->tif_decodestrip)(tif, buf, stripsize, plane) > 0)
-        {
-                (*tif->tif_postdecode)(tif, buf, stripsize);
-                return (stripsize);
-        }
-        else
-        {
-                if (comp < 9)
-                {
-                        TIFFSetField(tif, TIFFTAG_COMPRESSION, comp);
-                        TIFFSetField(tif, TIFFTAG_FAXMODE,FAXMODE_CLASSIC);
-                        comp++;
-                        goto StripDecode;
-                }
-
-                return ((tsize_t) -1);
-        }
+        return(stripsize);
 }
 
 static tmsize_t
 TIFFReadRawStrip1(TIFF* tif, uint32 strip, void* buf, tmsize_t size,
     const char* module)
 {
         TIFFDirectory *td = &tif->tif_dir;
 
     if (!_TIFFFillStriles( tif ))
         return ((tmsize_t)(-1));
@@ skipping 80 matching lines @@
                      (unsigned long) td->td_nstrips);
                 return ((tmsize_t)(-1));
         }
         if (tif->tif_flags&TIFF_NOREADRAW)
         {
                 TIFFErrorExt(tif->tif_clientdata, module,
                     "Compression scheme does not support access to raw uncompressed data");
                 return ((tmsize_t)(-1));
         }
         bytecount = td->td_stripbytecount[strip];
-        if (bytecount <= 0) {
+        if ((int64)bytecount <= 0) {
 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
                 TIFFErrorExt(tif->tif_clientdata, module,
                              "%I64u: Invalid strip byte count, strip %lu",
                              (unsigned __int64) bytecount,
                              (unsigned long) strip);
 #else
                 TIFFErrorExt(tif->tif_clientdata, module,
                              "%llu: Invalid strip byte count, strip %lu",
                              (unsigned long long) bytecount,
                              (unsigned long) strip);
@@ skipping 19 matching lines @@
 {
         static const char module[] = "TIFFFillStrip";
         TIFFDirectory *td = &tif->tif_dir;
 
     if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount)
         return 0;
         
         if ((tif->tif_flags&TIFF_NOREADRAW)==0)
         {
                 uint64 bytecount = td->td_stripbytecount[strip];
-                if (bytecount <= 0) {
+                if ((int64)bytecount <= 0) {
 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
                         TIFFErrorExt(tif->tif_clientdata, module,
                                 "Invalid strip byte count %I64u, strip %lu",
                                      (unsigned __int64) bytecount,
                                      (unsigned long) strip);
 #else
                         TIFFErrorExt(tif->tif_clientdata, module,
                                 "Invalid strip byte count %llu, strip %lu",
                                      (unsigned long long) bytecount,
                                      (unsigned long) strip);
@@ skipping 282 matching lines @@
 {
         static const char module[] = "TIFFFillTile";
         TIFFDirectory *td = &tif->tif_dir;
 
     if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount)
         return 0;
         
         if ((tif->tif_flags&TIFF_NOREADRAW)==0)
         {
                 uint64 bytecount = td->td_stripbytecount[tile];
-                if (bytecount <= 0) {
+                if ((int64)bytecount <= 0) {
 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
                         TIFFErrorExt(tif->tif_clientdata, module,
                                 "%I64u: Invalid tile byte count, tile %lu",
                                      (unsigned __int64) bytecount,
                                      (unsigned long) tile);
 #else
                         TIFFErrorExt(tif->tif_clientdata, module,
                                 "%llu: Invalid tile byte count, tile %lu",
                                      (unsigned long long) bytecount,
                                      (unsigned long) tile);
@@ skipping 108 matching lines @@
                         _TIFFfree(tif->tif_rawdata);
                 tif->tif_rawdata = NULL;
                 tif->tif_rawdatasize = 0;
         }
         if (bp) {
                 tif->tif_rawdatasize = size;
                 tif->tif_rawdata = (uint8*) bp;
                 tif->tif_flags &= ~TIFF_MYBUFFER;
         } else {
                 tif->tif_rawdatasize = (tmsize_t)TIFFroundup_64((uint64)size, 1024);
-                if (tif->tif_rawdatasize==0)
-                        tif->tif_rawdatasize=(tmsize_t)(-1);
+                if (tif->tif_rawdatasize==0) {
+                    TIFFErrorExt(tif->tif_clientdata, module,
+                                 "Invalid buffer size");
+                    return (0);
+                }
                 tif->tif_rawdata = (uint8*) _TIFFmalloc(tif->tif_rawdatasize);
                 tif->tif_flags |= TIFF_MYBUFFER;
         }
         if (tif->tif_rawdata == NULL) {
                 TIFFErrorExt(tif->tif_clientdata, module,
                     "No space for data buffer at scanline %lu",
                     (unsigned long) tif->tif_row);
                 tif->tif_rawdatasize = 0;
                 return (0);
         }
@@ skipping 35 matching lines @@
                         (uint16)(strip / td->td_stripsperimage)));
 }
 
 /*
  * Set state to appear as if a
  * tile has just been read in.
  */
 static int
 TIFFStartTile(TIFF* tif, uint32 tile)
 {
+        static const char module[] = "TIFFStartTile";
         TIFFDirectory *td = &tif->tif_dir;
+        uint32 howmany32;
 
-    if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount)
-        return 0;
+        if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount)
+                return 0;
 
         if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
                 if (!(*tif->tif_setupdecode)(tif))
                         return (0);
                 tif->tif_flags |= TIFF_CODERSETUP;
         }
         tif->tif_curtile = tile;
-        tif->tif_row =
-            (tile % TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth)) *
-                td->td_tilelength;
-        tif->tif_col =
-            (tile % TIFFhowmany_32(td->td_imagelength, td->td_tilelength)) *
-                td->td_tilewidth;
+        howmany32=TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth);
+        if (howmany32 == 0) {
+                 TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
+                return 0;
+        }
+        tif->tif_row = (tile % howmany32) * td->td_tilelength;
+        howmany32=TIFFhowmany_32(td->td_imagelength, td->td_tilelength);
+        if (howmany32 == 0) {
+                TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
+                return 0;
+        }
+        tif->tif_col = (tile % howmany32) * td->td_tilewidth;
         tif->tif_flags &= ~TIFF_BUF4WRITE;
         if (tif->tif_flags&TIFF_NOREADRAW)
         {
                 tif->tif_rawcp = NULL;
                 tif->tif_rawcc = 0;
         }
         else
         {
                 tif->tif_rawcp = tif->tif_rawdata;
                 tif->tif_rawcc = (tmsize_t)td->td_stripbytecount[tile];
@@ skipping 57 matching lines @@
 }
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-