Revision control
/*
* 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);
+ uint32_t xpt_ypt = _TIFFMultiply32(tif, xpt, ypt, "TIFFComputeTile");
+ uint32_t xpt_ypt_zpt =
+ _TIFFMultiply32(tif, xpt_ypt, zpt, "TIFFComputeTile");
+ uint64_t z_offset;
+ uint64_t y_offset;
+ uint64_t tile64;
+ if ((xpt_ypt == 0 && xpt != 0 && ypt != 0) ||
+ (xpt_ypt_zpt == 0 && xpt_ypt != 0 && zpt != 0))
+ return (0);
+
+ z_offset = _TIFFMultiply64(tif, xpt_ypt, z / dz, "TIFFComputeTile");
+ y_offset = _TIFFMultiply64(tif, xpt, y / dy, "TIFFComputeTile");
+ if ((z_offset == 0 && xpt_ypt != 0 && (z / dz) != 0) ||
+ (y_offset == 0 && xpt != 0 && (y / dy) != 0))
+ return (0);
+ tile64 = _TIFFAdd64(tif, z_offset, y_offset, "TIFFComputeTile");
+ if (tile64 == 0 && (z_offset != 0 || y_offset != 0))
+ return (0);
+ tile64 = _TIFFAdd64(tif, tile64, x / dx, "TIFFComputeTile");
+ if (tile64 == 0 && (z_offset != 0 || y_offset != 0 || (x / dx) != 0))
+ return (0);
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;
+ {
+ uint64_t sample_offset;
+ if (s >= td->td_samplesperpixel)
+ {
+ TIFFErrorExtR(
+ tif, "TIFFComputeTile", "%lu: Sample out of range, max %lu",
+ (unsigned long)s, (unsigned long)td->td_samplesperpixel);
+ return (0);
+ }
+ sample_offset =
+ _TIFFMultiply64(tif, xpt_ypt_zpt, s, "TIFFComputeTile");
+ if (sample_offset == 0 && xpt_ypt_zpt != 0 && s != 0)
+ return (0);
+ tile64 = _TIFFAdd64(tif, sample_offset, tile64, "TIFFComputeTile");
+ if (tile64 == 0 && (sample_offset != 0 || z_offset != 0 ||
+ y_offset != 0 || (x / dx) != 0))
+ return (0);
+ }
+ tile = _TIFFCastUInt64ToUInt32(tif, tile64, "TIFFComputeTile");
+ if (tile == 0 && tile64 != 0)
+ return (0);
}
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));
+ return _TIFFStrileSize64(tif, nrows, /* isStrip = */ FALSE);
}
+
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);
}