XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_ojpeg.c

-/* $Id: tif_ojpeg.c,v 1.56 2012-05-24 03:15:18 fwarmerdam Exp $ */
+/* $Id: tif_ojpeg.c,v 1.60 2015-05-31 00:38:46 bfriesen Exp $ */
 
 /* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0
    specification is now totally obsolete and deprecated for new applications and
    images. This file was was created solely in order to read unconverted images
    still present on some users' computer systems. It will never be extended
    to write such files. Writing new-style JPEG compressed TIFFs is implemented
    in tif_jpeg.c.
 
    The code is carefully crafted to robustly read all gathered JPEG-in-TIFF
    testfiles, and anticipate as much as possible all other... But still, it may
@@ skipping 20 matching lines @@
    library.
 
    IN NO EVENT SHALL JORIS VAN DAMME OR AWARE SYSTEMS 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.
 
    Joris Van Damme and/or AWare Systems may be available for custom
-   developement. If you like what you see, and need anything similar or related,
+   development. If you like what you see, and need anything similar or related,
    contact <info@awaresystems.be>.
 */
 
 /* What is what, and what is not?
 
    This decoder starts with an input stream, that is essentially the JpegInterchangeFormat
    stream, if any, followed by the strile data, if any. This stream is read in
    OJPEGReadByte and related functions.
 
    It analyzes the start of this stream, until it encounters non-marker data, i.e.
@@ skipping 60 matching lines @@
    planarconfig is not separate (vast majority). We may one day use that to build
    converters to JPEG, and/or to new-style JPEG compression inside TIFF.
 
    A dissadvantage is the lack of random access to the individual striles. This is the
    reason for much of the complicated restart-and-position stuff inside OJPEGPreDecode.
    Applications would do well accessing all striles in order, as this will result in
    a single sequential scan of the input stream, and no restarting of LibJpeg decoding
    session.
 */
 
-
 #define WIN32_LEAN_AND_MEAN
 #define VC_EXTRALEAN
 
 #include "tiffiop.h"
 #ifdef OJPEG_SUPPORT
 
 /* Configuration defines here are:
  * JPEG_ENCAP_EXTERNAL: The normal way to call libjpeg, uses longjump. In some environments,
  *      like eg LibTiffDelphi, this is not possible. For this reason, the actual calls to
  *      libjpeg, with longjump stuff, are encapsulated in dedicated functions. When
  *      JPEG_ENCAP_EXTERNAL is defined, these encapsulating functions are declared external
  *      to this unit, and can be defined elsewhere to use stuff other then longjump.
  *      The default mode, without JPEG_ENCAP_EXTERNAL, implements the call encapsulators
  *      here, internally, with normal longjump.
  * SETJMP, LONGJMP, JMP_BUF: On some machines/environments a longjump equivalent is
  *      conviniently available, but still it may be worthwhile to use _setjmp or sigsetjmp
  *      in place of plain setjmp. These macros will make it easier. It is useless
  *      to fiddle with these if you define JPEG_ENCAP_EXTERNAL.
  * OJPEG_BUFFER: Define the size of the desired buffer here. Should be small enough so as to guarantee
  *      instant processing, optimal streaming and optimal use of processor cache, but also big
  *      enough so as to not result in significant call overhead. It should be at least a few
- *      bytes to accomodate some structures (this is verified in asserts), but it would not be
+ *      bytes to accommodate some structures (this is verified in asserts), but it would not be
  *      sensible to make it this small anyway, and it should be at most 64K since it is indexed
  *      with uint16. We recommend 2K.
  * EGYPTIANWALK: You could also define EGYPTIANWALK here, but it is not used anywhere and has
  *      absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly.
  */
 
 /* define LIBJPEG_ENCAP_EXTERNAL */
 #define SETJMP(jbuf) setjmp(jbuf)
 #define LONGJMP(jbuf,code) longjmp(jbuf,code)
 #define JMP_BUF jmp_buf
@@ skipping 53 matching lines @@
 
 /* Define "boolean" as unsigned char, not int, per Windows custom. */
 #if defined(__WIN32__) && !defined(__MINGW32__)
 # ifndef __RPCNDR_H__            /* don't conflict if rpcndr.h already read */
    typedef unsigned char boolean;
 # endif
 # define HAVE_BOOLEAN            /* prevent jmorecfg.h from redefining it */
 #endif
 
 #if defined(USE_SYSTEM_LIBJPEG)
+#include <jerror.h>
 #include <jpeglib.h>
 #elif defined(USE_LIBJPEG_TURBO)
+#include "third_party/libjpeg_turbo/jerror.h"
 #include "third_party/libjpeg_turbo/jpeglib.h"
 #else
+#include "third_party/libjpeg/jerror.h"
 #include "third_party/libjpeg/jpeglib.h"
 #endif
 
+
 typedef struct jpeg_error_mgr jpeg_error_mgr;
 typedef struct jpeg_common_struct jpeg_common_struct;
 typedef struct jpeg_decompress_struct jpeg_decompress_struct;
 typedef struct jpeg_source_mgr jpeg_source_mgr;
 
 typedef enum {
         osibsNotSetYet,
         osibsJpegInterchangeFormat,
         osibsStrile,
         osibsEof
@@ skipping 196 matching lines @@
         /*
          * Merge codec-specific tag information.
          */
         if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields))) {
                 TIFFErrorExt(tif->tif_clientdata, module,
                     "Merging Old JPEG codec-specific tags failed");
                 return 0;
         }
 
         /* state block */
-        sp = (OJPEGState*)_TIFFmalloc(sizeof(OJPEGState));              // // add (OJPEGState*) cast
-        if (sp == NULL)
+        sp=_TIFFmalloc(sizeof(OJPEGState));
+        if (sp==NULL)
         {
                 TIFFErrorExt(tif->tif_clientdata,module,"No space for OJPEG state block");
                 return(0);
         }
         _TIFFmemset(sp,0,sizeof(OJPEGState));
         sp->tif=tif;
         sp->jpeg_proc=1;
         sp->subsampling_hor=2;
         sp->subsampling_ver=2;
         TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2);
@@ skipping 73 matching lines @@
 }
 
 static int
 OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
 {
         static const char module[]="OJPEGVSetField";
         OJPEGState* sp=(OJPEGState*)tif->tif_data;
         uint32 ma;
         uint64* mb;
         uint32 n;
+        const TIFFField* fip;
+
         switch(tag)
         {
                 case TIFFTAG_JPEGIFOFFSET:
                         sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
                         break;
                 case TIFFTAG_JPEGIFBYTECOUNT:
                         sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
                         break;
                 case TIFFTAG_YCBCRSUBSAMPLING:
                         sp->subsampling_tag=1;
@@ skipping 49 matching lines @@
                         break;
                 case TIFFTAG_JPEGPROC:
                         sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
                         break;
                 case TIFFTAG_JPEGRESTARTINTERVAL:
                         sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
                         break;
                 default:
                         return (*sp->vsetparent)(tif,tag,ap);
         }
-        TIFFSetFieldBit(tif,TIFFFieldWithTag(tif,tag)->field_bit);
+        fip = TIFFFieldWithTag(tif,tag);
+        if( fip == NULL ) /* shouldn't happen */
+            return(0);
+        TIFFSetFieldBit(tif,fip->field_bit);
         tif->tif_flags|=TIFF_DIRTYDIRECT;
         return(1);
 }
 
 static void
 OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
 {
         OJPEGState* sp=(OJPEGState*)tif->tif_data;
         uint8 m;
         (void)flags;
@@ skipping 143 matching lines @@
 }
 
 static int
 OJPEGPreDecodeSkipScanlines(TIFF* tif)
 {
         static const char module[]="OJPEGPreDecodeSkipScanlines";
         OJPEGState* sp=(OJPEGState*)tif->tif_data;
         uint32 m;
         if (sp->skip_buffer==NULL)
         {
-                // add (uint8*) cast
-                sp->skip_buffer = (uint8*)_TIFFmalloc(sp->bytes_per_line);
-                if (sp->skip_buffer == NULL)
+                sp->skip_buffer=_TIFFmalloc(sp->bytes_per_line);
+                if (sp->skip_buffer==NULL)
                 {
                         TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                         return(0);
                 }
         }
         for (m=0; m<sp->lines_per_strile; m++)
         {
                 if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&sp->skip_buffer,1)==0)
                         return(0);
         }
@@ skipping 403 matching lines @@
                 {
                         assert(sp->subsampling_convert_ycbcrbuf==0);
                         assert(sp->subsampling_convert_ycbcrimage==0);
                         sp->subsampling_convert_ylinelen=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8)*sp->subsampling_hor*8);
                         sp->subsampling_convert_ylines=sp->subsampling_ver*8;
                         sp->subsampling_convert_clinelen=sp->subsampling_convert_ylinelen/sp->subsampling_hor;
                         sp->subsampling_convert_clines=8;
                         sp->subsampling_convert_ybuflen=sp->subsampling_convert_ylinelen*sp->subsampling_convert_ylines;
                         sp->subsampling_convert_cbuflen=sp->subsampling_convert_clinelen*sp->subsampling_convert_clines;
                         sp->subsampling_convert_ycbcrbuflen=sp->subsampling_convert_ybuflen+2*sp->subsampling_convert_cbuflen;
-                        sp->subsampling_convert_ycbcrbuf = (uint8*)_TIFFmalloc(sp->subsampling_convert_ycbcrbuflen);    // add (uint8*) cast
+                        sp->subsampling_convert_ycbcrbuf=_TIFFmalloc(sp->subsampling_convert_ycbcrbuflen);
                         if (sp->subsampling_convert_ycbcrbuf==0)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                                 return(0);
                         }
                         sp->subsampling_convert_ybuf=sp->subsampling_convert_ycbcrbuf;
                         sp->subsampling_convert_cbbuf=sp->subsampling_convert_ybuf+sp->subsampling_convert_ybuflen;
                         sp->subsampling_convert_crbuf=sp->subsampling_convert_cbbuf+sp->subsampling_convert_cbuflen;
                         sp->subsampling_convert_ycbcrimagelen=3+sp->subsampling_convert_ylines+2*sp->subsampling_convert_clines;
-                        sp->subsampling_convert_ycbcrimage = (uint8**)_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen * sizeof(uint8*));// add (uint8**) cast
+                        sp->subsampling_convert_ycbcrimage=_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen*sizeof(uint8*));
                         if (sp->subsampling_convert_ycbcrimage==0)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                                 return(0);
                         }
                         m=sp->subsampling_convert_ycbcrimage;
                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3);
                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines);
                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines+sp->subsampling_convert_clines);
                         for (n=0; n<sp->subsampling_convert_ylines; n++)
@@ skipping 206 matching lines @@
         else
         {
                 m-=2;
                 do
                 {
                         if (m<65)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
                                 return(0);
                         }
-                        na = sizeof(uint32) + 69;
-                        nb = (uint8*)_TIFFmalloc(na);   // add (uint8*) cast
-                        if (nb == 0)
+                        na=sizeof(uint32)+69;
+                        nb=_TIFFmalloc(na);
+                        if (nb==0)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                                 return(0);
                         }
                         *(uint32*)nb=na;
                         nb[sizeof(uint32)]=255;
                         nb[sizeof(uint32)+1]=JPEG_MARKER_DQT;
                         nb[sizeof(uint32)+2]=0;
                         nb[sizeof(uint32)+3]=67;
                         if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) {
@@ skipping 34 matching lines @@
                 if (sp->subsamplingcorrect==0)
                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
                 return(0);
         }
         if (sp->subsamplingcorrect!=0)
         {
                 OJPEGReadSkip(sp,m-2);
         }
         else
         {
-                na = sizeof(uint32) + 2 + m;
-                nb = (uint8*)_TIFFmalloc(na);   // add (uint8*) cast
-                if (nb == 0)
+                na=sizeof(uint32)+2+m;
+                nb=_TIFFmalloc(na);
+                if (nb==0)
                 {
                         TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                         return(0);
                 }
                 *(uint32*)nb=na;
                 nb[sizeof(uint32)]=255;
                 nb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
                 nb[sizeof(uint32)+2]=(m>>8);
                 nb[sizeof(uint32)+3]=(m&255);
-                if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0)
+                if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0) {
+                        _TIFFfree(nb);
                         return(0);
+                }
                 o=nb[sizeof(uint32)+4];
                 if ((o&240)==0)
                 {
                         if (3<o)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
+                                _TIFFfree(nb);
                                 return(0);
                         }
                         if (sp->dctable[o]!=0)
                                 _TIFFfree(sp->dctable[o]);
                         sp->dctable[o]=nb;
                 }
                 else
                 {
                         if ((o&240)!=16)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
+                                _TIFFfree(nb);
                                 return(0);
                         }
                         o&=15;
                         if (3<o)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
+                                _TIFFfree(nb);
                                 return(0);
                         }
                         if (sp->actable[o]!=0)
                                 _TIFFfree(sp->actable[o]);
                         sp->actable[o]=nb;
                 }
         }
         return(1);
 }
 
@@ skipping 219 matching lines @@
                 {
                         for (n=0; n<m-1; n++)
                         {
                                 if (sp->qtable_offset[m]==sp->qtable_offset[n])
                                 {
                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegQTables tag value");
                                         return(0);
                                 }
                         }
                         oa=sizeof(uint32)+69;
-                        ob = (uint8*)_TIFFmalloc(oa);   // add (uint8*) cast
+                        ob=_TIFFmalloc(oa);
                         if (ob==0)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                                 return(0);
                         }
                         *(uint32*)ob=oa;
                         ob[sizeof(uint32)]=255;
                         ob[sizeof(uint32)+1]=JPEG_MARKER_DQT;
                         ob[sizeof(uint32)+2]=0;
                         ob[sizeof(uint32)+3]=67;
                         ob[sizeof(uint32)+4]=m;
                         TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET); 
-                        p=(uint32)TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
+                        p=TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
                         if (p!=64)
                                 return(0);
                         sp->qtable[m]=ob;
                         sp->sof_tq[m]=m;
                 }
                 else
                         sp->sof_tq[m]=sp->sof_tq[m-1];
         }
         return(1);
 }
@@ skipping 22 matching lines @@
                 {
                         for (n=0; n<m-1; n++)
                         {
                                 if (sp->dctable_offset[m]==sp->dctable_offset[n])
                                 {
                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegDcTables tag value");
                                         return(0);
                                 }
                         }
                         TIFFSeekFile(tif,sp->dctable_offset[m],SEEK_SET);
-                        p=(uint32)TIFFReadFile(tif,o,16);
+                        p=TIFFReadFile(tif,o,16);
                         if (p!=16)
                                 return(0);
                         q=0;
                         for (n=0; n<16; n++)
                                 q+=o[n];
                         ra=sizeof(uint32)+21+q;
-                        rb = (uint8*)_TIFFmalloc(ra);   // add (uint8*) cast
+                        rb=_TIFFmalloc(ra);
                         if (rb==0)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                                 return(0);
                         }
                         *(uint32*)rb=ra;
                         rb[sizeof(uint32)]=255;
                         rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
                         rb[sizeof(uint32)+2]=((19+q)>>8);
                         rb[sizeof(uint32)+3]=((19+q)&255);
                         rb[sizeof(uint32)+4]=m;
                         for (n=0; n<16; n++)
                                 rb[sizeof(uint32)+5+n]=o[n];
-                        p=(uint32)TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
+                        p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
                         if (p!=q)
                                 return(0);
                         sp->dctable[m]=rb;
                         sp->sos_tda[m]=(m<<4);
                 }
                 else
                         sp->sos_tda[m]=sp->sos_tda[m-1];
         }
         return(1);
 }
@@ skipping 22 matching lines @@
                 {
                         for (n=0; n<m-1; n++)
                         {
                                 if (sp->actable_offset[m]==sp->actable_offset[n])
                                 {
                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegAcTables tag value");
                                         return(0);
                                 }
                         }
                         TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);  
-                        p=(uint32)TIFFReadFile(tif,o,16);
+                        p=TIFFReadFile(tif,o,16);
                         if (p!=16)
                                 return(0);
                         q=0;
                         for (n=0; n<16; n++)
                                 q+=o[n];
                         ra=sizeof(uint32)+21+q;
-                        rb = (uint8*)_TIFFmalloc(ra);   // add (uint8*) cast
+                        rb=_TIFFmalloc(ra);
                         if (rb==0)
                         {
                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
                                 return(0);
                         }
                         *(uint32*)rb=ra;
                         rb[sizeof(uint32)]=255;
                         rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
                         rb[sizeof(uint32)+2]=((19+q)>>8);
                         rb[sizeof(uint32)+3]=((19+q)&255);
                         rb[sizeof(uint32)+4]=(16|m);
                         for (n=0; n<16; n++)
                                 rb[sizeof(uint32)+5+n]=o[n];
-                        p=(uint32)TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
+                        p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
                         if (p!=q)
                                 return(0);
                         sp->actable[m]=rb;
                         sp->sos_tda[m]=(sp->sos_tda[m]|m);
                 }
                 else
                         sp->sos_tda[m]=(sp->sos_tda[m]|(sp->sos_tda[m-1]&15));
         }
         return(1);
 }
@@ skipping 37 matching lines @@
                         case osibsNotSetYet:
                                 if (sp->jpeg_interchange_format!=0)
                                 {
                                         sp->in_buffer_file_pos=sp->jpeg_interchange_format;
                                         sp->in_buffer_file_togo=sp->jpeg_interchange_format_length;
                                 }
                                 sp->in_buffer_source=osibsJpegInterchangeFormat;
                                 break;
                         case osibsJpegInterchangeFormat:
                                 sp->in_buffer_source=osibsStrile;
+                                break;
                         case osibsStrile:
                                 if (!_TIFFFillStriles( sp->tif ) 
                                     || sp->tif->tif_dir.td_stripoffset == NULL
                                     || sp->tif->tif_dir.td_stripbytecount == NULL)
                                         return 0;
 
                                 if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
                                         sp->in_buffer_source=osibsEof;
                                 else
                                 {
@@ skipping 77 matching lines @@
 }
 
 static int
 OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
 {
         uint16 mlen;
         uint8* mmem;
         uint16 n;
         assert(len>0);
         mlen=len;
-        mmem = (uint8*)mem;             // add (uint8*) cast
+        mmem=mem;
         do
         {
                 if (sp->in_buffer_togo==0)
                 {
                         if (OJPEGReadBufferFill(sp)==0)
                                 return(0);
                         assert(sp->in_buffer_togo>0);
                 }
                 n=mlen;
                 if (n>sp->in_buffer_togo)
@@ skipping 381 matching lines @@
 {
         TIFF* tif=(TIFF*)cinfo->client_data;
         OJPEGState* sp=(OJPEGState*)tif->tif_data;
         void* mem=0;
         uint32 len=0U;
         if (OJPEGWriteStream(tif,&mem,&len)==0)
         {
                 TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");
                 jpeg_encap_unwind(tif);
         }
-        sp->libjpeg_jpeg_source_mgr.bytes_in_buffer = len;
-        sp->libjpeg_jpeg_source_mgr.next_input_byte = (const JOCTET * )mem;             // add (const JOCTET * ) cast
+        sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=len;
+        sp->libjpeg_jpeg_source_mgr.next_input_byte=mem;
         return(1);
 }
 
 static void
 OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes)
 {
         TIFF* tif=(TIFF*)cinfo->client_data;
         (void)num_bytes;
         TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
         jpeg_encap_unwind(tif);
@@ skipping 18 matching lines @@
 #endif
 
 
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-