| /* |
| * 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 <limits.h> |
| #include <stdio.h> |
| |
| static int gtTileContig(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t); |
| static int gtTileSeparate(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t); |
| static int gtStripContig(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t); |
| static int gtStripSeparate(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t); |
| 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 |
| |
| #define EMSG_BUF_SIZE 1024 |
| |
| /* |
| * 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[EMSG_BUF_SIZE]) |
| { |
| TIFFDirectory *td = &tif->tif_dir; |
| uint16_t photometric; |
| int colorchannels; |
| |
| if (!tif->tif_decodestatus) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "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: |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle images with %" PRIu16 |
| "-bit samples", |
| td->td_bitspersample); |
| return (0); |
| } |
| if (td->td_sampleformat == SAMPLEFORMAT_IEEEFP) |
| { |
| snprintf( |
| emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle images with IEEE floating-point samples"); |
| 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: |
| snprintf(emsg, EMSG_BUF_SIZE, "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) |
| { |
| snprintf( |
| emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle contiguous data with %s=%" PRIu16 |
| ", " |
| "and %s=%" PRIu16 " and Bits/Sample=%" PRIu16 "", |
| 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 meaningful |
| * error to return |
| */ |
| break; |
| case PHOTOMETRIC_RGB: |
| if (colorchannels < 3) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle RGB image with %s=%d", |
| "Color channels", colorchannels); |
| return (0); |
| } |
| break; |
| case PHOTOMETRIC_SEPARATED: |
| { |
| uint16_t inkset; |
| TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset); |
| if (inkset != INKSET_CMYK) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle separated image with %s=%d", |
| "InkSet", inkset); |
| return 0; |
| } |
| if (td->td_samplesperpixel < 4) |
| { |
| snprintf( |
| emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle separated image with %s=%" PRIu16, |
| "Samples/pixel", td->td_samplesperpixel); |
| return 0; |
| } |
| break; |
| } |
| case PHOTOMETRIC_LOGL: |
| if (td->td_compression != COMPRESSION_SGILOG) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "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) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, LogLuv data must have %s=%d or %d", |
| "Compression", COMPRESSION_SGILOG, |
| COMPRESSION_SGILOG24); |
| return (0); |
| } |
| if (td->td_planarconfig != PLANARCONFIG_CONTIG) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle LogLuv images with %s=%" PRIu16, |
| "Planarconfiguration", td->td_planarconfig); |
| return (0); |
| } |
| if (td->td_samplesperpixel != 3 || colorchannels != 3) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle image with %s=%" PRIu16 |
| ", %s=%d", |
| "Samples/pixel", td->td_samplesperpixel, |
| "colorchannels", colorchannels); |
| return 0; |
| } |
| break; |
| case PHOTOMETRIC_CIELAB: |
| if (td->td_samplesperpixel != 3 || colorchannels != 3 || |
| (td->td_bitspersample != 8 && td->td_bitspersample != 16)) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle image with %s=%" PRIu16 |
| ", %s=%d and %s=%" PRIu16, |
| "Samples/pixel", td->td_samplesperpixel, |
| "colorchannels", colorchannels, "Bits/sample", |
| td->td_bitspersample); |
| return 0; |
| } |
| break; |
| default: |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle image with %s=%" PRIu16, photoTag, |
| photometric); |
| return (0); |
| } |
| return (1); |
| } |
| |
| void TIFFRGBAImageEnd(TIFFRGBAImage *img) |
| { |
| if (img->Map) |
| { |
| _TIFFfreeExt(img->tif, img->Map); |
| img->Map = NULL; |
| } |
| if (img->BWmap) |
| { |
| _TIFFfreeExt(img->tif, img->BWmap); |
| img->BWmap = NULL; |
| } |
| if (img->PALmap) |
| { |
| _TIFFfreeExt(img->tif, img->PALmap); |
| img->PALmap = NULL; |
| } |
| if (img->ycbcr) |
| { |
| _TIFFfreeExt(img->tif, img->ycbcr); |
| img->ycbcr = NULL; |
| } |
| if (img->cielab) |
| { |
| _TIFFfreeExt(img->tif, img->cielab); |
| img->cielab = NULL; |
| } |
| if (img->UaToAa) |
| { |
| _TIFFfreeExt(img->tif, img->UaToAa); |
| img->UaToAa = NULL; |
| } |
| if (img->Bitdepth16To8) |
| { |
| _TIFFfreeExt(img->tif, img->Bitdepth16To8); |
| img->Bitdepth16To8 = NULL; |
| } |
| |
| if (img->redcmap) |
| { |
| _TIFFfreeExt(img->tif, img->redcmap); |
| _TIFFfreeExt(img->tif, img->greencmap); |
| _TIFFfreeExt(img->tif, img->bluecmap); |
| img->redcmap = img->greencmap = img->bluecmap = NULL; |
| } |
| } |
| |
| static int isCCITTCompression(TIFF *tif) |
| { |
| uint16_t 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[EMSG_BUF_SIZE]) |
| { |
| uint16_t *sampleinfo; |
| uint16_t extrasamples; |
| uint16_t planarconfig; |
| uint16_t compress; |
| int colorchannels; |
| uint16_t *red_orig, *green_orig, *blue_orig; |
| int n_color; |
| |
| if (!TIFFRGBAImageOK(tif, emsg)) |
| return 0; |
| |
| /* Initialize to normal values */ |
| img->row_offset = 0; |
| img->col_offset = 0; |
| img->redcmap = NULL; |
| img->greencmap = NULL; |
| img->bluecmap = NULL; |
| img->Map = NULL; |
| img->BWmap = NULL; |
| img->PALmap = NULL; |
| img->ycbcr = NULL; |
| img->cielab = NULL; |
| img->UaToAa = NULL; |
| img->Bitdepth16To8 = 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: |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle images with %" PRIu16 |
| "-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: |
| snprintf(emsg, EMSG_BUF_SIZE, "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)) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Missing required \"Colormap\" tag"); |
| goto fail_return; |
| } |
| |
| /* copy the colormaps so we can modify them */ |
| n_color = (1U << img->bitspersample); |
| img->redcmap = |
| (uint16_t *)_TIFFmallocExt(tif, sizeof(uint16_t) * n_color); |
| img->greencmap = |
| (uint16_t *)_TIFFmallocExt(tif, sizeof(uint16_t) * n_color); |
| img->bluecmap = |
| (uint16_t *)_TIFFmallocExt(tif, sizeof(uint16_t) * n_color); |
| if (!img->redcmap || !img->greencmap || !img->bluecmap) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "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 through... */ |
| case PHOTOMETRIC_MINISWHITE: |
| case PHOTOMETRIC_MINISBLACK: |
| if (planarconfig == PLANARCONFIG_CONTIG && |
| img->samplesperpixel != 1 && img->bitspersample < 8) |
| { |
| snprintf( |
| emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle contiguous data with %s=%" PRIu16 |
| ", " |
| "and %s=%" PRIu16 " and Bits/Sample=%" PRIu16, |
| 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 meaningful |
| * error to return |
| */ |
| break; |
| case PHOTOMETRIC_RGB: |
| if (colorchannels < 3) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle RGB image with %s=%d", |
| "Color channels", colorchannels); |
| goto fail_return; |
| } |
| break; |
| case PHOTOMETRIC_SEPARATED: |
| { |
| uint16_t inkset; |
| TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset); |
| if (inkset != INKSET_CMYK) |
| { |
| snprintf( |
| emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle separated image with %s=%" PRIu16, |
| "InkSet", inkset); |
| goto fail_return; |
| } |
| if (img->samplesperpixel < 4) |
| { |
| snprintf( |
| emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle separated image with %s=%" PRIu16, |
| "Samples/pixel", img->samplesperpixel); |
| goto fail_return; |
| } |
| } |
| break; |
| case PHOTOMETRIC_LOGL: |
| if (compress != COMPRESSION_SGILOG) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "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) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, LogLuv data must have %s=%d or %d", |
| "Compression", COMPRESSION_SGILOG, |
| COMPRESSION_SGILOG24); |
| goto fail_return; |
| } |
| if (planarconfig != PLANARCONFIG_CONTIG) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle LogLuv images with %s=%" PRIu16, |
| "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: |
| snprintf(emsg, EMSG_BUF_SIZE, |
| "Sorry, can not handle image with %s=%" PRIu16, photoTag, |
| img->photometric); |
| goto fail_return; |
| } |
| 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)) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, "Sorry, can not handle image"); |
| goto fail_return; |
| } |
| } |
| else |
| { |
| if (!PickSeparateCase(img)) |
| { |
| snprintf(emsg, EMSG_BUF_SIZE, "Sorry, can not handle image"); |
| goto fail_return; |
| } |
| } |
| return 1; |
| |
| fail_return: |
| TIFFRGBAImageEnd(img); |
| return 0; |
| } |
| |
| int TIFFRGBAImageGet(TIFFRGBAImage *img, uint32_t *raster, uint32_t w, |
| uint32_t h) |
| { |
| if (img->get == NULL) |
| { |
| TIFFErrorExtR(img->tif, TIFFFileName(img->tif), |
| "No \"get\" routine setup"); |
| return (0); |
| } |
| if (img->put.any == NULL) |
| { |
| TIFFErrorExtR( |
| img->tif, 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_t rwidth, uint32_t rheight, |
| uint32_t *raster, int orientation, int stop) |
| { |
| char emsg[EMSG_BUF_SIZE] = ""; |
| TIFFRGBAImage img; |
| int ok; |
| |
| if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, stop, emsg)) |
| { |
| img.req_orientation = (uint16_t)orientation; |
| /* XXX verify rwidth and rheight against width and height */ |
| ok = TIFFRGBAImageGet(&img, raster + (rheight - img.height) * rwidth, |
| rwidth, img.height); |
| TIFFRGBAImageEnd(&img); |
| } |
| else |
| { |
| TIFFErrorExtR(tif, 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_t rwidth, uint32_t rheight, |
| uint32_t *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_t *raster, uint32_t w, |
| uint32_t h) |
| { |
| TIFF *tif = img->tif; |
| tileContigRoutine put = img->put.contig; |
| uint32_t col, row, y, rowstoread; |
| tmsize_t pos; |
| uint32_t tw, th; |
| unsigned char *buf = NULL; |
| int32_t fromskew, toskew; |
| uint32_t nrow; |
| int ret = 1, flip; |
| uint32_t this_tw, tocol; |
| int32_t this_toskew, leftmost_toskew; |
| int32_t leftmost_fromskew; |
| int64_t safeskew; |
| uint32_t leftmost_tw; |
| tmsize_t bufsize; |
| |
| bufsize = TIFFTileSize(tif); |
| if (bufsize == 0) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "%s", "No space for tile buffer"); |
| return (0); |
| } |
| |
| TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw); |
| TIFFGetField(tif, TIFFTAG_TILELENGTH, &th); |
| |
| flip = setorientation(img); |
| if (flip & FLIP_VERTICALLY) |
| { |
| if ((tw + w) > INT_MAX) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "%s", |
| "unsupported tile size (too wide)"); |
| return (0); |
| } |
| y = h - 1; |
| toskew = -(int32_t)(tw + w); |
| } |
| else |
| { |
| if (tw > (INT_MAX + w)) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "%s", |
| "unsupported tile size (too wide)"); |
| return (0); |
| } |
| y = 0; |
| toskew = -(int32_t)(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; ret != 0 && row < h; row += nrow) |
| { |
| rowstoread = th - (row + img->row_offset) % th; |
| nrow = (row + rowstoread > h ? h - row : rowstoread); |
| fromskew = leftmost_fromskew; |
| this_tw = leftmost_tw; |
| this_toskew = leftmost_toskew; |
| tocol = 0; |
| col = img->col_offset; |
| while (tocol < w) |
| { |
| if (_TIFFReadTileAndAllocBuffer(tif, (void **)&buf, bufsize, col, |
| row + img->row_offset, 0, |
| 0) == (tmsize_t)(-1) && |
| (buf == NULL || img->stoponerr)) |
| { |
| ret = 0; |
| break; |
| } |
| 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. |
| */ |
| safeskew = tw; |
| safeskew -= w; |
| safeskew += tocol; |
| if (safeskew > INT_MAX || safeskew < INT_MIN) |
| { |
| _TIFFfree(buf); |
| TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", |
| "Invalid skew"); |
| return (0); |
| } |
| fromskew = safeskew; |
| this_tw = tw - fromskew; |
| safeskew = toskew; |
| safeskew += fromskew; |
| if (safeskew > INT_MAX || safeskew < INT_MIN) |
| { |
| _TIFFfree(buf); |
| TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", |
| "Invalid skew"); |
| return (0); |
| } |
| this_toskew = safeskew; |
| } |
| tmsize_t roffset = (tmsize_t)y * w + tocol; |
| (*put)(img, raster + roffset, 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_t)nrow : (int32_t)nrow); |
| } |
| _TIFFfreeExt(img->tif, buf); |
| |
| if (flip & FLIP_HORIZONTALLY) |
| { |
| uint32_t line; |
| |
| for (line = 0; line < h; line++) |
| { |
| uint32_t *left = raster + (line * w); |
| uint32_t *right = left + w - 1; |
| |
| while (left < right) |
| { |
| uint32_t 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_t *raster, uint32_t w, |
| uint32_t h) |
| { |
| TIFF *tif = img->tif; |
| tileSeparateRoutine put = img->put.separate; |
| uint32_t col, row, y, rowstoread; |
| tmsize_t pos; |
| uint32_t tw, th; |
| unsigned char *buf = NULL; |
| unsigned char *p0 = NULL; |
| unsigned char *p1 = NULL; |
| unsigned char *p2 = NULL; |
| unsigned char *pa = NULL; |
| tmsize_t tilesize; |
| tmsize_t bufsize; |
| int32_t fromskew, toskew; |
| int alpha = img->alpha; |
| uint32_t nrow; |
| int ret = 1, flip; |
| uint16_t colorchannels; |
| uint32_t this_tw, tocol; |
| int32_t this_toskew, leftmost_toskew; |
| int32_t leftmost_fromskew; |
| uint32_t leftmost_tw; |
| |
| tilesize = TIFFTileSize(tif); |
| bufsize = |
| _TIFFMultiplySSize(tif, alpha ? 4 : 3, tilesize, "gtTileSeparate"); |
| if (bufsize == 0) |
| { |
| return (0); |
| } |
| |
| TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw); |
| TIFFGetField(tif, TIFFTAG_TILELENGTH, &th); |
| |
| flip = setorientation(img); |
| if (flip & FLIP_VERTICALLY) |
| { |
| if ((tw + w) > INT_MAX) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "%s", |
| "unsupported tile size (too wide)"); |
| return (0); |
| } |
| y = h - 1; |
| toskew = -(int32_t)(tw + w); |
| } |
| else |
| { |
| if (tw > (INT_MAX + w)) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "%s", |
| "unsupported tile size (too wide)"); |
| return (0); |
| } |
| y = 0; |
| toskew = -(int32_t)(tw - w); |
| } |
| |
| switch (img->photometric) |
| { |
| case PHOTOMETRIC_MINISWHITE: |
| case PHOTOMETRIC_MINISBLACK: |
| case PHOTOMETRIC_PALETTE: |
| colorchannels = 1; |
| 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; ret != 0 && row < h; row += nrow) |
| { |
| rowstoread = th - (row + img->row_offset) % th; |
| nrow = (row + rowstoread > h ? h - row : rowstoread); |
| fromskew = leftmost_fromskew; |
| this_tw = leftmost_tw; |
| this_toskew = leftmost_toskew; |
| tocol = 0; |
| col = img->col_offset; |
| while (tocol < w) |
| { |
| if (buf == NULL) |
| { |
| if (_TIFFReadTileAndAllocBuffer(tif, (void **)&buf, bufsize, |
| col, row + img->row_offset, 0, |
| 0) == (tmsize_t)(-1) && |
| (buf == NULL || img->stoponerr)) |
| { |
| ret = 0; |
| break; |
| } |
| p0 = buf; |
| if (colorchannels == 1) |
| { |
| p2 = p1 = p0; |
| pa = (alpha ? (p0 + 3 * tilesize) : NULL); |
| } |
| else |
| { |
| p1 = p0 + tilesize; |
| p2 = p1 + tilesize; |
| pa = (alpha ? (p2 + tilesize) : NULL); |
| } |
| } |
| else 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, row + img->row_offset, 0, 1) == |
| (tmsize_t)(-1) && |
| img->stoponerr) |
| { |
| ret = 0; |
| break; |
| } |
| if (colorchannels > 1 && |
| TIFFReadTile(tif, p2, col, row + img->row_offset, 0, 2) == |
| (tmsize_t)(-1) && |
| img->stoponerr) |
| { |
| ret = 0; |
| break; |
| } |
| if (alpha && |
| 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) + |
| ((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; |
| } |
| tmsize_t roffset = (tmsize_t)y * w + tocol; |
| (*put)(img, raster + roffset, 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_t)nrow : (int32_t)nrow); |
| } |
| |
| if (flip & FLIP_HORIZONTALLY) |
| { |
| uint32_t line; |
| |
| for (line = 0; line < h; line++) |
| { |
| uint32_t *left = raster + (line * w); |
| uint32_t *right = left + w - 1; |
| |
| while (left < right) |
| { |
| uint32_t temp = *left; |
| *left = *right; |
| *right = temp; |
| left++; |
| right--; |
| } |
| } |
| } |
| |
| _TIFFfreeExt(img->tif, buf); |
| return (ret); |
| } |
| |
| /* |
| * Get a strip-organized image that has |
| * PlanarConfiguration contiguous if SamplesPerPixel > 1 |
| * or |
| * SamplesPerPixel == 1 |
| */ |
| static int gtStripContig(TIFFRGBAImage *img, uint32_t *raster, uint32_t w, |
| uint32_t h) |
| { |
| TIFF *tif = img->tif; |
| tileContigRoutine put = img->put.contig; |
| uint32_t row, y, nrow, nrowsub, rowstoread; |
| tmsize_t pos; |
| unsigned char *buf = NULL; |
| uint32_t rowsperstrip; |
| uint16_t subsamplinghor, subsamplingver; |
| uint32_t imagewidth = img->width; |
| tmsize_t scanline; |
| int32_t fromskew, toskew; |
| int ret = 1, flip; |
| tmsize_t maxstripsize; |
| |
| if ((tmsize_t)img->row_offset > TIFF_SSIZE_T_MAX || |
| (size_t)h > (size_t)TIFF_SSIZE_T_MAX) |
| { |
| return (0); |
| } |
| |
| TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, |
| &subsamplingver); |
| if (subsamplingver == 0) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), |
| "Invalid vertical YCbCr subsampling"); |
| return (0); |
| } |
| |
| maxstripsize = TIFFStripSize(tif); |
| |
| flip = setorientation(img); |
| if (flip & FLIP_VERTICALLY) |
| { |
| if (w > INT_MAX) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "Width overflow"); |
| return (0); |
| } |
| y = h - 1; |
| toskew = -(int32_t)(w + w); |
| } |
| else |
| { |
| y = 0; |
| toskew = -(int32_t)(w - w); |
| } |
| |
| TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); |
| |
| scanline = TIFFScanlineSize(tif); |
| fromskew = (w < imagewidth ? imagewidth - w : 0); |
| for (row = 0; row < h; row += nrow) |
| { |
| uint32_t temp; |
| rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip; |
| nrow = (row + rowstoread > h ? h - row : rowstoread); |
| nrowsub = nrow; |
| if ((nrowsub % subsamplingver) != 0) |
| nrowsub += subsamplingver - nrowsub % subsamplingver; |
| temp = (row + img->row_offset) % rowsperstrip + nrowsub; |
| if (scanline > 0 && temp > (size_t)(TIFF_TMSIZE_T_MAX / scanline)) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), |
| "Integer overflow in gtStripContig"); |
| return 0; |
| } |
| if (_TIFFReadEncodedStripAndAllocBuffer( |
| tif, TIFFComputeStrip(tif, row + img->row_offset, 0), |
| (void **)(&buf), maxstripsize, |
| temp * scanline) == (tmsize_t)(-1) && |
| (buf == NULL || img->stoponerr)) |
| { |
| ret = 0; |
| break; |
| } |
| |
| pos = ((row + img->row_offset) % rowsperstrip) * scanline + |
| ((tmsize_t)img->col_offset * img->samplesperpixel); |
| tmsize_t roffset = (tmsize_t)y * w; |
| (*put)(img, raster + roffset, 0, y, w, nrow, fromskew, toskew, |
| buf + pos); |
| y += ((flip & FLIP_VERTICALLY) ? -(int32_t)nrow : (int32_t)nrow); |
| } |
| |
| if (flip & FLIP_HORIZONTALLY) |
| { |
| uint32_t line; |
| |
| for (line = 0; line < h; line++) |
| { |
| uint32_t *left = raster + (line * w); |
| uint32_t *right = left + w - 1; |
| |
| while (left < right) |
| { |
| uint32_t temp = *left; |
| *left = *right; |
| *right = temp; |
| left++; |
| right--; |
| } |
| } |
| } |
| |
| _TIFFfreeExt(img->tif, 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_t *raster, uint32_t w, |
| uint32_t h) |
| { |
| TIFF *tif = img->tif; |
| tileSeparateRoutine put = img->put.separate; |
| unsigned char *buf = NULL; |
| unsigned char *p0 = NULL, *p1 = NULL, *p2 = NULL, *pa = NULL; |
| uint32_t row, y, nrow, rowstoread; |
| tmsize_t pos; |
| tmsize_t scanline; |
| uint32_t rowsperstrip, offset_row; |
| uint32_t imagewidth = img->width; |
| tmsize_t stripsize; |
| tmsize_t bufsize; |
| int32_t fromskew, toskew; |
| int alpha = img->alpha; |
| int ret = 1, flip; |
| uint16_t colorchannels; |
| |
| stripsize = TIFFStripSize(tif); |
| bufsize = |
| _TIFFMultiplySSize(tif, alpha ? 4 : 3, stripsize, "gtStripSeparate"); |
| if (bufsize == 0) |
| { |
| return (0); |
| } |
| |
| flip = setorientation(img); |
| if (flip & FLIP_VERTICALLY) |
| { |
| if (w > INT_MAX) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), "Width overflow"); |
| return (0); |
| } |
| y = h - 1; |
| toskew = -(int32_t)(w + w); |
| } |
| else |
| { |
| y = 0; |
| toskew = -(int32_t)(w - w); |
| } |
| |
| switch (img->photometric) |
| { |
| case PHOTOMETRIC_MINISWHITE: |
| case PHOTOMETRIC_MINISBLACK: |
| case PHOTOMETRIC_PALETTE: |
| colorchannels = 1; |
| 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) |
| { |
| uint32_t temp; |
| rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip; |
| nrow = (row + rowstoread > h ? h - row : rowstoread); |
| offset_row = row + img->row_offset; |
| temp = (row + img->row_offset) % rowsperstrip + nrow; |
| if (scanline > 0 && temp > (size_t)(TIFF_TMSIZE_T_MAX / scanline)) |
| { |
| TIFFErrorExtR(tif, TIFFFileName(tif), |
| "Integer overflow in gtStripSeparate"); |
| return 0; |
| } |
| if (buf == NULL) |
| { |
| if (_TIFFReadEncodedStripAndAllocBuffer( |
| tif, TIFFComputeStrip(tif, offset_row, 0), (void **)&buf, |
| bufsize, temp * scanline) == (tmsize_t)(-1) && |
| (buf == NULL || img->stoponerr)) |
| { |
| ret = 0; |
| break; |
| } |
| p0 = buf; |
| if (colorchannels == 1) |
| { |
| p2 = p1 = p0; |
| pa = (alpha ? (p0 + 3 * stripsize) : NULL); |
| } |
| else |
| { |
| p1 = p0 + stripsize; |
| p2 = p1 + stripsize; |
| pa = (alpha ? (p2 + stripsize) : NULL); |
| } |
| } |
| else if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0), |
| p0, temp * scanline) == (tmsize_t)(-1) && |
| img->stoponerr) |
| { |
| ret = 0; |
| break; |
| } |
| if (colorchannels > 1 && |
| TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), p1, |
| temp * scanline) == (tmsize_t)(-1) && |
| img->stoponerr) |
| { |
| ret = 0; |
| break; |
| } |
| if (colorchannels > 1 && |
| TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), p2, |
| temp * scanline) == (tmsize_t)(-1) && |
| img->stoponerr) |
| { |
| ret = 0; |
| break; |
| } |
| if (alpha) |
| { |
| if (TIFFReadEncodedStrip( |
| tif, TIFFComputeStrip(tif, offset_row, colorchannels), pa, |
| temp * scanline) == (tmsize_t)(-1) && |
| img->stoponerr) |
| { |
| ret = 0; |
| break; |
| } |
| } |
| |
| pos = ((row + img->row_offset) % rowsperstrip) * scanline + |
| ((tmsize_t)img->col_offset * img->samplesperpixel); |
| tmsize_t roffset = (tmsize_t)y * w; |
| (*put)(img, raster + roffset, 0, y, w, nrow, fromskew, toskew, p0 + pos, |
| p1 + pos, p2 + pos, (alpha ? (pa + pos) : NULL)); |
| y += ((flip & FLIP_VERTICALLY) ? -(int32_t)nrow : (int32_t)nrow); |
| } |
| |
| if (flip & FLIP_HORIZONTALLY) |
| { |
| uint32_t line; |
| |
| for (line = 0; line < h; line++) |
| { |
| uint32_t *left = raster + (line * w); |
| uint32_t *right = left + w - 1; |
| |
| while (left < right) |
| { |
| uint32_t temp = *left; |
| *left = *right; |
| *right = temp; |
| left++; |
| right--; |
| } |
| } |
| } |
| |
| _TIFFfreeExt(img->tif, 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; /*-fallthrough*/ \ |
| case 6: \ |
| op; /*-fallthrough*/ \ |
| case 5: \ |
| op; /*-fallthrough*/ \ |
| case 4: \ |
| op; /*-fallthrough*/ \ |
| case 3: \ |
| op; /*-fallthrough*/ \ |
| case 2: \ |
| op; /*-fallthrough*/ \ |
| case 1: \ |
| op; \ |
| } |
| #define CASE4(x, op) \ |
| switch (x) \ |
| { \ |
| case 3: \ |
| op; /*-fallthrough*/ \ |
| case 2: \ |
| op; /*-fallthrough*/ \ |
| case 1: \ |
| op; \ |
| } |
| #define NOP |
| |
| #define UNROLL8(w, op1, op2) \ |
| { \ |
| uint32_t _x; \ |
| for (_x = w; _x >= 8; _x -= 8) \ |
| { \ |
| op1; \ |
| REPEAT8(op2); \ |
| } \ |
| if (_x > 0) \ |
| { \ |
| op1; \ |
| CASE8(_x, op2); \ |
| } \ |
| } |
| #define UNROLL4(w, op1, op2) \ |
| { \ |
| uint32_t _x; \ |
| for (_x = w; _x >= 4; _x -= 4) \ |
| { \ |
| op1; \ |
| REPEAT4(op2); \ |
| } \ |
| if (_x > 0) \ |
| { \ |
| op1; \ |
| CASE4(_x, op2); \ |
| } \ |
| } |
| #define UNROLL2(w, op1, op2) \ |
| { \ |
| uint32_t _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_t)0xffL) << 24) |
| #define PACK(r, g, b) \ |
| ((uint32_t)(r) | ((uint32_t)(g) << 8) | ((uint32_t)(b) << 16) | A1) |
| #define PACK4(r, g, b, a) \ |
| ((uint32_t)(r) | ((uint32_t)(g) << 8) | ((uint32_t)(b) << 16) | \ |
| ((uint32_t)(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_t)W2B(r) | ((uint32_t)W2B(g) << 8) | ((uint32_t)W2B(b) << 16) | A1) |
| #define PACKW4(r, g, b, a) \ |
| ((uint32_t)W2B(r) | ((uint32_t)W2B(g) << 8) | ((uint32_t)W2B(b) << 16) | \ |
| ((uint32_t)W2B(a) << 24)) |
| |
| #define DECLAREContigPutFunc(name) \ |
| static void name(TIFFRGBAImage *img, uint32_t *cp, uint32_t x, uint32_t y, \ |
| uint32_t w, uint32_t h, int32_t fromskew, int32_t toskew, \ |
| unsigned char *pp) |
| |
| /* |
| * 8-bit palette => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put8bitcmaptile) |
| { |
| uint32_t **PALmap = img->PALmap; |
| int samplesperpixel = img->samplesperpixel; |
| |
| (void)y; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| *cp++ = PALmap[*pp][0]; |
| pp += samplesperpixel; |
| } |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 4-bit palette => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put4bitcmaptile) |
| { |
| uint32_t **PALmap = img->PALmap; |
| |
| (void)x; |
| (void)y; |
| fromskew /= 2; |
| for (; h > 0; --h) |
| { |
| uint32_t *bw; |
| UNROLL2(w, bw = PALmap[*pp++], *cp++ = *bw++); |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 2-bit palette => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put2bitcmaptile) |
| { |
| uint32_t **PALmap = img->PALmap; |
| |
| (void)x; |
| (void)y; |
| fromskew /= 4; |
| for (; h > 0; --h) |
| { |
| uint32_t *bw; |
| UNROLL4(w, bw = PALmap[*pp++], *cp++ = *bw++); |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 1-bit palette => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put1bitcmaptile) |
| { |
| uint32_t **PALmap = img->PALmap; |
| |
| (void)x; |
| (void)y; |
| fromskew /= 8; |
| for (; h > 0; --h) |
| { |
| uint32_t *bw; |
| UNROLL8(w, bw = PALmap[*pp++], *cp++ = *bw++); |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 8-bit greyscale => colormap/RGB |
| */ |
| DECLAREContigPutFunc(putgreytile) |
| { |
| int samplesperpixel = img->samplesperpixel; |
| uint32_t **BWmap = img->BWmap; |
| |
| (void)y; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| *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_t **BWmap = img->BWmap; |
| |
| (void)y; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| *cp++ = BWmap[*pp][0] & ((uint32_t) * (pp + 1) << 24 | ~A1); |
| pp += samplesperpixel; |
| } |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 16-bit greyscale => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put16bitbwtile) |
| { |
| int samplesperpixel = img->samplesperpixel; |
| uint32_t **BWmap = img->BWmap; |
| |
| (void)y; |
| for (; h > 0; --h) |
| { |
| uint16_t *wp = (uint16_t *)pp; |
| |
| for (x = w; x > 0; --x) |
| { |
| /* 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_t **BWmap = img->BWmap; |
| |
| (void)x; |
| (void)y; |
| fromskew /= 8; |
| for (; h > 0; --h) |
| { |
| uint32_t *bw; |
| UNROLL8(w, bw = BWmap[*pp++], *cp++ = *bw++); |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 2-bit greyscale => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put2bitbwtile) |
| { |
| uint32_t **BWmap = img->BWmap; |
| |
| (void)x; |
| (void)y; |
| fromskew /= 4; |
| for (; h > 0; --h) |
| { |
| uint32_t *bw; |
| UNROLL4(w, bw = BWmap[*pp++], *cp++ = *bw++); |
| cp += toskew; |
| pp += fromskew; |
| } |
| } |
| |
| /* |
| * 4-bit greyscale => colormap/RGB |
| */ |
| DECLAREContigPutFunc(put4bitbwtile) |
| { |
| uint32_t **BWmap = img->BWmap; |
| |
| (void)x; |
| (void)y; |
| fromskew /= 2; |
| for (; h > 0; --h) |
| { |
| uint32_t *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; |
| for (; h > 0; --h) |
| { |
| 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; |
| for (; h > 0; --h) |
| { |
| 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; |
| for (; h > 0; --h) |
| { |
| uint32_t r, g, b, a; |
| uint8_t *m; |
| for (x = w; x > 0; --x) |
| { |
| a = pp[3]; |
| m = img->UaToAa + ((size_t)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_t *wp = (uint16_t *)pp; |
| (void)y; |
| fromskew *= samplesperpixel; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| *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_t *wp = (uint16_t *)pp; |
| (void)y; |
| fromskew *= samplesperpixel; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| *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_t *wp = (uint16_t *)pp; |
| (void)y; |
| fromskew *= samplesperpixel; |
| for (; h > 0; --h) |
| { |
| uint32_t r, g, b, a; |
| uint8_t *m; |
| for (x = w; x > 0; --x) |
| { |
| a = img->Bitdepth16To8[wp[3]]; |
| m = img->UaToAa + ((size_t)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_t r, g, b, k; |
| |
| (void)x; |
| (void)y; |
| fromskew *= samplesperpixel; |
| for (; h > 0; --h) |
| { |
| 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; |
| } |
| } |
| |
| /* |
| * 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_t r, g, b, k; |
| |
| (void)y; |
| fromskew *= samplesperpixel; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| 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; |
| } |
| } |
| |
| #define DECLARESepPutFunc(name) \ |
| static void name(TIFFRGBAImage *img, uint32_t *cp, uint32_t x, uint32_t y, \ |
| uint32_t w, uint32_t h, int32_t fromskew, int32_t 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; |
| for (; h > 0; --h) |
| { |
| 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; |
| for (; h > 0; --h) |
| { |
| 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; |
| for (; h > 0; --h) |
| { |
| uint32_t rv, gv, bv, kv; |
| for (x = w; x > 0; --x) |
| { |
| 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; |
| for (; h > 0; --h) |
| { |
| uint32_t rv, gv, bv, av; |
| uint8_t *m; |
| for (x = w; x > 0; --x) |
| { |
| av = *a++; |
| m = img->UaToAa + ((size_t)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_t *wr = (uint16_t *)r; |
| uint16_t *wg = (uint16_t *)g; |
| uint16_t *wb = (uint16_t *)b; |
| (void)img; |
| (void)y; |
| (void)a; |
| for (; h > 0; --h) |
| { |
| 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_t *wr = (uint16_t *)r; |
| uint16_t *wg = (uint16_t *)g; |
| uint16_t *wb = (uint16_t *)b; |
| uint16_t *wa = (uint16_t *)a; |
| (void)img; |
| (void)y; |
| for (; h > 0; --h) |
| { |
| 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_t *wr = (uint16_t *)r; |
| uint16_t *wg = (uint16_t *)g; |
| uint16_t *wb = (uint16_t *)b; |
| uint16_t *wa = (uint16_t *)a; |
| (void)img; |
| (void)y; |
| for (; h > 0; --h) |
| { |
| uint32_t r2, g2, b2, a2; |
| uint8_t *m; |
| for (x = w; x > 0; --x) |
| { |
| a2 = img->Bitdepth16To8[*wa++]; |
| m = img->UaToAa + ((size_t)a2 << 8); |
| r2 = m[img->Bitdepth16To8[*wr++]]; |
| g2 = m[img->Bitdepth16To8[*wg++]]; |
| b2 = m[img->Bitdepth16To8[*wb++]]; |
| *cp++ = PACK4(r2, g2, b2, a2); |
| } |
| SKEW4(wr, wg, wb, wa, fromskew); |
| cp += toskew; |
| } |
| } |
| |
| /* |
| * 8-bit packed CIE L*a*b 1976 samples => RGB |
| */ |
| DECLAREContigPutFunc(putcontig8bitCIELab8) |
| { |
| float X, Y, Z; |
| uint32_t r, g, b; |
| (void)y; |
| fromskew *= 3; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| 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; |
| } |
| } |
| |
| /* |
| * 16-bit packed CIE L*a*b 1976 samples => RGB |
| */ |
| DECLAREContigPutFunc(putcontig8bitCIELab16) |
| { |
| float X, Y, Z; |
| uint32_t r, g, b; |
| uint16_t *wp = (uint16_t *)pp; |
| (void)y; |
| fromskew *= 3; |
| for (; h > 0; --h) |
| { |
| for (x = w; x > 0; --x) |
| { |
| TIFFCIELab16ToXYZ(img->cielab, (uint16_t)wp[0], (int16_t)wp[1], |
| (int16_t)wp[2], &X, &Y, &Z); |
| TIFFXYZToRGB(img->cielab, X, Y, Z, &r, &g, &b); |
| *cp++ = PACK(r, g, b); |
| wp += 3; |
| } |
| cp += toskew; |
| wp += fromskew; |
| } |
| } |
| |
| /* |
| * YCbCr -> RGB conversion and packing routines. |
| */ |
| |
| #define YCbCrtoRGB(dst, Y) \ |
| { \ |
| uint32_t r, g, b; \ |
| TIFFYCbCrtoRGB(img->ycbcr, (Y), Cb, Cr, &r, &g, &b); \ |
| dst = PACK(r, g, b); \ |
| } |
| |
| /* |
| * 8-bit packed YCbCr samples w/ 4,4 subsampling => RGB |
| */ |
| DECLAREContigPutFunc(putcontig8bitYCbCr44tile) |
| { |
| uint32_t *cp1 = cp + w + toskew; |
| uint32_t *cp2 = cp1 + w + toskew; |
| uint32_t *cp3 = cp2 + w + toskew; |
| int32_t incr = 3 * w + 4 * toskew; |
| |
| (void)y; |
| /* adjust fromskew */ |
| fromskew = (fromskew / 4) * (4 * 2 + 2); |
| if ((h & 3) == 0 && (w & 3) == 0) |
| { |
| for (; h >= 4; h -= 4) |
| { |
| x = w >> 2; |
| do |
| { |
| int32_t Cb = pp[16]; |
| int32_t 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_t Cb = pp[16]; |
| int32_t 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_t *cp1 = cp + w + toskew; |
| int32_t incr = 2 * toskew + w; |
| |
| (void)y; |
| fromskew = (fromskew / 4) * (4 * 2 + 2); |
| if ((w & 3) == 0 && (h & 1) == 0) |
| { |
| for (; h >= 2; h -= 2) |
| { |
| x = w >> 2; |
| do |
| { |
| int32_t Cb = pp[8]; |
| int32_t 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_t Cb = pp[8]; |
| int32_t 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; |
| fromskew = (fromskew / 4) * (4 * 1 + 2); |
| do |
| { |
| x = w >> 2; |
| while (x > 0) |
| { |
| int32_t Cb = pp[4]; |
| int32_t 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; |
| x--; |
| } |
| |
| if ((w & 3) != 0) |
| { |
| int32_t Cb = pp[4]; |
| int32_t Cr = pp[5]; |
| |
| switch ((w & 3)) |
| { |
| case 3: |
| YCbCrtoRGB(cp[2], pp[2]); /*-fallthrough*/ |
| case 2: |
| YCbCrtoRGB(cp[1], pp[1]); /*-fallthrough*/ |
| case 1: |
| YCbCrtoRGB(cp[0], pp[0]); /*-fallthrough*/ |
| 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_t *cp2; |
| int32_t incr = 2 * toskew + w; |
| (void)y; |
| fromskew = (fromskew / 2) * (2 * 2 + 2); |
| cp2 = cp + w + toskew; |
| while (h >= 2) |
| { |
| x = w; |
| while (x >= 2) |
| { |
| uint32_t Cb = pp[4]; |
| uint32_t 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_t Cb = pp[4]; |
| uint32_t 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_t Cb = pp[4]; |
| uint32_t 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_t Cb = pp[4]; |
| uint32_t Cr = pp[5]; |
| YCbCrtoRGB(cp[0], pp[0]); |
| } |
| } |
| } |
| |
| /* |
| * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB |
| */ |
| DECLAREContigPutFunc(putcontig8bitYCbCr21tile) |
| { |
| (void)y; |
| fromskew = (fromskew / 2) * (2 * 1 + 2); |
| do |
| { |
| x = w >> 1; |
| while (x > 0) |
| { |
| int32_t Cb = pp[2]; |
| int32_t Cr = pp[3]; |
| |
| YCbCrtoRGB(cp[0], pp[0]); |
| YCbCrtoRGB(cp[1], pp[1]); |
| |
| cp += 2; |
| pp += 4; |
| x--; |
| } |
| |
| if ((w & 1) != 0) |
| { |
| int32_t Cb = pp[2]; |
| int32_t 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_t *cp2; |
| int32_t incr = 2 * toskew + w; |
| (void)y; |
| fromskew = (fromskew / 1) * (1 * 2 + 2); |
| cp2 = cp + w + toskew; |
| while (h >= 2) |
| { |
| x = w; |
| do |
| { |
| uint32_t Cb = pp[2]; |
| uint32_t 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_t Cb = pp[2]; |
| uint32_t 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 = (fromskew / 1) * (1 * 1 + 2); |
| do |
| { |
| x = w; /* was x = w>>1; patched 2000/09/25 warmerda@home.com */ |
| do |
| { |
| int32_t Cb = pp[1]; |
| int32_t 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 */ |
| for (; h > 0; --h) |
| { |
| x = w; |
| do |
| { |
| uint32_t 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 isInRefBlackWhiteRange(float f) |
| { |
| return f > (float)(-0x7FFFFFFF + 128) && f < (float)0x7FFFFFFF; |
| } |
| |
| static int initYCbCrConversion(TIFFRGBAImage *img) |
| { |
| static const char module[] = "initYCbCrConversion"; |
| |
| float *luma, *refBlackWhite; |
| |
| if (img->ycbcr == NULL) |
| { |
| img->ycbcr = (TIFFYCbCrToRGB *)_TIFFmallocExt( |
| img->tif, TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long)) + |
| 4 * 256 * sizeof(TIFFRGBValue) + |
| 2 * 256 * sizeof(int) + 3 * 256 * sizeof(int32_t)); |
| if (img->ycbcr == NULL) |
| { |
| TIFFErrorExtR(img->tif, module, |
| "No space for YCbCr->RGB conversion state"); |
| return (0); |
| } |
| } |
| |
| TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma); |
| TIFFGetFieldDefaulted(img->tif, TIFFTAG_REFERENCEBLACKWHITE, |
| &refBlackWhite); |
| |
| /* Do some validation to avoid later issues. Detect NaN for now */ |
| /* and also if lumaGreen is zero since we divide by it later */ |
| if (luma[0] != luma[0] || luma[1] != luma[1] || luma[1] == 0.0 || |
| luma[2] != luma[2]) |
| { |
| TIFFErrorExtR(img->tif, module, |
| "Invalid values for YCbCrCoefficients tag"); |
| return (0); |
| } |
| |
| if (!isInRefBlackWhiteRange(refBlackWhite[0]) || |
| !isInRefBlackWhiteRange(refBlackWhite[1]) || |
| !isInRefBlackWhiteRange(refBlackWhite[2]) || |
| !isInRefBlackWhiteRange(refBlackWhite[3]) || |
| !isInRefBlackWhiteRange(refBlackWhite[4]) || |
| !isInRefBlackWhiteRange(refBlackWhite[5])) |
| { |
| TIFFErrorExtR(img->tif, module, |
| "Invalid values for ReferenceBlackWhite tag"); |
| return (0); |
| } |
| |
| 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]; |
| |
| TIFFGetFieldDefaulted(img->tif, TIFFTAG_WHITEPOINT, &whitePoint); |
| if (whitePoint[1] == 0.0f) |
| { |
| TIFFErrorExtR(img->tif, module, "Invalid value for WhitePoint tag."); |
| return NULL; |
| } |
| |
| if (!img->cielab) |
| { |
| img->cielab = (TIFFCIELabToRGB *)_TIFFmallocExt( |
| img->tif, sizeof(TIFFCIELabToRGB)); |
| if (!img->cielab) |
| { |
| TIFFErrorExtR(img->tif, module, |
| "No space for CIE L*a*b*->RGB conversion state."); |
| return NULL; |
| } |
| } |
| |
| 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) |
| { |
| TIFFErrorExtR(img->tif, module, |
| "Failed to initialize CIE L*a*b*->RGB conversion state."); |
| _TIFFfreeExt(img->tif, img->cielab); |
| return NULL; |
| } |
| |
| if (img->bitspersample == 8) |
| return putcontig8bitCIELab8; |
| else if (img->bitspersample == 16) |
| return putcontig8bitCIELab16; |
| return NULL; |
| } |
| |
| /* |
| * 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_t *p; |
| |
| if (nsamples == 0) |
| nsamples = 1; |
| |
| img->BWmap = (uint32_t **)_TIFFmallocExt( |
| img->tif, |
| 256 * sizeof(uint32_t *) + (256 * nsamples * sizeof(uint32_t))); |
| if (img->BWmap == NULL) |
| { |
| TIFFErrorExtR(img->tif, TIFFFileName(img->tif), |
| "No space for B&W mapping table"); |
| return (0); |
| } |
| p = (uint32_t *)(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_t x, range; |
| |
| range = (int32_t)((1L << img->bitspersample) - 1); |
| |
| /* treat 16 bit the same as eight bit */ |
| if (img->bitspersample == 16) |
| range = (int32_t)255; |
| |
| img->Map = (TIFFRGBValue *)_TIFFmallocExt( |
| img->tif, (range + 1) * sizeof(TIFFRGBValue)); |
| if (img->Map == NULL) |
| { |
| TIFFErrorExtR(img->tif, 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 */ |
| _TIFFfreeExt(img->tif, img->Map); |
| img->Map = NULL; |
| } |
| return (1); |
| } |
| |
| static int checkcmap(TIFFRGBAImage *img) |
| { |
| uint16_t *r = img->redcmap; |
| uint16_t *g = img->greencmap; |
| uint16_t *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_t *r = img->redcmap; |
| uint16_t *g = img->greencmap; |
| uint16_t *b = img->bluecmap; |
| long i; |
| |
| for (i = (1L << img->bitspersample) - 1; i >= 0; i--) |
| { |
| #define CVT(x) ((uint16_t)((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_t *r = img->redcmap; |
| uint16_t *g = img->greencmap; |
| uint16_t *b = img->bluecmap; |
| uint32_t *p; |
| int i; |
| |
| img->PALmap = (uint32_t **)_TIFFmallocExt( |
| img->tif, |
| 256 * sizeof(uint32_t *) + (256 * nsamples * sizeof(uint32_t))); |
| if (img->PALmap == NULL) |
| { |
| TIFFErrorExtR(img->tif, TIFFFileName(img->tif), |
| "No space for Palette mapping table"); |
| return (0); |
| } |
| p = (uint32_t *)(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: |
