XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_getimage.c

-/* $Id: tif_getimage.c,v 1.82 2012-06-06 00:17:49 fwarmerdam Exp $ */
+/* $Id: tif_getimage.c,v 1.90 2015-06-17 01:34:08 bfriesen Exp $ */
 
 /*
  * Copyright (c) 1991-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 163 matching lines @@
                             td->td_compression != COMPRESSION_SGILOG24) {
                                 sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
                                     "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
                                 return (0);
                         }
                         if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
                                 sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
                                     "Planarconfiguration", td->td_planarconfig);
                                 return (0);
                         }
+                        if( td->td_samplesperpixel != 3 )
+            {
+                sprintf(emsg,
+                        "Sorry, can not handle image with %s=%d",
+                        "Samples/pixel", td->td_samplesperpixel);
+                return 0;
+            }
                         break;
                 case PHOTOMETRIC_CIELAB:
+            if( td->td_samplesperpixel != 3 || td->td_bitspersample != 8 )
+            {
+                sprintf(emsg,
+                        "Sorry, can not handle image with %s=%d and %s=%d",
+                        "Samples/pixel", td->td_samplesperpixel,
+                        "Bits/sample", td->td_bitspersample);
+                return 0;
+            }
                         break;
                 default:
                         sprintf(emsg, "Sorry, can not handle image with %s=%d",
                             photoTag, photometric);
                         return (0);
         }
         return (1);
 }
 
 void
@@ skipping 393 matching lines @@
 {
     TIFF* tif = img->tif;
     tileContigRoutine put = img->put.contig;
     uint32 col, row, y, rowstoread;
     tmsize_t pos;
     uint32 tw, th;
     unsigned char* buf;
     int32 fromskew, toskew;
     uint32 nrow;
     int ret = 1, flip;
+    uint32 this_tw, tocol;
+    int32 this_toskew, leftmost_toskew;
+    int32 leftmost_fromskew;
+    uint32 leftmost_tw;
 
     buf = (unsigned char*) _TIFFmalloc(TIFFTileSize(tif));
     if (buf == 0) {
                 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer");
                 return (0);
     }
     _TIFFmemset(buf, 0, TIFFTileSize(tif));
     TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
     TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
 
     flip = setorientation(img);
     if (flip & FLIP_VERTICALLY) {
             y = h - 1;
             toskew = -(int32)(tw + w);
     }
     else {
             y = 0;
             toskew = -(int32)(tw - w);
     }
      
+    /*
+     *  Leftmost tile is clipped on left side if col_offset > 0.
+     */
+    leftmost_fromskew = img->col_offset % tw;
+    leftmost_tw = tw - leftmost_fromskew;
+    leftmost_toskew = toskew + leftmost_fromskew;
     for (row = 0; row < h; row += nrow)
     {
         rowstoread = th - (row + img->row_offset) % th;
         nrow = (row + rowstoread > h ? h - row : rowstoread);
-        for (col = 0; col < w; col += tw) 
+        fromskew = leftmost_fromskew;
+        this_tw = leftmost_tw;
+        this_toskew = leftmost_toskew;
+        tocol = 0;
+        col = img->col_offset;
+        while (tocol < w)
         {
-            if (TIFFReadTile(tif, buf, col+img->col_offset,  
+            if (TIFFReadTile(tif, buf, col,  
                              row+img->row_offset, 0, 0)==(tmsize_t)(-1) && img->stoponerr)
             {
                 ret = 0;
                 break;
             }
-            
-            pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);  
-
-            if (col + tw > w) 
-            {
-                /*
-                 * Tile is clipped horizontally.  Calculate
-                 * visible portion and skewing factors.
-                 */
-                uint32 npix = w - col;
-                fromskew = tw - npix;
-                (*put)(img, raster+y*w+col, col, y,
-                       npix, nrow, fromskew, toskew + fromskew, buf + pos);
-            }
-            else 
-            {
-                (*put)(img, raster+y*w+col, col, y, tw, nrow, 0, toskew, buf + pos);
-            }
-        }
+            pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif) + \
+                   ((tmsize_t) fromskew * img->samplesperpixel);
+            if (tocol + this_tw > w) 
+            {
+                /*
+                 * Rightmost tile is clipped on right side.
+                 */
+                fromskew = tw - (w - tocol);
+                this_tw = tw - fromskew;
+                this_toskew = toskew + fromskew;
+            }
+            (*put)(img, raster+y*w+tocol, tocol, y, this_tw, nrow, fromskew, this_toskew, buf + pos);
+            tocol += this_tw;
+            col += this_tw;
+            /*
+             * After the leftmost tile, tiles are no longer clipped on left side.
+             */
+            fromskew = 0;
+            this_tw = tw;
+            this_toskew = toskew;
+        }
 
         y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
     }
     _TIFFfree(buf);
 
     if (flip & FLIP_HORIZONTALLY) {
             uint32 line;
 
             for (line = 0; line < h; line++) {
                     uint32 *left = raster + (line * w);
@@ skipping 30 matching lines @@
         unsigned char* p1;
         unsigned char* p2;
         unsigned char* pa;
         tmsize_t tilesize;
         tmsize_t bufsize;
         int32 fromskew, toskew;
         int alpha = img->alpha;
         uint32 nrow;
         int ret = 1, flip;
         int colorchannels;
+        uint32 this_tw, tocol;
+        int32 this_toskew, leftmost_toskew;
+        int32 leftmost_fromskew;
+        uint32 leftmost_tw;
 
         tilesize = TIFFTileSize(tif);  
         bufsize = TIFFSafeMultiply(tmsize_t,alpha?4:3,tilesize);
         if (bufsize == 0) {
                 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Integer overflow in %s", "gtTileSeparate");
                 return (0);
         }
         buf = (unsigned char*) _TIFFmalloc(bufsize);
         if (buf == 0) {
                 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer");
@@ skipping 24 matching lines @@
           case PHOTOMETRIC_PALETTE:
             colorchannels = 1;
             p2 = p1 = p0;
             break;
 
           default:
             colorchannels = 3;
             break;
         }
 
+        /*
+         *      Leftmost tile is clipped on left side if col_offset > 0.
+         */
+        leftmost_fromskew = img->col_offset % tw;
+        leftmost_tw = tw - leftmost_fromskew;
+        leftmost_toskew = toskew + leftmost_fromskew;
         for (row = 0; row < h; row += nrow)
         {
                 rowstoread = th - (row + img->row_offset) % th;
                 nrow = (row + rowstoread > h ? h - row : rowstoread);
-                for (col = 0; col < w; col += tw)
+                fromskew = leftmost_fromskew;
+                this_tw = leftmost_tw;
+                this_toskew = leftmost_toskew;
+                tocol = 0;
+                col = img->col_offset;
+                while (tocol < w)
                 {
-                        if (TIFFReadTile(tif, p0, col+img->col_offset,  
+                        if (TIFFReadTile(tif, p0, col,  
                             row+img->row_offset,0,0)==(tmsize_t)(-1) && img->stoponerr)
                         {
                                 ret = 0;
                                 break;
                         }
                         if (colorchannels > 1 
-                            && TIFFReadTile(tif, p1, col+img->col_offset,  
+                            && TIFFReadTile(tif, p1, col,  
                                             row+img->row_offset,0,1) == (tmsize_t)(-1) 
                             && img->stoponerr)
                         {
                                 ret = 0;
                                 break;
                         }
                         if (colorchannels > 1 
-                            && TIFFReadTile(tif, p2, col+img->col_offset,  
+                            && TIFFReadTile(tif, p2, col,  
                                             row+img->row_offset,0,2) == (tmsize_t)(-1) 
                             && img->stoponerr)
                         {
                                 ret = 0;
                                 break;
                         }
                         if (alpha
-                            && TIFFReadTile(tif,pa,col+img->col_offset,  
+                            && TIFFReadTile(tif,pa,col,  
                                             row+img->row_offset,0,colorchannels) == (tmsize_t)(-1) 
                             && img->stoponerr)
                         {
                             ret = 0;
                             break;
                         }
 
-                        pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);  
-
-                        if (col + tw > w)
+                        pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif) + \
+                           ((tmsize_t) fromskew * img->samplesperpixel);
+                        if (tocol + this_tw > w) 
                         {
                                 /*
-                                 * Tile is clipped horizontally.  Calculate
-                                 * visible portion and skewing factors.
+                                 * Rightmost tile is clipped on right side.
                                  */
-                                uint32 npix = w - col;
-                                fromskew = tw - npix;
-                                (*put)(img, raster+y*w+col, col, y,
-                                    npix, nrow, fromskew, toskew + fromskew,
-                                    p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
-                        } else {
-                                (*put)(img, raster+y*w+col, col, y,
-                                    tw, nrow, 0, toskew, p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
+                                fromskew = tw - (w - tocol);
+                                this_tw = tw - fromskew;
+                                this_toskew = toskew + fromskew;
                         }
+                        (*put)(img, raster+y*w+tocol, tocol, y, this_tw, nrow, fromskew, this_toskew, \
+                                p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
+                        tocol += this_tw;
+                        col += this_tw;
+                        /*
+                        * After the leftmost tile, tiles are no longer clipped on left side.
+                        */
+                        fromskew = 0;
+                        this_tw = tw;
+                        this_toskew = toskew;
                 }
 
                 y += (flip & FLIP_VERTICALLY ?-(int32) nrow : (int32) nrow);
         }
 
         if (flip & FLIP_HORIZONTALLY) {
                 uint32 line;
 
                 for (line = 0; line < h; line++) {
                         uint32 *left = raster + (line * w);
@@ skipping 26 matching lines @@
         uint32 row, y, nrow, nrowsub, rowstoread;
         tmsize_t pos;
         unsigned char* buf;
         uint32 rowsperstrip;
         uint16 subsamplinghor,subsamplingver;
         uint32 imagewidth = img->width;
         tmsize_t scanline;
         int32 fromskew, toskew;
         int ret = 1, flip;
 
+        TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver);
+        if( subsamplingver == 0 ) {
+                TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Invalid vertical YCbCr subsampling");
+                return (0);
+        }
+
         buf = (unsigned char*) _TIFFmalloc(TIFFStripSize(tif));
         if (buf == 0) {
                 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
                 return (0);
         }
         _TIFFmemset(buf, 0, TIFFStripSize(tif));
 
         flip = setorientation(img);
         if (flip & FLIP_VERTICALLY) {
                 y = h - 1;
                 toskew = -(int32)(w + w);
         } else {
                 y = 0;
                 toskew = -(int32)(w - w);
         }
 
         TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
-        TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver);
+
         scanline = TIFFScanlineSize(tif);
         fromskew = (w < imagewidth ? imagewidth - w : 0);
         for (row = 0; row < h; row += nrow)
         {
                 rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
                 nrow = (row + rowstoread > h ? h - row : rowstoread);
                 nrowsub = nrow;
                 if ((nrowsub%subsamplingver)!=0)
                         nrowsub+=subsamplingver-nrowsub%subsamplingver;
                 if (TIFFReadEncodedStrip(tif,
                     TIFFComputeStrip(tif,row+img->row_offset, 0),
                     buf,
                     ((row + img->row_offset)%rowsperstrip + nrowsub) * scanline)==(tmsize_t)(-1)
                     && img->stoponerr)
                 {
                         ret = 0;
                         break;
                 }
 
-                pos = ((row + img->row_offset) % rowsperstrip) * scanline;
+                pos = ((row + img->row_offset) % rowsperstrip) * scanline + \
+                        ((tmsize_t) img->col_offset * img->samplesperpixel);
                 (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf + pos);
                 y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
         }
 
         if (flip & FLIP_HORIZONTALLY) {
                 uint32 line;
 
                 for (line = 0; line < h; line++) {
                         uint32 *left = raster + (line * w);
                         uint32 *right = left + w - 1;
@@ skipping 110 matching lines @@
                 {
                         if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, colorchannels),
                             pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline)==(tmsize_t)(-1)
                             && img->stoponerr)
                         {
                                 ret = 0;
                                 break;
                         }
                 }
 
-                pos = ((row + img->row_offset) % rowsperstrip) * scanline;
+                pos = ((row + img->row_offset) % rowsperstrip) * scanline + \
+                        ((tmsize_t) img->col_offset * img->samplesperpixel);
                 (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, p0 + pos, p1 + pos,
                     p2 + pos, (alpha?(pa+pos):NULL));
                 y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
         }
 
         if (flip & FLIP_HORIZONTALLY) {
                 uint32 line;
 
                 for (line = 0; line < h; line++) {
                         uint32 *left = raster + (line * w);
@@ skipping 412 matching lines @@
                 cp += toskew;
                 wp += fromskew;
         }
 }
 
 /*
  * 8-bit packed CMYK samples w/o Map => RGB
  *
  * NB: The conversion of CMYK->RGB is *very* crude.
  */
-/*DECLAREContigPutFunc(putRGBcontig8bitCMYKtile)
+DECLAREContigPutFunc(putRGBcontig8bitCMYKtile)
 {
     int samplesperpixel = img->samplesperpixel;
     uint16 r, g, b, k;
-        
+
     (void) x; (void) y;
     fromskew *= samplesperpixel;
     while (h-- > 0) {
-                UNROLL8(w, NOP,
-                    k = 255 - pp[3];
-                    r = (k*(255-pp[0]))/255;
-                    g = (k*(255-pp[1]))/255;
-                    b = (k*(255-pp[2]))/255;
-                *cp++ = PACK(r, g, b);
-                pp += samplesperpixel);
-                cp += toskew;
-                pp += fromskew;
-}*/
-/* Modify in 20090723 by Sunliang.Liu */
-DECLAREContigPutFunc(putRGBcontig8bitCMYKtile)
-{
-        int samplesperpixel = img->samplesperpixel;
-        uint8 r, g, b, k;
-
-        (void) x; (void) y;
-        fromskew *= samplesperpixel;
-        while (h-- > 0) {
-                UNROLL8(w, NOP,
-                        if(!TIFFCmyk2Rgb(img->tif->tif_clientdata,pp[0],pp[1],pp[2],pp[3],
-                                &r,&g,&b)){
-                                        k = 255 - pp[3];
-                                        r = (k*(255-pp[0]))/255;
-                                        g = (k*(255-pp[1]))/255;
-                                        b = (k*(255-pp[2]))/255;
-                        }
-
-                        *cp++ = PACK(r, g, b);
-                        pp += samplesperpixel);
-                        cp += toskew;
-                        pp += fromskew;
-        }
+        UNROLL8(w, NOP,
+            k = 255 - pp[3];
+            r = (k*(255-pp[0]))/255;
+            g = (k*(255-pp[1]))/255;
+            b = (k*(255-pp[2]))/255;
+            *cp++ = PACK(r, g, b);
+            pp += samplesperpixel);
+        cp += toskew;
+        pp += fromskew;
+    }
 }
 
 /*
- * 16-bit packed CMYK samples w/o Map => RGB(8-bit)
- *
- * NB: The conversion of CMYK->RGB is *very* crude.
- */
-DECLAREContigPutFunc(putRGBcontig16bitCMYKtile)
-{
-        int samplesperpixel = img->samplesperpixel;
-        uint16* wp = (uint16*)pp;
-        uint8 C, M, Y, K;
-        uint8 r, g, b;
-
-        (void) x; (void) y;
-        fromskew *= samplesperpixel;
-        while (h-- > 0) {
-                UNROLL8(w, NOP,
-                        C = wp[0]>>8;M = wp[1]>>8;Y = wp[2]>>8;K = wp[3]>>8;
-                if(!TIFFCmyk2Rgb(img->tif->tif_clientdata,C,M,Y,K,
-                        &r,&g,&b)){
-                                K = 255 - K;
-                                r = (K*(255-C))/255;
-                                g = (K*(255-M))/255;
-                                b = (K*(255-Y))/255;
-                }
-
-                *cp++ = PACK(r, g, b);
-                wp += samplesperpixel);
-                cp += toskew;
-                wp += fromskew;
-        }
-}
-
-/*
  * 8-bit packed CMYK samples w/Map => RGB
  *
  * NB: The conversion of CMYK->RGB is *very* crude.
  */
-/*
 DECLAREContigPutFunc(putRGBcontig8bitCMYKMaptile)
 {
     int samplesperpixel = img->samplesperpixel;
     TIFFRGBValue* Map = img->Map;
     uint16 r, g, b, k;
 
     (void) y;
     fromskew *= samplesperpixel;
     while (h-- > 0) {
         for (x = w; x-- > 0;) {
             k = 255 - pp[3];
             r = (k*(255-pp[0]))/255;
             g = (k*(255-pp[1]))/255;
             b = (k*(255-pp[2]))/255;
             *cp++ = PACK(Map[r], Map[g], Map[b]);
             pp += samplesperpixel;
         }
         pp += fromskew;
         cp += toskew;
     }
-}*/
-/* Modify in 20090723 by Sunliang.Liu */
-DECLAREContigPutFunc(putRGBcontig8bitCMYKMaptile)
-{
-        int samplesperpixel = img->samplesperpixel;
-        TIFFRGBValue* Map = img->Map;
-        uint8 r, g, b, k;
-
-        (void) y;
-        fromskew *= samplesperpixel;
-        while (h-- > 0) {
-                for (x = w; x-- > 0;) {
-                        if(!TIFFCmyk2Rgb(img->tif->tif_clientdata,pp[0],pp[1],pp[2],pp[3],
-                                &r,&g,&b)){
-                                        k = 255 - pp[3];
-                                        r = (k*(255-pp[0]))/255;
-                                        g = (k*(255-pp[1]))/255;
-                                        b = (k*(255-pp[2]))/255;
-                        }
-                        *cp++ = PACK(Map[r], Map[g], Map[b]);
-                        pp += samplesperpixel;
-                }
-                pp += fromskew;
-                cp += toskew;
-        }
-}
-
-/*
- * 16-bit packed CMYK samples w/Map => RGB(8-bit)
- *
- * NB: The conversion of CMYK->RGB is *very* crude.
- */
-DECLAREContigPutFunc(putRGBcontig16bitCMYKMaptile)
-{
-        int samplesperpixel = img->samplesperpixel;
-        TIFFRGBValue* Map = img->Map;
-        uint16* wp = (uint16*)pp;
-        uint8 C, M, Y, K;
-        uint8 r, g, b;
-
-        (void) y;
-        fromskew *= samplesperpixel;
-        while (h-- > 0) {
-                for (x = w; x-- > 0;) {
-                        C = wp[0]>>8;M = wp[1]>>8;Y = wp[2]>>8;K = wp[3]>>8;
-                        if(!TIFFCmyk2Rgb(img->tif->tif_clientdata,C,M,Y,K,
-                                &r,&g,&b)){
-                                        K = 255 - K;
-                                        r = (K*(255-C))/255;
-                                        g = (K*(255-M))/255;
-                                        b = (K*(255-Y))/255;
-                        }
-                        *cp++ = PACK(Map[r], Map[g], Map[b]);
-                        wp += samplesperpixel;
-                }
-                wp += fromskew;
-                cp += toskew;
-        }
 }
 
 #define DECLARESepPutFunc(name) \
 static void name(\
     TIFFRGBAImage* img,\
     uint32* cp,\
     uint32 x, uint32 y, \
     uint32 w, uint32 h,\
     int32 fromskew, int32 toskew,\
     unsigned char* r, unsigned char* g, unsigned char* b, unsigned char* a\
@@ skipping 344 matching lines @@
 /*
  * 8-bit packed YCbCr samples w/ 4,2 subsampling => RGB
  */
 DECLAREContigPutFunc(putcontig8bitYCbCr42tile)
 {
     uint32* cp1 = cp+w+toskew;
     int32 incr = 2*toskew+w;
 
     (void) y;
     fromskew = (fromskew * 10) / 4;
-    if ((h & 3) == 0 && (w & 1) == 0) {
+    if ((w & 3) == 0 && (h & 1) == 0) {
         for (; h >= 2; h -= 2) {
             x = w>>2;
             do {
                 int32 Cb = pp[8];
                 int32 Cr = pp[9];
                 
                 YCbCrtoRGB(cp [0], pp[0]);
                 YCbCrtoRGB(cp [1], pp[1]);
                 YCbCrtoRGB(cp [2], pp[2]);
                 YCbCrtoRGB(cp [3], pp[3]);
@@ skipping 56 matching lines @@
 
 /*
  * 8-bit packed YCbCr samples w/ 4,1 subsampling => RGB
  */
 DECLAREContigPutFunc(putcontig8bitYCbCr41tile)
 {
     (void) y;
     /* XXX adjust fromskew */
     do {
         x = w>>2;
-        do {
+        while(x>0) {
             int32 Cb = pp[4];
             int32 Cr = pp[5];
 
             YCbCrtoRGB(cp [0], pp[0]);
             YCbCrtoRGB(cp [1], pp[1]);
             YCbCrtoRGB(cp [2], pp[2]);
             YCbCrtoRGB(cp [3], pp[3]);
 
             cp += 4;
             pp += 6;
-        } while (--x);
+                x--;
+        }
 
         if( (w&3) != 0 )
         {
             int32 Cb = pp[4];
             int32 Cr = pp[5];
 
             switch( (w&3) ) {
               case 3: YCbCrtoRGB(cp [2], pp[2]);
               case 2: YCbCrtoRGB(cp [1], pp[1]);
               case 1: YCbCrtoRGB(cp [0], pp[0]);
@@ skipping 70 matching lines @@
 
 /*
  * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB
  */
 DECLAREContigPutFunc(putcontig8bitYCbCr21tile)
 {
         (void) y;
         fromskew = (fromskew * 4) / 2;
         do {
                 x = w>>1;
-                do {
+                while(x>0) {
                         int32 Cb = pp[2];
                         int32 Cr = pp[3];
 
                         YCbCrtoRGB(cp[0], pp[0]);
                         YCbCrtoRGB(cp[1], pp[1]);
 
                         cp += 2;
                         pp += 4;
-                } while (--x);
+                        x --;
+                }
 
                 if( (w&1) != 0 )
                 {
                         int32 Cb = pp[2];
                         int32 Cr = pp[3];
 
                         YCbCrtoRGB(cp[0], pp[0]);
 
                         cp += 1;
                         pp += 4;
@@ skipping 137 matching lines @@
         refWhite[0] = whitePoint[0] / whitePoint[1] * refWhite[1];
         refWhite[2] = (1.0F - whitePoint[0] - whitePoint[1])
                       / whitePoint[1] * refWhite[1];
         if (TIFFCIELabToRGBInit(img->cielab, &display_sRGB, refWhite) < 0) {
                 TIFFErrorExt(img->tif->tif_clientdata, module,
                     "Failed to initialize CIE L*a*b*->RGB conversion state.");
                 _TIFFfree(img->cielab);
                 return NULL;
         }
 
-        return (tileContigRoutine)putcontig8bitCIELab;
+        return putcontig8bitCIELab;
 }
 
 /*
  * Greyscale images with less than 8 bits/sample are handled
  * with a table to avoid lots of shifts and masks.  The table
  * is setup so that put*bwtile (below) can retrieve 8/bitspersample
  * pixel values simply by indexing into the table with one
  * number.
  */
 static int
@@ skipping 261 matching lines @@
                                         {
                                                 if (BuildMapBitdepth16To8(img))
                                                         img->put.contig = putRGBcontig16bittile;
                                         }
                                         break;
                         }
                         break;
                 case PHOTOMETRIC_SEPARATED:
                         if (buildMap(img)) {
                                 if (img->bitspersample == 8) {
-                                if (!img->Map)
-                                        img->put.contig = putRGBcontig8bitCMYKtile;
-                                else
-                                        img->put.contig = putRGBcontig8bitCMYKMaptile;
+                                        if (!img->Map)
+                                                img->put.contig = putRGBcontig8bitCMYKtile;
+                                        else
+                                                img->put.contig = putRGBcontig8bitCMYKMaptile;
+                                }
                         }
-                        else if(img->bitspersample == 16) /*LiuSunliang added 16bpp CMYK support.*/
-                        {
-                                if (!img->Map)
-                                        img->put.contig = putRGBcontig16bitCMYKtile;
-                                else
-                                        img->put.contig = putRGBcontig16bitCMYKMaptile;
-                        }
-                }
-                break;
-        case PHOTOMETRIC_PALETTE:
+                        break;
+                case PHOTOMETRIC_PALETTE:
                         if (buildMap(img)) {
                                 switch (img->bitspersample) {
                                         case 8:
                                                 img->put.contig = put8bitcmaptile;
                                                 break;
                                         case 4:
                                                 img->put.contig = put4bitcmaptile;
                                                 break;
                                         case 2:
                                                 img->put.contig = put2bitcmaptile;
@@ skipping 33 matching lines @@
                         if ((img->bitspersample==8) && (img->samplesperpixel==3))
                         {
                                 if (initYCbCrConversion(img)!=0)
                                 {
                                         /*
                                          * The 6.0 spec says that subsampling must be
                                          * one of 1, 2, or 4, and that vertical subsampling
                                          * must always be <= horizontal subsampling; so
                                          * there are only a few possibilities and we just
                                          * enumerate the cases.
-                                         * Joris: added support for the [1,2] case, nonetheless, to accomodate
+                                         * Joris: added support for the [1,2] case, nonetheless, to accommodate
                                          * some OJPEG files
                                          */
                                         uint16 SubsamplingHor;
                                         uint16 SubsamplingVer;
                                         TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &SubsamplingHor, &SubsamplingVer);
                                         switch ((SubsamplingHor<<4)|SubsamplingVer) {
                                                 case 0x44:
                                                         img->put.contig = putcontig8bitYCbCr44tile;
                                                         break;
                                                 case 0x42:
@@ skipping 303 matching lines @@
 }
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-