| /* | |
| * 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. | |
| * | |
| * Tiled Image Support Routines. | |
| */ | |
| #include "tiffiop.h" | |
| /* | |
| * Compute which tile an (x,y,z,s) value is in. | |
| */ | |
| uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, | |
| uint16_t s) | |
| { | |
| TIFFDirectory *td = &tif->tif_dir; | |
| uint32_t dx = td->td_tilewidth; | |
| uint32_t dy = td->td_tilelength; | |
| uint32_t dz = td->td_tiledepth; | |
| uint32_t tile = 1; | |
| if (td->td_imagedepth == 1) | |
| z = 0; | |
| if (dx == (uint32_t)-1) | |
| dx = td->td_imagewidth; | |
| if (dy == (uint32_t)-1) | |
| dy = td->td_imagelength; | |
| if (dz == (uint32_t)-1) | |
| dz = td->td_imagedepth; | |
| if (dx != 0 && dy != 0 && dz != 0) | |
| { | |
| uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx); | |
| uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy); | |
| uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz); | |
| if (td->td_planarconfig == PLANARCONFIG_SEPARATE) | |
| tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) + | |
| xpt * (y / dy) + x / dx; | |
| else | |
| tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx; | |
| } | |
| return (tile); | |
| } | |
| /* | |
| * Check an (x,y,z,s) coordinate | |
| * against the image bounds. | |
| */ | |
| int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s) | |
| { | |
| TIFFDirectory *td = &tif->tif_dir; | |
| if (x >= td->td_imagewidth) | |
| { | |
| TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu", | |
| (unsigned long)x, (unsigned long)(td->td_imagewidth - 1)); | |
| return (0); | |
| } | |
| if (y >= td->td_imagelength) | |
| { | |
| TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu", | |
| (unsigned long)y, | |
| (unsigned long)(td->td_imagelength - 1)); | |
| return (0); | |
| } | |
| if (z >= td->td_imagedepth) | |
| { | |
| TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu", | |
| (unsigned long)z, (unsigned long)(td->td_imagedepth - 1)); | |
| return (0); | |
| } | |
| if (td->td_planarconfig == PLANARCONFIG_SEPARATE && | |
| s >= td->td_samplesperpixel) | |
| { | |
| TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu", | |
| (unsigned long)s, | |
| (unsigned long)(td->td_samplesperpixel - 1)); | |
| return (0); | |
| } | |
| return (1); | |
| } | |
| /* | |
| * Compute how many tiles are in an image. | |
| */ | |
| uint32_t TIFFNumberOfTiles(TIFF *tif) | |
| { | |
| TIFFDirectory *td = &tif->tif_dir; | |
| uint32_t dx = td->td_tilewidth; | |
| uint32_t dy = td->td_tilelength; | |
| uint32_t dz = td->td_tiledepth; | |
| uint32_t ntiles; | |
| if (dx == (uint32_t)-1) | |
| dx = td->td_imagewidth; | |
| if (dy == (uint32_t)-1) | |
| dy = td->td_imagelength; | |
| if (dz == (uint32_t)-1) | |
| dz = td->td_imagedepth; | |
| ntiles = | |
| (dx == 0 || dy == 0 || dz == 0) | |
| ? 0 | |
| : _TIFFMultiply32( | |
| tif, | |
| _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx), | |
| TIFFhowmany_32(td->td_imagelength, dy), | |
| "TIFFNumberOfTiles"), | |
| TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles"); | |
| if (td->td_planarconfig == PLANARCONFIG_SEPARATE) | |
| ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel, | |
| "TIFFNumberOfTiles"); | |
| return (ntiles); | |
| } | |
| /* | |
| * Compute the # bytes in each row of a tile. | |
| */ | |
| uint64_t TIFFTileRowSize64(TIFF *tif) | |
| { | |
| static const char module[] = "TIFFTileRowSize64"; | |
| TIFFDirectory *td = &tif->tif_dir; | |
| uint64_t rowsize; | |
| uint64_t tilerowsize; | |
| if (td->td_tilelength == 0) | |
| { | |
| TIFFErrorExtR(tif, module, "Tile length is zero"); | |
| return 0; | |
| } | |
| if (td->td_tilewidth == 0) | |
| { | |
| TIFFErrorExtR(tif, module, "Tile width is zero"); | |
| return (0); | |
| } | |
| rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth, | |
| "TIFFTileRowSize"); | |
| if (td->td_planarconfig == PLANARCONFIG_CONTIG) | |
| { | |
| if (td->td_samplesperpixel == 0) | |
| { | |
| TIFFErrorExtR(tif, module, "Samples per pixel is zero"); | |
| return 0; | |
| } | |
| rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel, | |
| "TIFFTileRowSize"); | |
| } | |
| tilerowsize = TIFFhowmany8_64(rowsize); | |
| if (tilerowsize == 0) | |
| { | |
| TIFFErrorExtR(tif, module, "Computed tile row size is zero"); | |
| return 0; | |
| } | |
| return (tilerowsize); | |
| } | |
| tmsize_t TIFFTileRowSize(TIFF *tif) | |
| { | |
| static const char module[] = "TIFFTileRowSize"; | |
| uint64_t m; | |
| m = TIFFTileRowSize64(tif); | |
| return _TIFFCastUInt64ToSSize(tif, m, module); | |
| } | |
| /* | |
| * Compute the # bytes in a variable length, row-aligned tile. | |
| */ | |
| uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows) | |
| { | |
| static const char module[] = "TIFFVTileSize64"; | |
| TIFFDirectory *td = &tif->tif_dir; | |
| if (td->td_tilelength == 0 || td->td_tilewidth == 0 || | |
| td->td_tiledepth == 0) | |
| return (0); | |
| if ((td->td_planarconfig == PLANARCONFIG_CONTIG) && | |
| (td->td_photometric == PHOTOMETRIC_YCBCR) && | |
| (td->td_samplesperpixel == 3) && (!isUpSampled(tif))) | |
| { | |
| /* | |
| * Packed YCbCr data contain one Cb+Cr for every | |
| * HorizontalSampling*VerticalSampling Y values. | |
| * Must also roundup width and height when calculating | |
| * since images that are not a multiple of the | |
| * horizontal/vertical subsampling area include | |
| * YCbCr data for the extended image. | |
| */ | |
| uint16_t ycbcrsubsampling[2]; | |
| uint16_t samplingblock_samples; | |
| uint32_t samplingblocks_hor; | |
| uint32_t samplingblocks_ver; | |
| uint64_t samplingrow_samples; | |
| uint64_t samplingrow_size; | |
| TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, | |
| ycbcrsubsampling + 0, ycbcrsubsampling + 1); | |
| if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && | |
| ycbcrsubsampling[0] != 4) || | |
| (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && | |
| ycbcrsubsampling[1] != 4)) | |
| { | |
| TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)", | |
| ycbcrsubsampling[0], ycbcrsubsampling[1]); | |
| return 0; | |
| } | |
| samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2; | |
| samplingblocks_hor = | |
| TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]); | |
| samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]); | |
| samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor, | |
| samplingblock_samples, module); | |
| samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64( | |
| tif, samplingrow_samples, td->td_bitspersample, module)); | |
| return ( | |
| _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module)); | |
| } | |
| else | |
| return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module)); | |
| } | |
| tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows) | |
| { | |
| static const char module[] = "TIFFVTileSize"; | |
| uint64_t m; | |
| m = TIFFVTileSize64(tif, nrows); | |
| return _TIFFCastUInt64ToSSize(tif, m, module); | |
| } | |
| /* | |
| * Compute the # bytes in a row-aligned tile. | |
| */ | |
| uint64_t TIFFTileSize64(TIFF *tif) | |
| { | |
| return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength)); | |
| } | |
| tmsize_t TIFFTileSize(TIFF *tif) | |
| { | |
| static const char module[] = "TIFFTileSize"; | |
| uint64_t m; | |
| m = TIFFTileSize64(tif); | |
| return _TIFFCastUInt64ToSSize(tif, m, module); | |
| } | |
| /* | |
| * Compute a default tile size based on the image | |
| * characteristics and a requested value. If a | |
| * request is <1 then we choose a size according | |
| * to certain heuristics. | |
| */ | |
| void TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th) | |
| { | |
| (*tif->tif_deftilesize)(tif, tw, th); | |
| } | |
| void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th) | |
| { | |
| (void)tif; | |
| if (*(int32_t *)tw < 1) | |
| *tw = 256; | |
| if (*(int32_t *)th < 1) | |
| *th = 256; | |
| /* roundup to a multiple of 16 per the spec */ | |
| if (*tw & 0xf) | |
| *tw = TIFFroundup_32(*tw, 16); | |
| if (*th & 0xf) | |
| *th = TIFFroundup_32(*th, 16); | |
| } |