XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_jpeg.c

-/* $Id: tif_jpeg.c,v 1.111 2012-07-06 18:48:04 bfriesen Exp $ */
+/* $Id: tif_jpeg.c,v 1.119 2015-08-15 20:13:07 bfriesen Exp $ */
 
 /*
  * Copyright (c) 1994-1997 Sam Leffler
  * Copyright (c) 1994-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.
  */
+
 #define WIN32_LEAN_AND_MEAN
 #define VC_EXTRALEAN
 
 #include "tiffiop.h"
 #ifdef JPEG_SUPPORT
 
 /*
  * TIFF Library
  *
  * JPEG Compression support per TIFF Technical Note #2
@@ skipping 34 matching lines @@
    way. That causes errors of the following type:
 
    "JPEGLib: JPEG parameter struct mismatch: library thinks size is 432,
    caller expects 464"
 
    For such users we wil fix the problem here. See install.doc file from
    the JPEG library distribution for details.
 */
 
 /* Define "boolean" as unsigned char, not int, per Windows custom. */
-#if defined(WIN32) && !defined(__MINGW32__)
+#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)
@@ skipping 161 matching lines @@
 #define CALLVJPEG(sp, op)       CALLJPEG(sp, 0, ((op),1))
 
 static int
 TIFFjpeg_create_compress(JPEGState* sp)
 {
         /* initialize JPEG error handling */
         sp->cinfo.c.err = jpeg_std_error(&sp->err);
         sp->err.error_exit = TIFFjpeg_error_exit;
         sp->err.output_message = TIFFjpeg_output_message;
 
+        /* set client_data to avoid UMR warning from tools like Purify */
+        sp->cinfo.c.client_data = NULL;
+
         return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c));
 }
 
 static int
 TIFFjpeg_create_decompress(JPEGState* sp)
 {
         /* initialize JPEG error handling */
         sp->cinfo.d.err = jpeg_std_error(&sp->err);
         sp->err.error_exit = TIFFjpeg_error_exit;
         sp->err.output_message = TIFFjpeg_output_message;
 
+        /* set client_data to avoid UMR warning from tools like Purify */
+        sp->cinfo.d.client_data = NULL;
+
         return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d));
 }
 
 static int
 TIFFjpeg_set_defaults(JPEGState* sp)
 {
         return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c));
 }
 
 static int
@@ skipping 375 matching lines @@
 
 
 /*
  * JPEG Decoding.
  */
 
 #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
 
 #define JPEG_MARKER_SOF0 0xC0
 #define JPEG_MARKER_SOF1 0xC1
-#define JPEG_MARKER_SOF3 0xC3
+#define JPEG_MARKER_SOF2 0xC2
+#define JPEG_MARKER_SOF9 0xC9
+#define JPEG_MARKER_SOF10 0xCA
 #define JPEG_MARKER_DHT 0xC4
 #define JPEG_MARKER_SOI 0xD8
 #define JPEG_MARKER_SOS 0xDA
 #define JPEG_MARKER_DQT 0xDB
 #define JPEG_MARKER_DRI 0xDD
 #define JPEG_MARKER_APP0 0xE0
 #define JPEG_MARKER_COM 0xFE
 struct JPEGFixupTagsSubsamplingData
 {
         TIFF* tif;
@@ skipping 50 matching lines @@
          *
          * Frank Warmerdam, July 2002
          * Joris Van Damme, May 2007
          */
         static const char module[] = "JPEGFixupTagsSubsampling";
         struct JPEGFixupTagsSubsamplingData m;
 
         _TIFFFillStriles( tif );
         
         if( tif->tif_dir.td_stripbytecount == NULL
+            || tif->tif_dir.td_stripoffset == NULL
             || tif->tif_dir.td_stripbytecount[0] == 0 )
         {
             /* Do not even try to check if the first strip/tile does not
                yet exist, as occurs when GDAL has created a new NULL file
                for instance. */
             return;
         }
 
         m.tif=tif;
         m.buffersize=2048;
@@ skipping 67 matching lines @@
                                         uint16 n;
                                         if (!JPEGFixupTagsSubsamplingReadWord(data,&n))
                                                 return(0);
                                         if (n<2)
                                                 return(0);
                                         n-=2;
                                         if (n>0)
                                                 JPEGFixupTagsSubsamplingSkip(data,n);
                                 }
                                 break;
-                        case JPEG_MARKER_SOF0:
-                        case JPEG_MARKER_SOF1:
+                        case JPEG_MARKER_SOF0: /* Baseline sequential Huffman */
+                        case JPEG_MARKER_SOF1: /* Extended sequential Huffman */
+                        case JPEG_MARKER_SOF2: /* Progressive Huffman: normally not allowed by TechNote, but that doesn't hurt supporting it */
+                        case JPEG_MARKER_SOF9: /* Extended sequential arithmetic */
+                        case JPEG_MARKER_SOF10: /* Progressive arithmetic: normally not allowed by TechNote, but that doesn't hurt supporting it */
                                 /* this marker contains the subsampling factors we're scanning for */
                                 {
                                         uint16 n;
                                         uint16 o;
                                         uint8 p;
                                         uint8 ph,pv;
                                         if (!JPEGFixupTagsSubsamplingReadWord(data,&n))
                                                 return(0);
                                         if (n!=8+data->tif->tif_dir.td_samplesperpixel*3)
                                                 return(0);
@@ skipping 154 matching lines @@
 
         /* Set up for reading normal data */
         TIFFjpeg_data_src(sp, tif);
         tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */
         return (1);
 }
 
 /*
  * Set up for decoding a strip or tile.
  */
-static int
+/*ARGSUSED*/ static int
 JPEGPreDecode(TIFF* tif, uint16 s)
 {
         JPEGState *sp = JState(tif);
         TIFFDirectory *td = &tif->tif_dir;
         static const char module[] = "JPEGPreDecode";
         uint32 segment_width, segment_height;
         int downsampled_output;
         int ci;
 
         assert(sp != NULL);
@@ skipping 155 matching lines @@
                         return (0);
                 sp->scancount = DCTSIZE;        /* mark buffer empty */
         }
         return (1);
 }
 
 /*
  * Decode a chunk of pixels.
  * "Standard" case: returned data is not downsampled.
  */
-/*ARGSUSED*/ static int
+#if !JPEG_LIB_MK1_OR_12BIT
+static int
 JPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 {
         JPEGState *sp = JState(tif);
         tmsize_t nrows;
         (void) s;
 
         /*
         ** Update available information, buffer may have been refilled
         ** between decode requests
         */
         sp->src.next_input_byte = (const JOCTET*) tif->tif_rawcp;
         sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
 
         if( sp->bytesperline == 0 )
                 return 0;
         
         nrows = cc / sp->bytesperline;
         if (cc % sp->bytesperline)
-                TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline not read");
+                TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
+                               "fractional scanline not read");
 
         if( nrows > (tmsize_t) sp->cinfo.d.image_height )
                 nrows = sp->cinfo.d.image_height;
 
         /* data is expected to be read in multiples of a scanline */
         if (nrows)
-        {
-                JSAMPROW line_work_buf = NULL;
+        {
+                do
+                {
+                        /*
+                         * In the libjpeg6b-9a 8bit case.  We read directly into
+                         * the TIFF buffer.
+                         */
+                        JSAMPROW bufptr = (JSAMPROW)buf;
 
-                /*
-                 * For 6B, only use temporary buffer for 12 bit imagery.
-                 * For Mk1 always use it.
-                 */
-#if !defined(JPEG_LIB_MK1)
-                if( sp->cinfo.d.data_precision == 12 )
-#endif
-                {
-                        line_work_buf = (JSAMPROW)
-                            _TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width
-                            * sp->cinfo.d.num_components );
-                }
+                        if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)
+                                return (0);
 
-                do {
-                        if( line_work_buf != NULL )
-                        {
-                                /*
-                                 * In the MK1 case, we aways read into a 16bit buffer, and then
-                                 * pack down to 12bit or 8bit.  In 6B case we only read into 16
-                                 * bit buffer for 12bit data, which we need to repack.
-                                */
-                                if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)
-                                        return (0);
-
-                                if( sp->cinfo.d.data_precision == 12 )
-                                {
-                                        int value_pairs = (sp->cinfo.d.output_width
-                                            * sp->cinfo.d.num_components) / 2;
-                                        int iPair;
-
-                                        for( iPair = 0; iPair < value_pairs; iPair++ )
-                                        {
-                                                unsigned char *out_ptr =
-                                                    ((unsigned char *) buf) + iPair * 3;
-                                                JSAMPLE *in_ptr = line_work_buf + iPair * 2;
-
-                                                out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
-                                                out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
-                                                    | ((in_ptr[1] & 0xf00) >> 8);
-                                                out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
-                                        }
-                                }
-                                else if( sp->cinfo.d.data_precision == 8 )
-                                {
-                                        int value_count = (sp->cinfo.d.output_width
-                                            * sp->cinfo.d.num_components);
-                                        int iValue;
-
-                                        for( iValue = 0; iValue < value_count; iValue++ )
-                                        {
-                                                ((unsigned char *) buf)[iValue] =
-                                                    line_work_buf[iValue] & 0xff;
-                                        }
-                                }
-                        }
-                        else
-                        {
-                                /*
-                                 * In the libjpeg6b 8bit case.  We read directly into the
-                                 * TIFF buffer.
-                                */
-                                JSAMPROW bufptr = (JSAMPROW)buf;
-
-                                if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)
-                                        return (0);
-                        }
-
-                        ++tif->tif_row;
-                        buf += sp->bytesperline;
-                        cc -= sp->bytesperline;
-                } while (--nrows > 0);
-
-                if( line_work_buf != NULL )
-                        _TIFFfree( line_work_buf );
-        }
+                        ++tif->tif_row;
+                        buf += sp->bytesperline;
+                        cc -= sp->bytesperline;
+                } while (--nrows > 0);
+        }
 
         /* Update information on consumed data */
         tif->tif_rawcp = (uint8*) sp->src.next_input_byte;
+        tif->tif_rawcc = sp->src.bytes_in_buffer;
+                
+        /* Close down the decompressor if we've finished the strip or tile. */
+        return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
+                || TIFFjpeg_finish_decompress(sp);
+}
+#endif /* !JPEG_LIB_MK1_OR_12BIT */
+
+#if JPEG_LIB_MK1_OR_12BIT
+/*ARGSUSED*/ static int
+JPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
+{
+        JPEGState *sp = JState(tif);
+        tmsize_t nrows;
+        (void) s;
+
+        /*
+        ** Update available information, buffer may have been refilled
+        ** between decode requests
+        */
+        sp->src.next_input_byte = (const JOCTET*) tif->tif_rawcp;
+        sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
+
+        if( sp->bytesperline == 0 )
+                return 0;
+        
+        nrows = cc / sp->bytesperline;
+        if (cc % sp->bytesperline)
+                TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
+                               "fractional scanline not read");
+
+        if( nrows > (tmsize_t) sp->cinfo.d.image_height )
+                nrows = sp->cinfo.d.image_height;
+
+        /* data is expected to be read in multiples of a scanline */
+        if (nrows)
+        {
+                JSAMPROW line_work_buf = NULL;
+
+                /*
+                 * For 6B, only use temporary buffer for 12 bit imagery.
+                 * For Mk1 always use it.
+                 */
+                if( sp->cinfo.d.data_precision == 12 )
+                {
+                        line_work_buf = (JSAMPROW)
+                                _TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width
+                                            * sp->cinfo.d.num_components );
+                }
+
+               do
+               {
+                       if( line_work_buf != NULL )
+                       {
+                               /*
+                                * In the MK1 case, we aways read into a 16bit
+                                * buffer, and then pack down to 12bit or 8bit.
+                                * In 6B case we only read into 16 bit buffer
+                                * for 12bit data, which we need to repack.
+                                */
+                               if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)
+                                       return (0);
+
+                               if( sp->cinfo.d.data_precision == 12 )
+                               {
+                                       int value_pairs = (sp->cinfo.d.output_width
+                                                          * sp->cinfo.d.num_components) / 2;
+                                       int iPair;
+
+                                       for( iPair = 0; iPair < value_pairs; iPair++ )
+                                       {
+                                               unsigned char *out_ptr =
+                                                       ((unsigned char *) buf) + iPair * 3;
+                                               JSAMPLE *in_ptr = line_work_buf + iPair * 2;
+
+                                               out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
+                                               out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
+                                                       | ((in_ptr[1] & 0xf00) >> 8);
+                                               out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
+                                       }
+                               }
+                               else if( sp->cinfo.d.data_precision == 8 )
+                               {
+                                       int value_count = (sp->cinfo.d.output_width
+                                                          * sp->cinfo.d.num_components);
+                                       int iValue;
+
+                                       for( iValue = 0; iValue < value_count; iValue++ )
+                                       {
+                                               ((unsigned char *) buf)[iValue] =
+                                                       line_work_buf[iValue] & 0xff;
+                                       }
+                               }
+                       }
+
+                       ++tif->tif_row;
+                       buf += sp->bytesperline;
+                       cc -= sp->bytesperline;
+               } while (--nrows > 0);
+
+               if( line_work_buf != NULL )
+                       _TIFFfree( line_work_buf );
+        }
+
+        /* Update information on consumed data */
+        tif->tif_rawcp = (uint8*) sp->src.next_input_byte;
         tif->tif_rawcc = sp->src.bytes_in_buffer;
                 
         /* Close down the decompressor if we've finished the strip or tile. */
         return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
-            || TIFFjpeg_finish_decompress(sp);
+                || TIFFjpeg_finish_decompress(sp);
 }
+#endif /* JPEG_LIB_MK1_OR_12BIT */
 
 /*ARGSUSED*/ static int
 DecodeRowError(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 
 {
     (void) buf;
     (void) cc;
     (void) s;
 
     TIFFErrorExt(tif->tif_clientdata, "TIFFReadScanline",
@@ skipping 150 matching lines @@
 static void
 unsuppress_quant_table (JPEGState* sp, int tblno)
 {
         JQUANT_TBL* qtbl;
 
         if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
                 qtbl->sent_table = FALSE;
 }
 
 static void
+suppress_quant_table (JPEGState* sp, int tblno)
+{
+        JQUANT_TBL* qtbl;
+
+        if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
+                qtbl->sent_table = TRUE;
+}
+
+static void
 unsuppress_huff_table (JPEGState* sp, int tblno)
 {
         JHUFF_TBL* htbl;
 
         if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
                 htbl->sent_table = FALSE;
         if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
                 htbl->sent_table = FALSE;
 }
 
+static void
+suppress_huff_table (JPEGState* sp, int tblno)
+{
+        JHUFF_TBL* htbl;
+
+        if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
+                htbl->sent_table = TRUE;
+        if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
+                htbl->sent_table = TRUE;
+}
+
 static int
 prepare_JPEGTables(TIFF* tif)
 {
         JPEGState* sp = JState(tif);
 
         /* Initialize quant tables for current quality setting */
         if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
                 return (0);
         /* Mark only the tables we want for output */
         /* NB: chrominance tables are currently used only with YCbCr */
@@ skipping 29 matching lines @@
 #if defined(JPEG_DUAL_MODE_8_12) && !defined(TIFFInitJPEG)
         if( tif->tif_dir.td_bitspersample == 12 )
             return TIFFReInitJPEG_12( tif, COMPRESSION_JPEG, 1 );
 #endif
 
         JPEGInitializeLibJPEG( tif, FALSE );
 
         assert(sp != NULL);
         assert(!sp->cinfo.comm.is_decompressor);
 
+        sp->photometric = td->td_photometric;
+
         /*
          * Initialize all JPEG parameters to default values.
          * Note that jpeg_set_defaults needs legal values for
          * in_color_space and input_components.
          */
-        sp->cinfo.c.in_color_space = JCS_UNKNOWN;
-        sp->cinfo.c.input_components = 1;
+        if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
+                sp->cinfo.c.input_components = td->td_samplesperpixel;
+                if (sp->photometric == PHOTOMETRIC_YCBCR) {
+                        if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {
+                                sp->cinfo.c.in_color_space = JCS_RGB;
+                        } else {
+                                sp->cinfo.c.in_color_space = JCS_YCbCr;
+                        }
+                } else {
+                        if ((td->td_photometric == PHOTOMETRIC_MINISWHITE || td->td_photometric == PHOTOMETRIC_MINISBLACK) && td->td_samplesperpixel == 1)
+                                sp->cinfo.c.in_color_space = JCS_GRAYSCALE;
+                        else if (td->td_photometric == PHOTOMETRIC_RGB && td->td_samplesperpixel == 3)
+                                sp->cinfo.c.in_color_space = JCS_RGB;
+                        else if (td->td_photometric == PHOTOMETRIC_SEPARATED && td->td_samplesperpixel == 4)
+                                sp->cinfo.c.in_color_space = JCS_CMYK;
+                        else
+                                sp->cinfo.c.in_color_space = JCS_UNKNOWN;
+                }
+        } else {
+                sp->cinfo.c.input_components = 1;
+                sp->cinfo.c.in_color_space = JCS_UNKNOWN;
+        }
         if (!TIFFjpeg_set_defaults(sp))
                 return (0);
         /* Set per-file parameters */
-        sp->photometric = td->td_photometric;
         switch (sp->photometric) {
         case PHOTOMETRIC_YCBCR:
                 sp->h_sampling = td->td_ycbcrsubsampling[0];
                 sp->v_sampling = td->td_ycbcrsubsampling[1];
                 /*
                  * A ReferenceBlackWhite field *must* be present since the
                  * default value is inappropriate for YCbCr.  Fill in the
                  * proper value if application didn't set it.
                  */
                 {
@@ skipping 139 matching lines @@
         if (segment_width > 65535 || segment_height > 65535) {
                 TIFFErrorExt(tif->tif_clientdata, module, "Strip/tile too large for JPEG");
                 return (0);
         }
         sp->cinfo.c.image_width = segment_width;
         sp->cinfo.c.image_height = segment_height;
         downsampled_input = FALSE;
         if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
                 sp->cinfo.c.input_components = td->td_samplesperpixel;
                 if (sp->photometric == PHOTOMETRIC_YCBCR) {
-                        if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {
-                                sp->cinfo.c.in_color_space = JCS_RGB;
-                        } else {
-                                sp->cinfo.c.in_color_space = JCS_YCbCr;
+                        if (sp->jpegcolormode != JPEGCOLORMODE_RGB) {
                                 if (sp->h_sampling != 1 || sp->v_sampling != 1)
                                         downsampled_input = TRUE;
                         }
                         if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
                                 return (0);
                         /*
                          * Set Y sampling factors;
                          * we assume jpeg_set_colorspace() set the rest to 1
                          */
                         sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
                         sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
                 } else {
-                        if ((td->td_photometric == PHOTOMETRIC_MINISWHITE || td->td_photometric == PHOTOMETRIC_MINISBLACK) && td->td_samplesperpixel == 1)
-                                sp->cinfo.c.in_color_space = JCS_GRAYSCALE;
-                        else if (td->td_photometric == PHOTOMETRIC_RGB && td->td_samplesperpixel == 3)
-                                sp->cinfo.c.in_color_space = JCS_RGB;
-                        else if (td->td_photometric == PHOTOMETRIC_SEPARATED && td->td_samplesperpixel == 4)
-                                sp->cinfo.c.in_color_space = JCS_CMYK;
-                        else
-                                sp->cinfo.c.in_color_space = JCS_UNKNOWN;
                         if (!TIFFjpeg_set_colorspace(sp, sp->cinfo.c.in_color_space))
                                 return (0);
                         /* jpeg_set_colorspace set all sampling factors to 1 */
                 }
         } else {
-                sp->cinfo.c.input_components = 1;
-                sp->cinfo.c.in_color_space = JCS_UNKNOWN;
                 if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
                         return (0);
                 sp->cinfo.c.comp_info[0].component_id = s;
                 /* jpeg_set_colorspace() set sampling factors to 1 */
                 if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) {
                         sp->cinfo.c.comp_info[0].quant_tbl_no = 1;
                         sp->cinfo.c.comp_info[0].dc_tbl_no = 1;
                         sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
                 }
         }
         /* ensure libjpeg won't write any extraneous markers */
         sp->cinfo.c.write_JFIF_header = FALSE;
         sp->cinfo.c.write_Adobe_marker = FALSE;
         /* set up table handling correctly */
-        if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
+        /* calling TIFFjpeg_set_quality() causes quantization tables to be flagged */
+        /* as being to be emitted, which we don't want in the JPEGTABLESMODE_QUANT */
+        /* mode, so we must manually suppress them. However TIFFjpeg_set_quality() */
+        /* should really be called when dealing with files with directories with */
+        /* mixed qualities. see http://trac.osgeo.org/gdal/ticket/3539 */
+        if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
                 return (0);
-        if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) {
+        if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) {
+                suppress_quant_table(sp, 0);
+                suppress_quant_table(sp, 1);
+        }
+        else {
                 unsuppress_quant_table(sp, 0);
                 unsuppress_quant_table(sp, 1);
         }
         if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF)
+        {
+                /* Explicit suppression is only needed if we did not go through the */
+                /* prepare_JPEGTables() code path, which may be the case if updating */
+                /* an existing file */
+                suppress_huff_table(sp, 0);
+                suppress_huff_table(sp, 1);
                 sp->cinfo.c.optimize_coding = FALSE;
+        }
         else
                 sp->cinfo.c.optimize_coding = TRUE;
         if (downsampled_input) {
                 /* Need to use raw-data interface to libjpeg */
                 sp->cinfo.c.raw_data_in = TRUE;
                 tif->tif_encoderow = JPEGEncodeRaw;
                 tif->tif_encodestrip = JPEGEncodeRaw;
                 tif->tif_encodetile = JPEGEncodeRaw;
         } else {
                 /* Use normal interface to libjpeg */
@@ skipping 36 matching lines @@
         if (cc % sp->bytesperline)
             TIFFWarningExt(tif->tif_clientdata, tif->tif_name, 
                            "fractional scanline discarded");
 
         /* The last strip will be limited to image size */
         if( !isTiled(tif) && tif->tif_row+nrows > tif->tif_dir.td_imagelength )
             nrows = tif->tif_dir.td_imagelength - tif->tif_row;
 
         if( sp->cinfo.c.data_precision == 12 )
         {
-            line16_count = (int)((sp->bytesperline * 2) / 3);
+            line16_count = (sp->bytesperline * 2) / 3;
             line16 = (short *) _TIFFmalloc(sizeof(short) * line16_count);
-            // FIXME: undiagnosed malloc failure
+            if (!line16)
+            {
+                TIFFErrorExt(tif->tif_clientdata,
+                             "JPEGEncode",
+                             "Failed to allocate memory");
+
+                return 0;
+            }
         }
             
         while (nrows-- > 0) {
 
             if( sp->cinfo.c.data_precision == 12 )
             {
 
                 int value_pairs = line16_count / 2;
                 int iPair;
 
@@ skipping 154 matching lines @@
 static void
 JPEGCleanup(TIFF* tif)
 {
         JPEGState *sp = JState(tif);
         
         assert(sp != 0);
 
         tif->tif_tagmethods.vgetfield = sp->vgetparent;
         tif->tif_tagmethods.vsetfield = sp->vsetparent;
         tif->tif_tagmethods.printdir = sp->printdir;
-
-        if( sp != NULL ) {
-                if( sp->cinfo_initialized )
-                    TIFFjpeg_destroy(sp);       /* release libjpeg resources */
-                if (sp->jpegtables)             /* tag value */
-                        _TIFFfree(sp->jpegtables);
-        }
+        if( sp->cinfo_initialized )
+                TIFFjpeg_destroy(sp);   /* release libjpeg resources */
+        if (sp->jpegtables)             /* tag value */
+                _TIFFfree(sp->jpegtables);
         _TIFFfree(tif->tif_data);       /* release local state */
         tif->tif_data = NULL;
 
         _TIFFSetDefaultCompressionState(tif);
 }
 
 static void 
 JPEGResetUpsampled( TIFF* tif )
 {
         JPEGState* sp = JState(tif);
@@ skipping 291 matching lines @@
 /*
 The following line assumes incorrectly that all JPEG-in-TIFF files will have
 a JPEGTABLES tag generated and causes null-filled JPEGTABLES tags to be written
 when the JPEG data is placed with TIFFWriteRawStrip.  The field bit should be 
 set, anyway, later when actual JPEGTABLES header is generated, so removing it 
 here hopefully is harmless.
             TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
 */
             sp->jpegtables_length = SIZE_OF_JPEGTABLES;
             sp->jpegtables = (void *) _TIFFmalloc(sp->jpegtables_length);
-            // FIXME: NULL-deref after malloc failure
-            _TIFFmemset(sp->jpegtables, 0, SIZE_OF_JPEGTABLES);
+            if (sp->jpegtables)
+            {
+                _TIFFmemset(sp->jpegtables, 0, SIZE_OF_JPEGTABLES);
+            }
+            else
+            {
+                TIFFErrorExt(tif->tif_clientdata,
+                             "TIFFInitJPEG",
+                             "Failed to allocate memory for JPEG tables");
+                return 0;
+            }
 #undef SIZE_OF_JPEGTABLES
         }
 
         return 1;
 }
 #endif /* JPEG_SUPPORT */
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-