Index: third_party/tiff_v403/tif_getimage.c |
diff --git a/third_party/tiff_v403/tif_getimage.c b/third_party/tiff_v403/tif_getimage.c |
deleted file mode 100644 |
index 35c478601832f54752e2c6a2f6f76b55c60ac8ab..0000000000000000000000000000000000000000 |
--- a/third_party/tiff_v403/tif_getimage.c |
+++ /dev/null |
@@ -1,2989 +0,0 @@ |
-/* $Id: tif_getimage.c,v 1.82 2012-06-06 00:17:49 fwarmerdam 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 |
- * 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. |
- */ |
- |
-/* |
- * TIFF Library |
- * |
- * Read and return a packed RGBA image. |
- */ |
-#include "tiffiop.h" |
-#include <stdio.h> |
- |
-static int gtTileContig(TIFFRGBAImage*, uint32*, uint32, uint32); |
-static int gtTileSeparate(TIFFRGBAImage*, uint32*, uint32, uint32); |
-static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32); |
-static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32); |
-static int PickContigCase(TIFFRGBAImage*); |
-static int PickSeparateCase(TIFFRGBAImage*); |
- |
-static int BuildMapUaToAa(TIFFRGBAImage* img); |
-static int BuildMapBitdepth16To8(TIFFRGBAImage* img); |
- |
-static const char photoTag[] = "PhotometricInterpretation"; |
- |
-/* |
- * Helper constants used in Orientation tag handling |
- */ |
-#define FLIP_VERTICALLY 0x01 |
-#define FLIP_HORIZONTALLY 0x02 |
- |
-/* |
- * Color conversion constants. We will define display types here. |
- */ |
- |
-static const TIFFDisplay display_sRGB = { |
- { /* XYZ -> luminance matrix */ |
- { 3.2410F, -1.5374F, -0.4986F }, |
- { -0.9692F, 1.8760F, 0.0416F }, |
- { 0.0556F, -0.2040F, 1.0570F } |
- }, |
- 100.0F, 100.0F, 100.0F, /* Light o/p for reference white */ |
- 255, 255, 255, /* Pixel values for ref. white */ |
- 1.0F, 1.0F, 1.0F, /* Residual light o/p for black pixel */ |
- 2.4F, 2.4F, 2.4F, /* Gamma values for the three guns */ |
-}; |
- |
-/* |
- * Check the image to see if TIFFReadRGBAImage can deal with it. |
- * 1/0 is returned according to whether or not the image can |
- * be handled. If 0 is returned, emsg contains the reason |
- * why it is being rejected. |
- */ |
-int |
-TIFFRGBAImageOK(TIFF* tif, char emsg[1024]) |
-{ |
- TIFFDirectory* td = &tif->tif_dir; |
- uint16 photometric; |
- int colorchannels; |
- |
- if (!tif->tif_decodestatus) { |
- sprintf(emsg, "Sorry, requested compression method is not configured"); |
- return (0); |
- } |
- switch (td->td_bitspersample) { |
- case 1: |
- case 2: |
- case 4: |
- case 8: |
- case 16: |
- break; |
- default: |
- sprintf(emsg, "Sorry, can not handle images with %d-bit samples", |
- td->td_bitspersample); |
- return (0); |
- } |
- colorchannels = td->td_samplesperpixel - td->td_extrasamples; |
- if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) { |
- switch (colorchannels) { |
- case 1: |
- photometric = PHOTOMETRIC_MINISBLACK; |
- break; |
- case 3: |
- photometric = PHOTOMETRIC_RGB; |
- break; |
- default: |
- sprintf(emsg, "Missing needed %s tag", photoTag); |
- return (0); |
- } |
- } |
- switch (photometric) { |
- case PHOTOMETRIC_MINISWHITE: |
- case PHOTOMETRIC_MINISBLACK: |
- case PHOTOMETRIC_PALETTE: |
- if (td->td_planarconfig == PLANARCONFIG_CONTIG |
- && td->td_samplesperpixel != 1 |
- && td->td_bitspersample < 8 ) { |
- sprintf(emsg, |
- "Sorry, can not handle contiguous data with %s=%d, " |
- "and %s=%d and Bits/Sample=%d", |
- photoTag, photometric, |
- "Samples/pixel", td->td_samplesperpixel, |
- td->td_bitspersample); |
- return (0); |
- } |
- /* |
- * We should likely validate that any extra samples are either |
- * to be ignored, or are alpha, and if alpha we should try to use |
- * them. But for now we won't bother with this. |
- */ |
- break; |
- case PHOTOMETRIC_YCBCR: |
- /* |
- * TODO: if at all meaningful and useful, make more complete |
- * support check here, or better still, refactor to let supporting |
- * code decide whether there is support and what meaningfull |
- * error to return |
- */ |
- break; |
- case PHOTOMETRIC_RGB: |
- if (colorchannels < 3) { |
- sprintf(emsg, "Sorry, can not handle RGB image with %s=%d", |
- "Color channels", colorchannels); |
- return (0); |
- } |
- break; |
- case PHOTOMETRIC_SEPARATED: |
- { |
- uint16 inkset; |
- TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset); |
- if (inkset != INKSET_CMYK) { |
- sprintf(emsg, |
- "Sorry, can not handle separated image with %s=%d", |
- "InkSet", inkset); |
- return 0; |
- } |
- if (td->td_samplesperpixel < 4) { |
- sprintf(emsg, |
- "Sorry, can not handle separated image with %s=%d", |
- "Samples/pixel", td->td_samplesperpixel); |
- return 0; |
- } |
- break; |
- } |
- case PHOTOMETRIC_LOGL: |
- if (td->td_compression != COMPRESSION_SGILOG) { |
- sprintf(emsg, "Sorry, LogL data must have %s=%d", |
- "Compression", COMPRESSION_SGILOG); |
- return (0); |
- } |
- break; |
- case PHOTOMETRIC_LOGLUV: |
- if (td->td_compression != COMPRESSION_SGILOG && |
- 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); |
- } |
- break; |
- case PHOTOMETRIC_CIELAB: |
- break; |
- default: |
- sprintf(emsg, "Sorry, can not handle image with %s=%d", |
- photoTag, photometric); |
- return (0); |
- } |
- return (1); |
-} |
- |
-void |
-TIFFRGBAImageEnd(TIFFRGBAImage* img) |
-{ |
- if (img->Map) |
- _TIFFfree(img->Map), img->Map = NULL; |
- if (img->BWmap) |
- _TIFFfree(img->BWmap), img->BWmap = NULL; |
- if (img->PALmap) |
- _TIFFfree(img->PALmap), img->PALmap = NULL; |
- if (img->ycbcr) |
- _TIFFfree(img->ycbcr), img->ycbcr = NULL; |
- if (img->cielab) |
- _TIFFfree(img->cielab), img->cielab = NULL; |
- if (img->UaToAa) |
- _TIFFfree(img->UaToAa), img->UaToAa = NULL; |
- if (img->Bitdepth16To8) |
- _TIFFfree(img->Bitdepth16To8), img->Bitdepth16To8 = NULL; |
- |
- if( img->redcmap ) { |
- _TIFFfree( img->redcmap ); |
- _TIFFfree( img->greencmap ); |
- _TIFFfree( img->bluecmap ); |
- img->redcmap = img->greencmap = img->bluecmap = NULL; |
- } |
-} |
- |
-static int |
-isCCITTCompression(TIFF* tif) |
-{ |
- uint16 compress; |
- TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress); |
- return (compress == COMPRESSION_CCITTFAX3 || |
- compress == COMPRESSION_CCITTFAX4 || |
- compress == COMPRESSION_CCITTRLE || |
- compress == COMPRESSION_CCITTRLEW); |
-} |
- |
-int |
-TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) |
-{ |
- uint16* sampleinfo; |
- uint16 extrasamples; |
- uint16 planarconfig; |
- uint16 compress; |
- int colorchannels; |
- uint16 *red_orig, *green_orig, *blue_orig; |
- int n_color; |
- |
- /* Initialize to normal values */ |
- img->row_offset = 0; |
- img->col_offset = 0; |
- img->redcmap = NULL; |
- img->greencmap = NULL; |
- img->bluecmap = NULL; |
- img->req_orientation = ORIENTATION_BOTLEFT; /* It is the default */ |
- |
- img->tif = tif; |
- img->stoponerr = stop; |
- TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample); |
- switch (img->bitspersample) { |
- case 1: |
- case 2: |
- case 4: |
- case 8: |
- case 16: |
- break; |
- default: |
- sprintf(emsg, "Sorry, can not handle images with %d-bit samples", |
- img->bitspersample); |
- goto fail_return; |
- } |
- img->alpha = 0; |
- TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel); |
- TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES, |
- &extrasamples, &sampleinfo); |
- if (extrasamples >= 1) |
- { |
- switch (sampleinfo[0]) { |
- case EXTRASAMPLE_UNSPECIFIED: /* Workaround for some images without */ |
- if (img->samplesperpixel > 3) /* correct info about alpha channel */ |
- img->alpha = EXTRASAMPLE_ASSOCALPHA; |
- break; |
- case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */ |
- case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */ |
- img->alpha = sampleinfo[0]; |
- break; |
- } |
- } |
- |
-#ifdef DEFAULT_EXTRASAMPLE_AS_ALPHA |
- if( !TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) |
- img->photometric = PHOTOMETRIC_MINISWHITE; |
- |
- if( extrasamples == 0 |
- && img->samplesperpixel == 4 |
- && img->photometric == PHOTOMETRIC_RGB ) |
- { |
- img->alpha = EXTRASAMPLE_ASSOCALPHA; |
- extrasamples = 1; |
- } |
-#endif |
- |
- colorchannels = img->samplesperpixel - extrasamples; |
- TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress); |
- TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig); |
- if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) { |
- switch (colorchannels) { |
- case 1: |
- if (isCCITTCompression(tif)) |
- img->photometric = PHOTOMETRIC_MINISWHITE; |
- else |
- img->photometric = PHOTOMETRIC_MINISBLACK; |
- break; |
- case 3: |
- img->photometric = PHOTOMETRIC_RGB; |
- break; |
- default: |
- sprintf(emsg, "Missing needed %s tag", photoTag); |
- goto fail_return; |
- } |
- } |
- switch (img->photometric) { |
- case PHOTOMETRIC_PALETTE: |
- if (!TIFFGetField(tif, TIFFTAG_COLORMAP, |
- &red_orig, &green_orig, &blue_orig)) { |
- sprintf(emsg, "Missing required \"Colormap\" tag"); |
- goto fail_return; |
- } |
- |
- /* copy the colormaps so we can modify them */ |
- n_color = (1L << img->bitspersample); |
- img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); |
- img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); |
- img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); |
- if( !img->redcmap || !img->greencmap || !img->bluecmap ) { |
- sprintf(emsg, "Out of memory for colormap copy"); |
- goto fail_return; |
- } |
- |
- _TIFFmemcpy( img->redcmap, red_orig, n_color * 2 ); |
- _TIFFmemcpy( img->greencmap, green_orig, n_color * 2 ); |
- _TIFFmemcpy( img->bluecmap, blue_orig, n_color * 2 ); |
- |
- /* fall thru... */ |
- case PHOTOMETRIC_MINISWHITE: |
- case PHOTOMETRIC_MINISBLACK: |
- if (planarconfig == PLANARCONFIG_CONTIG |
- && img->samplesperpixel != 1 |
- && img->bitspersample < 8 ) { |
- sprintf(emsg, |
- "Sorry, can not handle contiguous data with %s=%d, " |
- "and %s=%d and Bits/Sample=%d", |
- photoTag, img->photometric, |
- "Samples/pixel", img->samplesperpixel, |
- img->bitspersample); |
- goto fail_return; |
- } |
- break; |
- case PHOTOMETRIC_YCBCR: |
- /* It would probably be nice to have a reality check here. */ |
- if (planarconfig == PLANARCONFIG_CONTIG) |
- /* can rely on libjpeg to convert to RGB */ |
- /* XXX should restore current state on exit */ |
- switch (compress) { |
- case COMPRESSION_JPEG: |
- /* |
- * TODO: when complete tests verify complete desubsampling |
- * and YCbCr handling, remove use of TIFFTAG_JPEGCOLORMODE in |
- * favor of tif_getimage.c native handling |
- */ |
- TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); |
- img->photometric = PHOTOMETRIC_RGB; |
- break; |
- default: |
- /* do nothing */; |
- break; |
- } |
- /* |
- * TODO: if at all meaningful and useful, make more complete |
- * support check here, or better still, refactor to let supporting |
- * code decide whether there is support and what meaningfull |
- * error to return |
- */ |
- break; |
- case PHOTOMETRIC_RGB: |
- if (colorchannels < 3) { |
- sprintf(emsg, "Sorry, can not handle RGB image with %s=%d", |
- "Color channels", colorchannels); |
- goto fail_return; |
- } |
- break; |
- case PHOTOMETRIC_SEPARATED: |
- { |
- uint16 inkset; |
- TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset); |
- if (inkset != INKSET_CMYK) { |
- sprintf(emsg, "Sorry, can not handle separated image with %s=%d", |
- "InkSet", inkset); |
- goto fail_return; |
- } |
- if (img->samplesperpixel < 4) { |
- sprintf(emsg, "Sorry, can not handle separated image with %s=%d", |
- "Samples/pixel", img->samplesperpixel); |
- goto fail_return; |
- } |
- } |
- break; |
- case PHOTOMETRIC_LOGL: |
- if (compress != COMPRESSION_SGILOG) { |
- sprintf(emsg, "Sorry, LogL data must have %s=%d", |
- "Compression", COMPRESSION_SGILOG); |
- goto fail_return; |
- } |
- TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT); |
- img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */ |
- img->bitspersample = 8; |
- break; |
- case PHOTOMETRIC_LOGLUV: |
- if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) { |
- sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d", |
- "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24); |
- goto fail_return; |
- } |
- if (planarconfig != PLANARCONFIG_CONTIG) { |
- sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d", |
- "Planarconfiguration", planarconfig); |
- return (0); |
- } |
- TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT); |
- img->photometric = PHOTOMETRIC_RGB; /* little white lie */ |
- img->bitspersample = 8; |
- break; |
- case PHOTOMETRIC_CIELAB: |
- break; |
- default: |
- sprintf(emsg, "Sorry, can not handle image with %s=%d", |
- photoTag, img->photometric); |
- goto fail_return; |
- } |
- img->Map = NULL; |
- img->BWmap = NULL; |
- img->PALmap = NULL; |
- img->ycbcr = NULL; |
- img->cielab = NULL; |
- img->UaToAa = NULL; |
- img->Bitdepth16To8 = NULL; |
- TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width); |
- TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height); |
- TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation); |
- img->isContig = |
- !(planarconfig == PLANARCONFIG_SEPARATE && img->samplesperpixel > 1); |
- if (img->isContig) { |
- if (!PickContigCase(img)) { |
- sprintf(emsg, "Sorry, can not handle image"); |
- goto fail_return; |
- } |
- } else { |
- if (!PickSeparateCase(img)) { |
- sprintf(emsg, "Sorry, can not handle image"); |
- goto fail_return; |
- } |
- } |
- return 1; |
- |
- fail_return: |
- _TIFFfree( img->redcmap ); |
- _TIFFfree( img->greencmap ); |
- _TIFFfree( img->bluecmap ); |
- img->redcmap = img->greencmap = img->bluecmap = NULL; |
- return 0; |
-} |
- |
-int |
-TIFFRGBAImageGet(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) |
-{ |
- if (img->get == NULL) { |
- TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No \"get\" routine setup"); |
- return (0); |
- } |
- if (img->put.any == NULL) { |
- TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), |
- "No \"put\" routine setupl; probably can not handle image format"); |
- return (0); |
- } |
- return (*img->get)(img, raster, w, h); |
-} |
- |
-/* |
- * Read the specified image into an ABGR-format rastertaking in account |
- * specified orientation. |
- */ |
-int |
-TIFFReadRGBAImageOriented(TIFF* tif, |
- uint32 rwidth, uint32 rheight, uint32* raster, |
- int orientation, int stop) |
-{ |
- char emsg[1024] = ""; |
- TIFFRGBAImage img; |
- int ok; |
- |
- if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, stop, emsg)) { |
- img.req_orientation = orientation; |
- /* XXX verify rwidth and rheight against width and height */ |
- ok = TIFFRGBAImageGet(&img, raster+(rheight-img.height)*rwidth, |
- rwidth, img.height); |
- TIFFRGBAImageEnd(&img); |
- } else { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg); |
- ok = 0; |
- } |
- return (ok); |
-} |
- |
-/* |
- * Read the specified image into an ABGR-format raster. Use bottom left |
- * origin for raster by default. |
- */ |
-int |
-TIFFReadRGBAImage(TIFF* tif, |
- uint32 rwidth, uint32 rheight, uint32* raster, int stop) |
-{ |
- return TIFFReadRGBAImageOriented(tif, rwidth, rheight, raster, |
- ORIENTATION_BOTLEFT, stop); |
-} |
- |
-static int |
-setorientation(TIFFRGBAImage* img) |
-{ |
- switch (img->orientation) { |
- case ORIENTATION_TOPLEFT: |
- case ORIENTATION_LEFTTOP: |
- if (img->req_orientation == ORIENTATION_TOPRIGHT || |
- img->req_orientation == ORIENTATION_RIGHTTOP) |
- return FLIP_HORIZONTALLY; |
- else if (img->req_orientation == ORIENTATION_BOTRIGHT || |
- img->req_orientation == ORIENTATION_RIGHTBOT) |
- return FLIP_HORIZONTALLY | FLIP_VERTICALLY; |
- else if (img->req_orientation == ORIENTATION_BOTLEFT || |
- img->req_orientation == ORIENTATION_LEFTBOT) |
- return FLIP_VERTICALLY; |
- else |
- return 0; |
- case ORIENTATION_TOPRIGHT: |
- case ORIENTATION_RIGHTTOP: |
- if (img->req_orientation == ORIENTATION_TOPLEFT || |
- img->req_orientation == ORIENTATION_LEFTTOP) |
- return FLIP_HORIZONTALLY; |
- else if (img->req_orientation == ORIENTATION_BOTRIGHT || |
- img->req_orientation == ORIENTATION_RIGHTBOT) |
- return FLIP_VERTICALLY; |
- else if (img->req_orientation == ORIENTATION_BOTLEFT || |
- img->req_orientation == ORIENTATION_LEFTBOT) |
- return FLIP_HORIZONTALLY | FLIP_VERTICALLY; |
- else |
- return 0; |
- case ORIENTATION_BOTRIGHT: |
- case ORIENTATION_RIGHTBOT: |
- if (img->req_orientation == ORIENTATION_TOPLEFT || |
- img->req_orientation == ORIENTATION_LEFTTOP) |
- return FLIP_HORIZONTALLY | FLIP_VERTICALLY; |
- else if (img->req_orientation == ORIENTATION_TOPRIGHT || |
- img->req_orientation == ORIENTATION_RIGHTTOP) |
- return FLIP_VERTICALLY; |
- else if (img->req_orientation == ORIENTATION_BOTLEFT || |
- img->req_orientation == ORIENTATION_LEFTBOT) |
- return FLIP_HORIZONTALLY; |
- else |
- return 0; |
- case ORIENTATION_BOTLEFT: |
- case ORIENTATION_LEFTBOT: |
- if (img->req_orientation == ORIENTATION_TOPLEFT || |
- img->req_orientation == ORIENTATION_LEFTTOP) |
- return FLIP_VERTICALLY; |
- else if (img->req_orientation == ORIENTATION_TOPRIGHT || |
- img->req_orientation == ORIENTATION_RIGHTTOP) |
- return FLIP_HORIZONTALLY | FLIP_VERTICALLY; |
- else if (img->req_orientation == ORIENTATION_BOTRIGHT || |
- img->req_orientation == ORIENTATION_RIGHTBOT) |
- return FLIP_HORIZONTALLY; |
- else |
- return 0; |
- default: /* NOTREACHED */ |
- return 0; |
- } |
-} |
- |
-/* |
- * Get an tile-organized image that has |
- * PlanarConfiguration contiguous if SamplesPerPixel > 1 |
- * or |
- * SamplesPerPixel == 1 |
- */ |
-static int |
-gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) |
-{ |
- 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; |
- |
- 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); |
- } |
- |
- 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) |
- { |
- if (TIFFReadTile(tif, buf, col+img->col_offset, |
- 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); |
- } |
- } |
- |
- 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); |
- uint32 *right = left + w - 1; |
- |
- while ( left < right ) { |
- uint32 temp = *left; |
- *left = *right; |
- *right = temp; |
- left++, right--; |
- } |
- } |
- } |
- |
- return (ret); |
-} |
- |
-/* |
- * Get an tile-organized image that has |
- * SamplesPerPixel > 1 |
- * PlanarConfiguration separated |
- * We assume that all such images are RGB. |
- */ |
-static int |
-gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) |
-{ |
- TIFF* tif = img->tif; |
- tileSeparateRoutine put = img->put.separate; |
- uint32 col, row, y, rowstoread; |
- tmsize_t pos; |
- uint32 tw, th; |
- unsigned char* buf; |
- unsigned char* p0; |
- 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; |
- |
- 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"); |
- return (0); |
- } |
- _TIFFmemset(buf, 0, bufsize); |
- p0 = buf; |
- p1 = p0 + tilesize; |
- p2 = p1 + tilesize; |
- pa = (alpha?(p2+tilesize):NULL); |
- 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); |
- } |
- |
- switch( img->photometric ) |
- { |
- case PHOTOMETRIC_MINISWHITE: |
- case PHOTOMETRIC_MINISBLACK: |
- case PHOTOMETRIC_PALETTE: |
- colorchannels = 1; |
- p2 = p1 = p0; |
- break; |
- |
- default: |
- colorchannels = 3; |
- break; |
- } |
- |
- 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) |
- { |
- if (TIFFReadTile(tif, p0, col+img->col_offset, |
- row+img->row_offset,0,0)==(tmsize_t)(-1) && img->stoponerr) |
- { |
- ret = 0; |
- break; |
- } |
- if (colorchannels > 1 |
- && TIFFReadTile(tif, p1, col+img->col_offset, |
- row+img->row_offset,0,1) == (tmsize_t)(-1) |
- && img->stoponerr) |
- { |
- ret = 0; |
- break; |
- } |
- if (colorchannels > 1 |
- && TIFFReadTile(tif, p2, col+img->col_offset, |
- row+img->row_offset,0,2) == (tmsize_t)(-1) |
- && img->stoponerr) |
- { |
- ret = 0; |
- break; |
- } |
- if (alpha |
- && TIFFReadTile(tif,pa,col+img->col_offset, |
- 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) |
- { |
- /* |
- * 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, |
- 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)); |
- } |
- } |
- |
- 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; |
- |
- while ( left < right ) { |
- uint32 temp = *left; |
- *left = *right; |
- *right = temp; |
- left++, right--; |
- } |
- } |
- } |
- |
- _TIFFfree(buf); |
- return (ret); |
-} |
- |
-/* |
- * Get a strip-organized image that has |
- * PlanarConfiguration contiguous if SamplesPerPixel > 1 |
- * or |
- * SamplesPerPixel == 1 |
- */ |
-static int |
-gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) |
-{ |
- TIFF* tif = img->tif; |
- tileContigRoutine put = img->put.contig; |
- 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; |
- |
- 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; |
- (*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; |
- |
- while ( left < right ) { |
- uint32 temp = *left; |
- *left = *right; |
- *right = temp; |
- left++, right--; |
- } |
- } |
- } |
- |
- _TIFFfree(buf); |
- return (ret); |
-} |
- |
-/* |
- * Get a strip-organized image with |
- * SamplesPerPixel > 1 |
- * PlanarConfiguration separated |
- * We assume that all such images are RGB. |
- */ |
-static int |
-gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) |
-{ |
- TIFF* tif = img->tif; |
- tileSeparateRoutine put = img->put.separate; |
- unsigned char *buf; |
- unsigned char *p0, *p1, *p2, *pa; |
- uint32 row, y, nrow, rowstoread; |
- tmsize_t pos; |
- tmsize_t scanline; |
- uint32 rowsperstrip, offset_row; |
- uint32 imagewidth = img->width; |
- tmsize_t stripsize; |
- tmsize_t bufsize; |
- int32 fromskew, toskew; |
- int alpha = img->alpha; |
- int ret = 1, flip, colorchannels; |
- |
- stripsize = TIFFStripSize(tif); |
- bufsize = TIFFSafeMultiply(tmsize_t,alpha?4:3,stripsize); |
- if (bufsize == 0) { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Integer overflow in %s", "gtStripSeparate"); |
- return (0); |
- } |
- p0 = buf = (unsigned char *)_TIFFmalloc(bufsize); |
- if (buf == 0) { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer"); |
- return (0); |
- } |
- _TIFFmemset(buf, 0, bufsize); |
- p1 = p0 + stripsize; |
- p2 = p1 + stripsize; |
- pa = (alpha?(p2+stripsize):NULL); |
- |
- flip = setorientation(img); |
- if (flip & FLIP_VERTICALLY) { |
- y = h - 1; |
- toskew = -(int32)(w + w); |
- } |
- else { |
- y = 0; |
- toskew = -(int32)(w - w); |
- } |
- |
- switch( img->photometric ) |
- { |
- case PHOTOMETRIC_MINISWHITE: |
- case PHOTOMETRIC_MINISBLACK: |
- case PHOTOMETRIC_PALETTE: |
- colorchannels = 1; |
- p2 = p1 = p0; |
- break; |
- |
- default: |
- colorchannels = 3; |
- break; |
- } |
- |
- TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); |
- 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); |
- offset_row = row + img->row_offset; |
- if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0), |
- p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline)==(tmsize_t)(-1) |
- && img->stoponerr) |
- { |
- ret = 0; |
- break; |
- } |
- if (colorchannels > 1 |
- && TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), |
- p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) |
- && img->stoponerr) |
- { |
- ret = 0; |
- break; |
- } |
- if (colorchannels > 1 |
- && TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), |
- p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) |
- && img->stoponerr) |
- { |
- ret = 0; |
- break; |
- } |
- if (alpha) |
- { |
- 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; |
- (*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); |
- uint32 *right = left + w - 1; |
- |
- while ( left < right ) { |
- uint32 temp = *left; |
- *left = *right; |
- *right = temp; |
- left++, right--; |
- } |
- } |
- } |
- |
- _TIFFfree(buf); |
- return (ret); |
-} |
- |
-/* |
- * The following routines move decoded data returned |
- * from the TIFF library into rasters filled with packed |
- * ABGR pixels (i.e. suitable for passing to lrecwrite.) |
- * |
- * The routines have been created according to the most |
- * important cases and optimized. PickContigCase and |
- * PickSeparateCase analyze the parameters and select |
- * the appropriate "get" and "put" routine to use. |
- */ |
-#define REPEAT8(op) REPEAT4(op); REPEAT4(op) |
-#define REPEAT4(op) REPEAT2(op); REPEAT2(op) |
-#define REPEAT2(op) op; op |
-#define CASE8(x,op) \ |
- switch (x) { \ |
- case 7: op; case 6: op; case 5: op; \ |
- case 4: op; case 3: op; case 2: op; \ |
- case 1: op; \ |
- } |
-#define CASE4(x,op) switch (x) { case 3: op; case 2: op; case 1: op; } |
-#define NOP |
- |
-#define UNROLL8(w, op1, op2) { \ |
- uint32 _x; \ |
- for (_x = w; _x >= 8; _x -= 8) { \ |
- op1; \ |
- REPEAT8(op2); \ |
- } \ |
- if (_x > 0) { \ |
- op1; \ |
- CASE8(_x,op2); \ |
- } \ |
-} |
-#define UNROLL4(w, op1, op2) { \ |
- uint32 _x; \ |
- for (_x = w; _x >= 4; _x -= 4) { \ |
- op1; \ |
- REPEAT4(op2); \ |
- } \ |
- if (_x > 0) { \ |
- op1; \ |
- CASE4(_x,op2); \ |
- } \ |
-} |
-#define UNROLL2(w, op1, op2) { \ |
- uint32 _x; \ |
- for (_x = w; _x >= 2; _x -= 2) { \ |
- op1; \ |
- REPEAT2(op2); \ |
- } \ |
- if (_x) { \ |
- op1; \ |
- op2; \ |
- } \ |
-} |
- |
-#define SKEW(r,g,b,skew) { r += skew; g += skew; b += skew; } |
-#define SKEW4(r,g,b,a,skew) { r += skew; g += skew; b += skew; a+= skew; } |
- |
-#define A1 (((uint32)0xffL)<<24) |
-#define PACK(r,g,b) \ |
- ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|A1) |
-#define PACK4(r,g,b,a) \ |
- ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|((uint32)(a)<<24)) |
-#define W2B(v) (((v)>>8)&0xff) |
-/* TODO: PACKW should have be made redundant in favor of Bitdepth16To8 LUT */ |
-#define PACKW(r,g,b) \ |
- ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|A1) |
-#define PACKW4(r,g,b,a) \ |
- ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|((uint32)W2B(a)<<24)) |
- |
-#define DECLAREContigPutFunc(name) \ |
-static void name(\ |
- TIFFRGBAImage* img, \ |
- uint32* cp, \ |
- uint32 x, uint32 y, \ |
- uint32 w, uint32 h, \ |
- int32 fromskew, int32 toskew, \ |
- unsigned char* pp \ |
-) |
- |
-/* |
- * 8-bit palette => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put8bitcmaptile) |
-{ |
- uint32** PALmap = img->PALmap; |
- int samplesperpixel = img->samplesperpixel; |
- |
- (void) y; |
- while (h-- > 0) { |
- for (x = w; x-- > 0;) |
- { |
- *cp++ = PALmap[*pp][0]; |
- pp += samplesperpixel; |
- } |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 4-bit palette => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put4bitcmaptile) |
-{ |
- uint32** PALmap = img->PALmap; |
- |
- (void) x; (void) y; |
- fromskew /= 2; |
- while (h-- > 0) { |
- uint32* bw; |
- UNROLL2(w, bw = PALmap[*pp++], *cp++ = *bw++); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 2-bit palette => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put2bitcmaptile) |
-{ |
- uint32** PALmap = img->PALmap; |
- |
- (void) x; (void) y; |
- fromskew /= 4; |
- while (h-- > 0) { |
- uint32* bw; |
- UNROLL4(w, bw = PALmap[*pp++], *cp++ = *bw++); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 1-bit palette => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put1bitcmaptile) |
-{ |
- uint32** PALmap = img->PALmap; |
- |
- (void) x; (void) y; |
- fromskew /= 8; |
- while (h-- > 0) { |
- uint32* bw; |
- UNROLL8(w, bw = PALmap[*pp++], *cp++ = *bw++); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 8-bit greyscale => colormap/RGB |
- */ |
-DECLAREContigPutFunc(putgreytile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- uint32** BWmap = img->BWmap; |
- |
- (void) y; |
- while (h-- > 0) { |
- for (x = w; x-- > 0;) |
- { |
- *cp++ = BWmap[*pp][0]; |
- pp += samplesperpixel; |
- } |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 8-bit greyscale with associated alpha => colormap/RGBA |
- */ |
-DECLAREContigPutFunc(putagreytile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- uint32** BWmap = img->BWmap; |
- |
- (void) y; |
- while (h-- > 0) { |
- for (x = w; x-- > 0;) |
- { |
- *cp++ = BWmap[*pp][0] & (*(pp+1) << 24 | ~A1); |
- pp += samplesperpixel; |
- } |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 16-bit greyscale => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put16bitbwtile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- uint32** BWmap = img->BWmap; |
- |
- (void) y; |
- while (h-- > 0) { |
- uint16 *wp = (uint16 *) pp; |
- |
- for (x = w; x-- > 0;) |
- { |
- /* use high order byte of 16bit value */ |
- |
- *cp++ = BWmap[*wp >> 8][0]; |
- pp += 2 * samplesperpixel; |
- wp += samplesperpixel; |
- } |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 1-bit bilevel => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put1bitbwtile) |
-{ |
- uint32** BWmap = img->BWmap; |
- |
- (void) x; (void) y; |
- fromskew /= 8; |
- while (h-- > 0) { |
- uint32* bw; |
- UNROLL8(w, bw = BWmap[*pp++], *cp++ = *bw++); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 2-bit greyscale => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put2bitbwtile) |
-{ |
- uint32** BWmap = img->BWmap; |
- |
- (void) x; (void) y; |
- fromskew /= 4; |
- while (h-- > 0) { |
- uint32* bw; |
- UNROLL4(w, bw = BWmap[*pp++], *cp++ = *bw++); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 4-bit greyscale => colormap/RGB |
- */ |
-DECLAREContigPutFunc(put4bitbwtile) |
-{ |
- uint32** BWmap = img->BWmap; |
- |
- (void) x; (void) y; |
- fromskew /= 2; |
- while (h-- > 0) { |
- uint32* bw; |
- UNROLL2(w, bw = BWmap[*pp++], *cp++ = *bw++); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 8-bit packed samples, no Map => RGB |
- */ |
-DECLAREContigPutFunc(putRGBcontig8bittile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- |
- (void) x; (void) y; |
- fromskew *= samplesperpixel; |
- while (h-- > 0) { |
- UNROLL8(w, NOP, |
- *cp++ = PACK(pp[0], pp[1], pp[2]); |
- pp += samplesperpixel); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 8-bit packed samples => RGBA w/ associated alpha |
- * (known to have Map == NULL) |
- */ |
-DECLAREContigPutFunc(putRGBAAcontig8bittile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- |
- (void) x; (void) y; |
- fromskew *= samplesperpixel; |
- while (h-- > 0) { |
- UNROLL8(w, NOP, |
- *cp++ = PACK4(pp[0], pp[1], pp[2], pp[3]); |
- pp += samplesperpixel); |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 8-bit packed samples => RGBA w/ unassociated alpha |
- * (known to have Map == NULL) |
- */ |
-DECLAREContigPutFunc(putRGBUAcontig8bittile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- (void) y; |
- fromskew *= samplesperpixel; |
- while (h-- > 0) { |
- uint32 r, g, b, a; |
- uint8* m; |
- for (x = w; x-- > 0;) { |
- a = pp[3]; |
- m = img->UaToAa+(a<<8); |
- r = m[pp[0]]; |
- g = m[pp[1]]; |
- b = m[pp[2]]; |
- *cp++ = PACK4(r,g,b,a); |
- pp += samplesperpixel; |
- } |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * 16-bit packed samples => RGB |
- */ |
-DECLAREContigPutFunc(putRGBcontig16bittile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- uint16 *wp = (uint16 *)pp; |
- (void) y; |
- fromskew *= samplesperpixel; |
- while (h-- > 0) { |
- for (x = w; x-- > 0;) { |
- *cp++ = PACK(img->Bitdepth16To8[wp[0]], |
- img->Bitdepth16To8[wp[1]], |
- img->Bitdepth16To8[wp[2]]); |
- wp += samplesperpixel; |
- } |
- cp += toskew; |
- wp += fromskew; |
- } |
-} |
- |
-/* |
- * 16-bit packed samples => RGBA w/ associated alpha |
- * (known to have Map == NULL) |
- */ |
-DECLAREContigPutFunc(putRGBAAcontig16bittile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- uint16 *wp = (uint16 *)pp; |
- (void) y; |
- fromskew *= samplesperpixel; |
- while (h-- > 0) { |
- for (x = w; x-- > 0;) { |
- *cp++ = PACK4(img->Bitdepth16To8[wp[0]], |
- img->Bitdepth16To8[wp[1]], |
- img->Bitdepth16To8[wp[2]], |
- img->Bitdepth16To8[wp[3]]); |
- wp += samplesperpixel; |
- } |
- cp += toskew; |
- wp += fromskew; |
- } |
-} |
- |
-/* |
- * 16-bit packed samples => RGBA w/ unassociated alpha |
- * (known to have Map == NULL) |
- */ |
-DECLAREContigPutFunc(putRGBUAcontig16bittile) |
-{ |
- int samplesperpixel = img->samplesperpixel; |
- uint16 *wp = (uint16 *)pp; |
- (void) y; |
- fromskew *= samplesperpixel; |
- while (h-- > 0) { |
- uint32 r,g,b,a; |
- uint8* m; |
- for (x = w; x-- > 0;) { |
- a = img->Bitdepth16To8[wp[3]]; |
- m = img->UaToAa+(a<<8); |
- r = m[img->Bitdepth16To8[wp[0]]]; |
- g = m[img->Bitdepth16To8[wp[1]]]; |
- b = m[img->Bitdepth16To8[wp[2]]]; |
- *cp++ = PACK4(r,g,b,a); |
- wp += samplesperpixel; |
- } |
- cp += toskew; |
- wp += fromskew; |
- } |
-} |
- |
-/* |
- * 8-bit packed CMYK samples w/o Map => RGB |
- * |
- * NB: The conversion of CMYK->RGB is *very* crude. |
- */ |
-/*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; |
- } |
-} |
- |
-/* |
- * 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\ |
-) |
- |
-/* |
- * 8-bit unpacked samples => RGB |
- */ |
-DECLARESepPutFunc(putRGBseparate8bittile) |
-{ |
- (void) img; (void) x; (void) y; (void) a; |
- while (h-- > 0) { |
- UNROLL8(w, NOP, *cp++ = PACK(*r++, *g++, *b++)); |
- SKEW(r, g, b, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 8-bit unpacked samples => RGBA w/ associated alpha |
- */ |
-DECLARESepPutFunc(putRGBAAseparate8bittile) |
-{ |
- (void) img; (void) x; (void) y; |
- while (h-- > 0) { |
- UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++)); |
- SKEW4(r, g, b, a, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 8-bit unpacked CMYK samples => RGBA |
- */ |
-DECLARESepPutFunc(putCMYKseparate8bittile) |
-{ |
- (void) img; (void) y; |
- while (h-- > 0) { |
- uint32 rv, gv, bv, kv; |
- for (x = w; x-- > 0;) { |
- kv = 255 - *a++; |
- rv = (kv*(255-*r++))/255; |
- gv = (kv*(255-*g++))/255; |
- bv = (kv*(255-*b++))/255; |
- *cp++ = PACK4(rv,gv,bv,255); |
- } |
- SKEW4(r, g, b, a, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 8-bit unpacked samples => RGBA w/ unassociated alpha |
- */ |
-DECLARESepPutFunc(putRGBUAseparate8bittile) |
-{ |
- (void) img; (void) y; |
- while (h-- > 0) { |
- uint32 rv, gv, bv, av; |
- uint8* m; |
- for (x = w; x-- > 0;) { |
- av = *a++; |
- m = img->UaToAa+(av<<8); |
- rv = m[*r++]; |
- gv = m[*g++]; |
- bv = m[*b++]; |
- *cp++ = PACK4(rv,gv,bv,av); |
- } |
- SKEW4(r, g, b, a, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 16-bit unpacked samples => RGB |
- */ |
-DECLARESepPutFunc(putRGBseparate16bittile) |
-{ |
- uint16 *wr = (uint16*) r; |
- uint16 *wg = (uint16*) g; |
- uint16 *wb = (uint16*) b; |
- (void) img; (void) y; (void) a; |
- while (h-- > 0) { |
- for (x = 0; x < w; x++) |
- *cp++ = PACK(img->Bitdepth16To8[*wr++], |
- img->Bitdepth16To8[*wg++], |
- img->Bitdepth16To8[*wb++]); |
- SKEW(wr, wg, wb, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 16-bit unpacked samples => RGBA w/ associated alpha |
- */ |
-DECLARESepPutFunc(putRGBAAseparate16bittile) |
-{ |
- uint16 *wr = (uint16*) r; |
- uint16 *wg = (uint16*) g; |
- uint16 *wb = (uint16*) b; |
- uint16 *wa = (uint16*) a; |
- (void) img; (void) y; |
- while (h-- > 0) { |
- for (x = 0; x < w; x++) |
- *cp++ = PACK4(img->Bitdepth16To8[*wr++], |
- img->Bitdepth16To8[*wg++], |
- img->Bitdepth16To8[*wb++], |
- img->Bitdepth16To8[*wa++]); |
- SKEW4(wr, wg, wb, wa, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 16-bit unpacked samples => RGBA w/ unassociated alpha |
- */ |
-DECLARESepPutFunc(putRGBUAseparate16bittile) |
-{ |
- uint16 *wr = (uint16*) r; |
- uint16 *wg = (uint16*) g; |
- uint16 *wb = (uint16*) b; |
- uint16 *wa = (uint16*) a; |
- (void) img; (void) y; |
- while (h-- > 0) { |
- uint32 r,g,b,a; |
- uint8* m; |
- for (x = w; x-- > 0;) { |
- a = img->Bitdepth16To8[*wa++]; |
- m = img->UaToAa+(a<<8); |
- r = m[img->Bitdepth16To8[*wr++]]; |
- g = m[img->Bitdepth16To8[*wg++]]; |
- b = m[img->Bitdepth16To8[*wb++]]; |
- *cp++ = PACK4(r,g,b,a); |
- } |
- SKEW4(wr, wg, wb, wa, fromskew); |
- cp += toskew; |
- } |
-} |
- |
-/* |
- * 8-bit packed CIE L*a*b 1976 samples => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitCIELab) |
-{ |
- float X, Y, Z; |
- uint32 r, g, b; |
- (void) y; |
- fromskew *= 3; |
- while (h-- > 0) { |
- for (x = w; x-- > 0;) { |
- TIFFCIELabToXYZ(img->cielab, |
- (unsigned char)pp[0], |
- (signed char)pp[1], |
- (signed char)pp[2], |
- &X, &Y, &Z); |
- TIFFXYZToRGB(img->cielab, X, Y, Z, &r, &g, &b); |
- *cp++ = PACK(r, g, b); |
- pp += 3; |
- } |
- cp += toskew; |
- pp += fromskew; |
- } |
-} |
- |
-/* |
- * YCbCr -> RGB conversion and packing routines. |
- */ |
- |
-#define YCbCrtoRGB(dst, Y) { \ |
- uint32 r, g, b; \ |
- TIFFYCbCrtoRGB(img->ycbcr, (Y), Cb, Cr, &r, &g, &b); \ |
- dst = PACK(r, g, b); \ |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples => RGB |
- * This function is generic for different sampling sizes, |
- * and can handle blocks sizes that aren't multiples of the |
- * sampling size. However, it is substantially less optimized |
- * than the specific sampling cases. It is used as a fallback |
- * for difficult blocks. |
- */ |
-#ifdef notdef |
-static void putcontig8bitYCbCrGenericTile( |
- TIFFRGBAImage* img, |
- uint32* cp, |
- uint32 x, uint32 y, |
- uint32 w, uint32 h, |
- int32 fromskew, int32 toskew, |
- unsigned char* pp, |
- int h_group, |
- int v_group ) |
- |
-{ |
- uint32* cp1 = cp+w+toskew; |
- uint32* cp2 = cp1+w+toskew; |
- uint32* cp3 = cp2+w+toskew; |
- int32 incr = 3*w+4*toskew; |
- int32 Cb, Cr; |
- int group_size = v_group * h_group + 2; |
- |
- (void) y; |
- fromskew = (fromskew * group_size) / h_group; |
- |
- for( yy = 0; yy < h; yy++ ) |
- { |
- unsigned char *pp_line; |
- int y_line_group = yy / v_group; |
- int y_remainder = yy - y_line_group * v_group; |
- |
- pp_line = pp + v_line_group * |
- |
- |
- for( xx = 0; xx < w; xx++ ) |
- { |
- Cb = pp |
- } |
- } |
- for (; h >= 4; h -= 4) { |
- x = w>>2; |
- do { |
- Cb = pp[16]; |
- Cr = pp[17]; |
- |
- YCbCrtoRGB(cp [0], pp[ 0]); |
- YCbCrtoRGB(cp [1], pp[ 1]); |
- YCbCrtoRGB(cp [2], pp[ 2]); |
- YCbCrtoRGB(cp [3], pp[ 3]); |
- YCbCrtoRGB(cp1[0], pp[ 4]); |
- YCbCrtoRGB(cp1[1], pp[ 5]); |
- YCbCrtoRGB(cp1[2], pp[ 6]); |
- YCbCrtoRGB(cp1[3], pp[ 7]); |
- YCbCrtoRGB(cp2[0], pp[ 8]); |
- YCbCrtoRGB(cp2[1], pp[ 9]); |
- YCbCrtoRGB(cp2[2], pp[10]); |
- YCbCrtoRGB(cp2[3], pp[11]); |
- YCbCrtoRGB(cp3[0], pp[12]); |
- YCbCrtoRGB(cp3[1], pp[13]); |
- YCbCrtoRGB(cp3[2], pp[14]); |
- YCbCrtoRGB(cp3[3], pp[15]); |
- |
- cp += 4, cp1 += 4, cp2 += 4, cp3 += 4; |
- pp += 18; |
- } while (--x); |
- cp += incr, cp1 += incr, cp2 += incr, cp3 += incr; |
- pp += fromskew; |
- } |
-} |
-#endif |
- |
-/* |
- * 8-bit packed YCbCr samples w/ 4,4 subsampling => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitYCbCr44tile) |
-{ |
- uint32* cp1 = cp+w+toskew; |
- uint32* cp2 = cp1+w+toskew; |
- uint32* cp3 = cp2+w+toskew; |
- int32 incr = 3*w+4*toskew; |
- |
- (void) y; |
- /* adjust fromskew */ |
- fromskew = (fromskew * 18) / 4; |
- if ((h & 3) == 0 && (w & 3) == 0) { |
- for (; h >= 4; h -= 4) { |
- x = w>>2; |
- do { |
- int32 Cb = pp[16]; |
- int32 Cr = pp[17]; |
- |
- YCbCrtoRGB(cp [0], pp[ 0]); |
- YCbCrtoRGB(cp [1], pp[ 1]); |
- YCbCrtoRGB(cp [2], pp[ 2]); |
- YCbCrtoRGB(cp [3], pp[ 3]); |
- YCbCrtoRGB(cp1[0], pp[ 4]); |
- YCbCrtoRGB(cp1[1], pp[ 5]); |
- YCbCrtoRGB(cp1[2], pp[ 6]); |
- YCbCrtoRGB(cp1[3], pp[ 7]); |
- YCbCrtoRGB(cp2[0], pp[ 8]); |
- YCbCrtoRGB(cp2[1], pp[ 9]); |
- YCbCrtoRGB(cp2[2], pp[10]); |
- YCbCrtoRGB(cp2[3], pp[11]); |
- YCbCrtoRGB(cp3[0], pp[12]); |
- YCbCrtoRGB(cp3[1], pp[13]); |
- YCbCrtoRGB(cp3[2], pp[14]); |
- YCbCrtoRGB(cp3[3], pp[15]); |
- |
- cp += 4, cp1 += 4, cp2 += 4, cp3 += 4; |
- pp += 18; |
- } while (--x); |
- cp += incr, cp1 += incr, cp2 += incr, cp3 += incr; |
- pp += fromskew; |
- } |
- } else { |
- while (h > 0) { |
- for (x = w; x > 0;) { |
- int32 Cb = pp[16]; |
- int32 Cr = pp[17]; |
- switch (x) { |
- default: |
- switch (h) { |
- default: YCbCrtoRGB(cp3[3], pp[15]); /* FALLTHROUGH */ |
- case 3: YCbCrtoRGB(cp2[3], pp[11]); /* FALLTHROUGH */ |
- case 2: YCbCrtoRGB(cp1[3], pp[ 7]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [3], pp[ 3]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- case 3: |
- switch (h) { |
- default: YCbCrtoRGB(cp3[2], pp[14]); /* FALLTHROUGH */ |
- case 3: YCbCrtoRGB(cp2[2], pp[10]); /* FALLTHROUGH */ |
- case 2: YCbCrtoRGB(cp1[2], pp[ 6]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [2], pp[ 2]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- case 2: |
- switch (h) { |
- default: YCbCrtoRGB(cp3[1], pp[13]); /* FALLTHROUGH */ |
- case 3: YCbCrtoRGB(cp2[1], pp[ 9]); /* FALLTHROUGH */ |
- case 2: YCbCrtoRGB(cp1[1], pp[ 5]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [1], pp[ 1]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- case 1: |
- switch (h) { |
- default: YCbCrtoRGB(cp3[0], pp[12]); /* FALLTHROUGH */ |
- case 3: YCbCrtoRGB(cp2[0], pp[ 8]); /* FALLTHROUGH */ |
- case 2: YCbCrtoRGB(cp1[0], pp[ 4]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [0], pp[ 0]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- } |
- if (x < 4) { |
- cp += x; cp1 += x; cp2 += x; cp3 += x; |
- x = 0; |
- } |
- else { |
- cp += 4; cp1 += 4; cp2 += 4; cp3 += 4; |
- x -= 4; |
- } |
- pp += 18; |
- } |
- if (h <= 4) |
- break; |
- h -= 4; |
- cp += incr, cp1 += incr, cp2 += incr, cp3 += incr; |
- pp += fromskew; |
- } |
- } |
-} |
- |
-/* |
- * 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) { |
- 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]); |
- YCbCrtoRGB(cp1[0], pp[4]); |
- YCbCrtoRGB(cp1[1], pp[5]); |
- YCbCrtoRGB(cp1[2], pp[6]); |
- YCbCrtoRGB(cp1[3], pp[7]); |
- |
- cp += 4, cp1 += 4; |
- pp += 10; |
- } while (--x); |
- cp += incr, cp1 += incr; |
- pp += fromskew; |
- } |
- } else { |
- while (h > 0) { |
- for (x = w; x > 0;) { |
- int32 Cb = pp[8]; |
- int32 Cr = pp[9]; |
- switch (x) { |
- default: |
- switch (h) { |
- default: YCbCrtoRGB(cp1[3], pp[ 7]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [3], pp[ 3]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- case 3: |
- switch (h) { |
- default: YCbCrtoRGB(cp1[2], pp[ 6]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [2], pp[ 2]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- case 2: |
- switch (h) { |
- default: YCbCrtoRGB(cp1[1], pp[ 5]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [1], pp[ 1]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- case 1: |
- switch (h) { |
- default: YCbCrtoRGB(cp1[0], pp[ 4]); /* FALLTHROUGH */ |
- case 1: YCbCrtoRGB(cp [0], pp[ 0]); /* FALLTHROUGH */ |
- } /* FALLTHROUGH */ |
- } |
- if (x < 4) { |
- cp += x; cp1 += x; |
- x = 0; |
- } |
- else { |
- cp += 4; cp1 += 4; |
- x -= 4; |
- } |
- pp += 10; |
- } |
- if (h <= 2) |
- break; |
- h -= 2; |
- cp += incr, cp1 += incr; |
- pp += fromskew; |
- } |
- } |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples w/ 4,1 subsampling => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitYCbCr41tile) |
-{ |
- (void) y; |
- /* XXX adjust fromskew */ |
- do { |
- x = w>>2; |
- do { |
- 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); |
- |
- 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]); |
- case 0: break; |
- } |
- |
- cp += (w&3); |
- pp += 6; |
- } |
- |
- cp += toskew; |
- pp += fromskew; |
- } while (--h); |
- |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples w/ 2,2 subsampling => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitYCbCr22tile) |
-{ |
- uint32* cp2; |
- int32 incr = 2*toskew+w; |
- (void) y; |
- fromskew = (fromskew / 2) * 6; |
- cp2 = cp+w+toskew; |
- while (h>=2) { |
- x = w; |
- while (x>=2) { |
- uint32 Cb = pp[4]; |
- uint32 Cr = pp[5]; |
- YCbCrtoRGB(cp[0], pp[0]); |
- YCbCrtoRGB(cp[1], pp[1]); |
- YCbCrtoRGB(cp2[0], pp[2]); |
- YCbCrtoRGB(cp2[1], pp[3]); |
- cp += 2; |
- cp2 += 2; |
- pp += 6; |
- x -= 2; |
- } |
- if (x==1) { |
- uint32 Cb = pp[4]; |
- uint32 Cr = pp[5]; |
- YCbCrtoRGB(cp[0], pp[0]); |
- YCbCrtoRGB(cp2[0], pp[2]); |
- cp ++ ; |
- cp2 ++ ; |
- pp += 6; |
- } |
- cp += incr; |
- cp2 += incr; |
- pp += fromskew; |
- h-=2; |
- } |
- if (h==1) { |
- x = w; |
- while (x>=2) { |
- uint32 Cb = pp[4]; |
- uint32 Cr = pp[5]; |
- YCbCrtoRGB(cp[0], pp[0]); |
- YCbCrtoRGB(cp[1], pp[1]); |
- cp += 2; |
- cp2 += 2; |
- pp += 6; |
- x -= 2; |
- } |
- if (x==1) { |
- uint32 Cb = pp[4]; |
- uint32 Cr = pp[5]; |
- YCbCrtoRGB(cp[0], pp[0]); |
- } |
- } |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitYCbCr21tile) |
-{ |
- (void) y; |
- fromskew = (fromskew * 4) / 2; |
- do { |
- x = w>>1; |
- do { |
- int32 Cb = pp[2]; |
- int32 Cr = pp[3]; |
- |
- YCbCrtoRGB(cp[0], pp[0]); |
- YCbCrtoRGB(cp[1], pp[1]); |
- |
- cp += 2; |
- pp += 4; |
- } while (--x); |
- |
- if( (w&1) != 0 ) |
- { |
- int32 Cb = pp[2]; |
- int32 Cr = pp[3]; |
- |
- YCbCrtoRGB(cp[0], pp[0]); |
- |
- cp += 1; |
- pp += 4; |
- } |
- |
- cp += toskew; |
- pp += fromskew; |
- } while (--h); |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples w/ 1,2 subsampling => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitYCbCr12tile) |
-{ |
- uint32* cp2; |
- int32 incr = 2*toskew+w; |
- (void) y; |
- fromskew = (fromskew / 2) * 4; |
- cp2 = cp+w+toskew; |
- while (h>=2) { |
- x = w; |
- do { |
- uint32 Cb = pp[2]; |
- uint32 Cr = pp[3]; |
- YCbCrtoRGB(cp[0], pp[0]); |
- YCbCrtoRGB(cp2[0], pp[1]); |
- cp ++; |
- cp2 ++; |
- pp += 4; |
- } while (--x); |
- cp += incr; |
- cp2 += incr; |
- pp += fromskew; |
- h-=2; |
- } |
- if (h==1) { |
- x = w; |
- do { |
- uint32 Cb = pp[2]; |
- uint32 Cr = pp[3]; |
- YCbCrtoRGB(cp[0], pp[0]); |
- cp ++; |
- pp += 4; |
- } while (--x); |
- } |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples w/ no subsampling => RGB |
- */ |
-DECLAREContigPutFunc(putcontig8bitYCbCr11tile) |
-{ |
- (void) y; |
- fromskew *= 3; |
- do { |
- x = w; /* was x = w>>1; patched 2000/09/25 warmerda@home.com */ |
- do { |
- int32 Cb = pp[1]; |
- int32 Cr = pp[2]; |
- |
- YCbCrtoRGB(*cp++, pp[0]); |
- |
- pp += 3; |
- } while (--x); |
- cp += toskew; |
- pp += fromskew; |
- } while (--h); |
-} |
- |
-/* |
- * 8-bit packed YCbCr samples w/ no subsampling => RGB |
- */ |
-DECLARESepPutFunc(putseparate8bitYCbCr11tile) |
-{ |
- (void) y; |
- (void) a; |
- /* TODO: naming of input vars is still off, change obfuscating declaration inside define, or resolve obfuscation */ |
- while (h-- > 0) { |
- x = w; |
- do { |
- uint32 dr, dg, db; |
- TIFFYCbCrtoRGB(img->ycbcr,*r++,*g++,*b++,&dr,&dg,&db); |
- *cp++ = PACK(dr,dg,db); |
- } while (--x); |
- SKEW(r, g, b, fromskew); |
- cp += toskew; |
- } |
-} |
-#undef YCbCrtoRGB |
- |
-static int |
-initYCbCrConversion(TIFFRGBAImage* img) |
-{ |
- static const char module[] = "initYCbCrConversion"; |
- |
- float *luma, *refBlackWhite; |
- |
- if (img->ycbcr == NULL) { |
- img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc( |
- TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long)) |
- + 4*256*sizeof (TIFFRGBValue) |
- + 2*256*sizeof (int) |
- + 3*256*sizeof (int32) |
- ); |
- if (img->ycbcr == NULL) { |
- TIFFErrorExt(img->tif->tif_clientdata, module, |
- "No space for YCbCr->RGB conversion state"); |
- return (0); |
- } |
- } |
- |
- TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma); |
- TIFFGetFieldDefaulted(img->tif, TIFFTAG_REFERENCEBLACKWHITE, |
- &refBlackWhite); |
- if (TIFFYCbCrToRGBInit(img->ycbcr, luma, refBlackWhite) < 0) |
- return(0); |
- return (1); |
-} |
- |
-static tileContigRoutine |
-initCIELabConversion(TIFFRGBAImage* img) |
-{ |
- static const char module[] = "initCIELabConversion"; |
- |
- float *whitePoint; |
- float refWhite[3]; |
- |
- if (!img->cielab) { |
- img->cielab = (TIFFCIELabToRGB *) |
- _TIFFmalloc(sizeof(TIFFCIELabToRGB)); |
- if (!img->cielab) { |
- TIFFErrorExt(img->tif->tif_clientdata, module, |
- "No space for CIE L*a*b*->RGB conversion state."); |
- return NULL; |
- } |
- } |
- |
- TIFFGetFieldDefaulted(img->tif, TIFFTAG_WHITEPOINT, &whitePoint); |
- refWhite[1] = 100.0F; |
- 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; |
-} |
- |
-/* |
- * 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 |
-makebwmap(TIFFRGBAImage* img) |
-{ |
- TIFFRGBValue* Map = img->Map; |
- int bitspersample = img->bitspersample; |
- int nsamples = 8 / bitspersample; |
- int i; |
- uint32* p; |
- |
- if( nsamples == 0 ) |
- nsamples = 1; |
- |
- img->BWmap = (uint32**) _TIFFmalloc( |
- 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32))); |
- if (img->BWmap == NULL) { |
- TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No space for B&W mapping table"); |
- return (0); |
- } |
- p = (uint32*)(img->BWmap + 256); |
- for (i = 0; i < 256; i++) { |
- TIFFRGBValue c; |
- img->BWmap[i] = p; |
- switch (bitspersample) { |
-#define GREY(x) c = Map[x]; *p++ = PACK(c,c,c); |
- case 1: |
- GREY(i>>7); |
- GREY((i>>6)&1); |
- GREY((i>>5)&1); |
- GREY((i>>4)&1); |
- GREY((i>>3)&1); |
- GREY((i>>2)&1); |
- GREY((i>>1)&1); |
- GREY(i&1); |
- break; |
- case 2: |
- GREY(i>>6); |
- GREY((i>>4)&3); |
- GREY((i>>2)&3); |
- GREY(i&3); |
- break; |
- case 4: |
- GREY(i>>4); |
- GREY(i&0xf); |
- break; |
- case 8: |
- case 16: |
- GREY(i); |
- break; |
- } |
-#undef GREY |
- } |
- return (1); |
-} |
- |
-/* |
- * Construct a mapping table to convert from the range |
- * of the data samples to [0,255] --for display. This |
- * process also handles inverting B&W images when needed. |
- */ |
-static int |
-setupMap(TIFFRGBAImage* img) |
-{ |
- int32 x, range; |
- |
- range = (int32)((1L<<img->bitspersample)-1); |
- |
- /* treat 16 bit the same as eight bit */ |
- if( img->bitspersample == 16 ) |
- range = (int32) 255; |
- |
- img->Map = (TIFFRGBValue*) _TIFFmalloc((range+1) * sizeof (TIFFRGBValue)); |
- if (img->Map == NULL) { |
- TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), |
- "No space for photometric conversion table"); |
- return (0); |
- } |
- if (img->photometric == PHOTOMETRIC_MINISWHITE) { |
- for (x = 0; x <= range; x++) |
- img->Map[x] = (TIFFRGBValue) (((range - x) * 255) / range); |
- } else { |
- for (x = 0; x <= range; x++) |
- img->Map[x] = (TIFFRGBValue) ((x * 255) / range); |
- } |
- if (img->bitspersample <= 16 && |
- (img->photometric == PHOTOMETRIC_MINISBLACK || |
- img->photometric == PHOTOMETRIC_MINISWHITE)) { |
- /* |
- * Use photometric mapping table to construct |
- * unpacking tables for samples <= 8 bits. |
- */ |
- if (!makebwmap(img)) |
- return (0); |
- /* no longer need Map, free it */ |
- _TIFFfree(img->Map), img->Map = NULL; |
- } |
- return (1); |
-} |
- |
-static int |
-checkcmap(TIFFRGBAImage* img) |
-{ |
- uint16* r = img->redcmap; |
- uint16* g = img->greencmap; |
- uint16* b = img->bluecmap; |
- long n = 1L<<img->bitspersample; |
- |
- while (n-- > 0) |
- if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256) |
- return (16); |
- return (8); |
-} |
- |
-static void |
-cvtcmap(TIFFRGBAImage* img) |
-{ |
- uint16* r = img->redcmap; |
- uint16* g = img->greencmap; |
- uint16* b = img->bluecmap; |
- long i; |
- |
- for (i = (1L<<img->bitspersample)-1; i >= 0; i--) { |
-#define CVT(x) ((uint16)((x)>>8)) |
- r[i] = CVT(r[i]); |
- g[i] = CVT(g[i]); |
- b[i] = CVT(b[i]); |
-#undef CVT |
- } |
-} |
- |
-/* |
- * Palette images with <= 8 bits/sample are handled |
- * with a table to avoid lots of shifts and masks. The table |
- * is setup so that put*cmaptile (below) can retrieve 8/bitspersample |
- * pixel values simply by indexing into the table with one |
- * number. |
- */ |
-static int |
-makecmap(TIFFRGBAImage* img) |
-{ |
- int bitspersample = img->bitspersample; |
- int nsamples = 8 / bitspersample; |
- uint16* r = img->redcmap; |
- uint16* g = img->greencmap; |
- uint16* b = img->bluecmap; |
- uint32 *p; |
- int i; |
- |
- img->PALmap = (uint32**) _TIFFmalloc( |
- 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32))); |
- if (img->PALmap == NULL) { |
- TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No space for Palette mapping table"); |
- return (0); |
- } |
- p = (uint32*)(img->PALmap + 256); |
- for (i = 0; i < 256; i++) { |
- TIFFRGBValue c; |
- img->PALmap[i] = p; |
-#define CMAP(x) c = (TIFFRGBValue) x; *p++ = PACK(r[c]&0xff, g[c]&0xff, b[c]&0xff); |
- switch (bitspersample) { |
- case 1: |
- CMAP(i>>7); |
- CMAP((i>>6)&1); |
- CMAP((i>>5)&1); |
- CMAP((i>>4)&1); |
- CMAP((i>>3)&1); |
- CMAP((i>>2)&1); |
- CMAP((i>>1)&1); |
- CMAP(i&1); |
- break; |
- case 2: |
- CMAP(i>>6); |
- CMAP((i>>4)&3); |
- CMAP((i>>2)&3); |
- CMAP(i&3); |
- break; |
- case 4: |
- CMAP(i>>4); |
- CMAP(i&0xf); |
- break; |
- case 8: |
- CMAP(i); |
- break; |
- } |
-#undef CMAP |
- } |
- return (1); |
-} |
- |
-/* |
- * Construct any mapping table used |
- * by the associated put routine. |
- */ |
-static int |
-buildMap(TIFFRGBAImage* img) |
-{ |
- switch (img->photometric) { |
- case PHOTOMETRIC_RGB: |
- case PHOTOMETRIC_YCBCR: |
- case PHOTOMETRIC_SEPARATED: |
- if (img->bitspersample == 8) |
- break; |
- /* fall thru... */ |
- case PHOTOMETRIC_MINISBLACK: |
- case PHOTOMETRIC_MINISWHITE: |
- if (!setupMap(img)) |
- return (0); |
- break; |
- case PHOTOMETRIC_PALETTE: |
- /* |
- * Convert 16-bit colormap to 8-bit (unless it looks |
- * like an old-style 8-bit colormap). |
- */ |
- if (checkcmap(img) == 16) |
- cvtcmap(img); |
- else |
- TIFFWarningExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "Assuming 8-bit colormap"); |
- /* |
- * Use mapping table and colormap to construct |
- * unpacking tables for samples < 8 bits. |
- */ |
- if (img->bitspersample <= 8 && !makecmap(img)) |
- return (0); |
- break; |
- } |
- return (1); |
-} |
- |
-/* |
- * Select the appropriate conversion routine for packed data. |
- */ |
-static int |
-PickContigCase(TIFFRGBAImage* img) |
-{ |
- img->get = TIFFIsTiled(img->tif) ? gtTileContig : gtStripContig; |
- img->put.contig = NULL; |
- switch (img->photometric) { |
- case PHOTOMETRIC_RGB: |
- switch (img->bitspersample) { |
- case 8: |
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA) |
- img->put.contig = putRGBAAcontig8bittile; |
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA) |
- { |
- if (BuildMapUaToAa(img)) |
- img->put.contig = putRGBUAcontig8bittile; |
- } |
- else |
- img->put.contig = putRGBcontig8bittile; |
- break; |
- case 16: |
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA) |
- { |
- if (BuildMapBitdepth16To8(img)) |
- img->put.contig = putRGBAAcontig16bittile; |
- } |
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA) |
- { |
- if (BuildMapBitdepth16To8(img) && |
- BuildMapUaToAa(img)) |
- img->put.contig = putRGBUAcontig16bittile; |
- } |
- else |
- { |
- 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; |
- } |
- 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: |
- 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; |
- break; |
- case 1: |
- img->put.contig = put1bitcmaptile; |
- break; |
- } |
- } |
- break; |
- case PHOTOMETRIC_MINISWHITE: |
- case PHOTOMETRIC_MINISBLACK: |
- if (buildMap(img)) { |
- switch (img->bitspersample) { |
- case 16: |
- img->put.contig = put16bitbwtile; |
- break; |
- case 8: |
- if (img->alpha && img->samplesperpixel == 2) |
- img->put.contig = putagreytile; |
- else |
- img->put.contig = putgreytile; |
- break; |
- case 4: |
- img->put.contig = put4bitbwtile; |
- break; |
- case 2: |
- img->put.contig = put2bitbwtile; |
- break; |
- case 1: |
- img->put.contig = put1bitbwtile; |
- break; |
- } |
- } |
- break; |
- case PHOTOMETRIC_YCBCR: |
- 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 |
- * 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: |
- img->put.contig = putcontig8bitYCbCr42tile; |
- break; |
- case 0x41: |
- img->put.contig = putcontig8bitYCbCr41tile; |
- break; |
- case 0x22: |
- img->put.contig = putcontig8bitYCbCr22tile; |
- break; |
- case 0x21: |
- img->put.contig = putcontig8bitYCbCr21tile; |
- break; |
- case 0x12: |
- img->put.contig = putcontig8bitYCbCr12tile; |
- break; |
- case 0x11: |
- img->put.contig = putcontig8bitYCbCr11tile; |
- break; |
- } |
- } |
- } |
- break; |
- case PHOTOMETRIC_CIELAB: |
- if (buildMap(img)) { |
- if (img->bitspersample == 8) |
- img->put.contig = initCIELabConversion(img); |
- break; |
- } |
- } |
- return ((img->get!=NULL) && (img->put.contig!=NULL)); |
-} |
- |
-/* |
- * Select the appropriate conversion routine for unpacked data. |
- * |
- * NB: we assume that unpacked single channel data is directed |
- * to the "packed routines. |
- */ |
-static int |
-PickSeparateCase(TIFFRGBAImage* img) |
-{ |
- img->get = TIFFIsTiled(img->tif) ? gtTileSeparate : gtStripSeparate; |
- img->put.separate = NULL; |
- switch (img->photometric) { |
- case PHOTOMETRIC_MINISWHITE: |
- case PHOTOMETRIC_MINISBLACK: |
- /* greyscale images processed pretty much as RGB by gtTileSeparate */ |
- case PHOTOMETRIC_RGB: |
- switch (img->bitspersample) { |
- case 8: |
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA) |
- img->put.separate = putRGBAAseparate8bittile; |
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA) |
- { |
- if (BuildMapUaToAa(img)) |
- img->put.separate = putRGBUAseparate8bittile; |
- } |
- else |
- img->put.separate = putRGBseparate8bittile; |
- break; |
- case 16: |
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA) |
- { |
- if (BuildMapBitdepth16To8(img)) |
- img->put.separate = putRGBAAseparate16bittile; |
- } |
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA) |
- { |
- if (BuildMapBitdepth16To8(img) && |
- BuildMapUaToAa(img)) |
- img->put.separate = putRGBUAseparate16bittile; |
- } |
- else |
- { |
- if (BuildMapBitdepth16To8(img)) |
- img->put.separate = putRGBseparate16bittile; |
- } |
- break; |
- } |
- break; |
- case PHOTOMETRIC_SEPARATED: |
- if (img->bitspersample == 8 && img->samplesperpixel == 4) |
- { |
- img->alpha = 1; // Not alpha, but seems like the only way to get 4th band |
- img->put.separate = putCMYKseparate8bittile; |
- } |
- break; |
- case PHOTOMETRIC_YCBCR: |
- if ((img->bitspersample==8) && (img->samplesperpixel==3)) |
- { |
- if (initYCbCrConversion(img)!=0) |
- { |
- uint16 hs, vs; |
- TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs); |
- switch ((hs<<4)|vs) { |
- case 0x11: |
- img->put.separate = putseparate8bitYCbCr11tile; |
- break; |
- /* TODO: add other cases here */ |
- } |
- } |
- } |
- break; |
- } |
- return ((img->get!=NULL) && (img->put.separate!=NULL)); |
-} |
- |
-static int |
-BuildMapUaToAa(TIFFRGBAImage* img) |
-{ |
- static const char module[]="BuildMapUaToAa"; |
- uint8* m; |
- uint16 na,nv; |
- assert(img->UaToAa==NULL); |
- img->UaToAa=_TIFFmalloc(65536); |
- if (img->UaToAa==NULL) |
- { |
- TIFFErrorExt(img->tif->tif_clientdata,module,"Out of memory"); |
- return(0); |
- } |
- m=img->UaToAa; |
- for (na=0; na<256; na++) |
- { |
- for (nv=0; nv<256; nv++) |
- *m++=(nv*na+127)/255; |
- } |
- return(1); |
-} |
- |
-static int |
-BuildMapBitdepth16To8(TIFFRGBAImage* img) |
-{ |
- static const char module[]="BuildMapBitdepth16To8"; |
- uint8* m; |
- uint32 n; |
- assert(img->Bitdepth16To8==NULL); |
- img->Bitdepth16To8=_TIFFmalloc(65536); |
- if (img->Bitdepth16To8==NULL) |
- { |
- TIFFErrorExt(img->tif->tif_clientdata,module,"Out of memory"); |
- return(0); |
- } |
- m=img->Bitdepth16To8; |
- for (n=0; n<65536; n++) |
- *m++=(n+128)/257; |
- return(1); |
-} |
- |
- |
-/* |
- * Read a whole strip off data from the file, and convert to RGBA form. |
- * If this is the last strip, then it will only contain the portion of |
- * the strip that is actually within the image space. The result is |
- * organized in bottom to top form. |
- */ |
- |
- |
-int |
-TIFFReadRGBAStrip(TIFF* tif, uint32 row, uint32 * raster ) |
- |
-{ |
- char emsg[1024] = ""; |
- TIFFRGBAImage img; |
- int ok; |
- uint32 rowsperstrip, rows_to_read; |
- |
- if( TIFFIsTiled( tif ) ) |
- { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), |
- "Can't use TIFFReadRGBAStrip() with tiled file."); |
- return (0); |
- } |
- |
- TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); |
- if( (row % rowsperstrip) != 0 ) |
- { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), |
- "Row passed to TIFFReadRGBAStrip() must be first in a strip."); |
- return (0); |
- } |
- |
- if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, 0, emsg)) { |
- |
- img.row_offset = row; |
- img.col_offset = 0; |
- |
- if( row + rowsperstrip > img.height ) |
- rows_to_read = img.height - row; |
- else |
- rows_to_read = rowsperstrip; |
- |
- ok = TIFFRGBAImageGet(&img, raster, img.width, rows_to_read ); |
- |
- TIFFRGBAImageEnd(&img); |
- } else { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg); |
- ok = 0; |
- } |
- |
- return (ok); |
-} |
- |
-/* |
- * Read a whole tile off data from the file, and convert to RGBA form. |
- * The returned RGBA data is organized from bottom to top of tile, |
- * and may include zeroed areas if the tile extends off the image. |
- */ |
- |
-int |
-TIFFReadRGBATile(TIFF* tif, uint32 col, uint32 row, uint32 * raster) |
- |
-{ |
- char emsg[1024] = ""; |
- TIFFRGBAImage img; |
- int ok; |
- uint32 tile_xsize, tile_ysize; |
- uint32 read_xsize, read_ysize; |
- uint32 i_row; |
- |
- /* |
- * Verify that our request is legal - on a tile file, and on a |
- * tile boundary. |
- */ |
- |
- if( !TIFFIsTiled( tif ) ) |
- { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), |
- "Can't use TIFFReadRGBATile() with stripped file."); |
- return (0); |
- } |
- |
- TIFFGetFieldDefaulted(tif, TIFFTAG_TILEWIDTH, &tile_xsize); |
- TIFFGetFieldDefaulted(tif, TIFFTAG_TILELENGTH, &tile_ysize); |
- if( (col % tile_xsize) != 0 || (row % tile_ysize) != 0 ) |
- { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), |
- "Row/col passed to TIFFReadRGBATile() must be top" |
- "left corner of a tile."); |
- return (0); |
- } |
- |
- /* |
- * Setup the RGBA reader. |
- */ |
- |
- if (!TIFFRGBAImageOK(tif, emsg) |
- || !TIFFRGBAImageBegin(&img, tif, 0, emsg)) { |
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg); |
- return( 0 ); |
- } |
- |
- /* |
- * The TIFFRGBAImageGet() function doesn't allow us to get off the |
- * edge of the image, even to fill an otherwise valid tile. So we |
- * figure out how much we can read, and fix up the tile buffer to |
- * a full tile configuration afterwards. |
- */ |
- |
- if( row + tile_ysize > img.height ) |
- read_ysize = img.height - row; |
- else |
- read_ysize = tile_ysize; |
- |
- if( col + tile_xsize > img.width ) |
- read_xsize = img.width - col; |
- else |
- read_xsize = tile_xsize; |
- |
- /* |
- * Read the chunk of imagery. |
- */ |
- |
- img.row_offset = row; |
- img.col_offset = col; |
- |
- ok = TIFFRGBAImageGet(&img, raster, read_xsize, read_ysize ); |
- |
- TIFFRGBAImageEnd(&img); |
- |
- /* |
- * If our read was incomplete we will need to fix up the tile by |
- * shifting the data around as if a full tile of data is being returned. |
- * |
- * This is all the more complicated because the image is organized in |
- * bottom to top format. |
- */ |
- |
- if( read_xsize == tile_xsize && read_ysize == tile_ysize ) |
- return( ok ); |
- |
- for( i_row = 0; i_row < read_ysize; i_row++ ) { |
- memmove( raster + (tile_ysize - i_row - 1) * tile_xsize, |
- raster + (read_ysize - i_row - 1) * read_xsize, |
- read_xsize * sizeof(uint32) ); |
- _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize+read_xsize, |
- 0, sizeof(uint32) * (tile_xsize - read_xsize) ); |
- } |
- |
- for( i_row = read_ysize; i_row < tile_ysize; i_row++ ) { |
- _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize, |
- 0, sizeof(uint32) * tile_xsize ); |
- } |
- |
- return (ok); |
-} |
- |
-/* vim: set ts=8 sts=8 sw=8 noet: */ |
-/* |
- * Local Variables: |
- * mode: c |
- * c-basic-offset: 8 |
- * fill-column: 78 |
- * End: |
- */ |
- |