1 /*
2 * Copyright (c) 1991-1997 Sam Leffler
3 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
4 *
5 * Permission to use, copy, modify, distribute, and sell this software and
6 * its documentation for any purpose is hereby granted without fee, provided
7 * that (i) the above copyright notices and this permission notice appear in
8 * all copies of the software and related documentation, and (ii) the names of
9 * Sam Leffler and Silicon Graphics may not be used in any advertising or
10 * publicity relating to the software without the specific, prior written
11 * permission of Sam Leffler and Silicon Graphics.
12 *
13 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16 *
17 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
18 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22 * OF THIS SOFTWARE.
23 */
24
25 /*
26 * TIFF Library.
27 *
28 * Tiled Image Support Routines.
29 */
30 #include "tiffiop.h"
31
32 /*
33 * Compute which tile an (x,y,z,s) value is in.
34 */
TIFFComputeTile(TIFF * tif,uint32_t x,uint32_t y,uint32_t z,uint16_t s)35 uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
36 uint16_t s)
37 {
38 TIFFDirectory *td = &tif->tif_dir;
39 uint32_t dx = td->td_tilewidth;
40 uint32_t dy = td->td_tilelength;
41 uint32_t dz = td->td_tiledepth;
42 uint32_t tile = 1;
43
44 if (td->td_imagedepth == 1)
45 z = 0;
46 if (dx == (uint32_t)-1)
47 dx = td->td_imagewidth;
48 if (dy == (uint32_t)-1)
49 dy = td->td_imagelength;
50 if (dz == (uint32_t)-1)
51 dz = td->td_imagedepth;
52 if (dx != 0 && dy != 0 && dz != 0)
53 {
54 uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
55 uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
56 uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
57
58 if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
59 tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
60 xpt * (y / dy) + x / dx;
61 else
62 tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
63 }
64 return (tile);
65 }
66
67 /*
68 * Check an (x,y,z,s) coordinate
69 * against the image bounds.
70 */
TIFFCheckTile(TIFF * tif,uint32_t x,uint32_t y,uint32_t z,uint16_t s)71 int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
72 {
73 TIFFDirectory *td = &tif->tif_dir;
74
75 if (x >= td->td_imagewidth)
76 {
77 TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu",
78 (unsigned long)x, (unsigned long)(td->td_imagewidth - 1));
79 return (0);
80 }
81 if (y >= td->td_imagelength)
82 {
83 TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu",
84 (unsigned long)y,
85 (unsigned long)(td->td_imagelength - 1));
86 return (0);
87 }
88 if (z >= td->td_imagedepth)
89 {
90 TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
91 (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
92 return (0);
93 }
94 if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
95 s >= td->td_samplesperpixel)
96 {
97 TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
98 (unsigned long)s,
99 (unsigned long)(td->td_samplesperpixel - 1));
100 return (0);
101 }
102 return (1);
103 }
104
105 /*
106 * Compute how many tiles are in an image.
107 */
TIFFNumberOfTiles(TIFF * tif)108 uint32_t TIFFNumberOfTiles(TIFF *tif)
109 {
110 TIFFDirectory *td = &tif->tif_dir;
111 uint32_t dx = td->td_tilewidth;
112 uint32_t dy = td->td_tilelength;
113 uint32_t dz = td->td_tiledepth;
114 uint32_t ntiles;
115
116 if (dx == (uint32_t)-1)
117 dx = td->td_imagewidth;
118 if (dy == (uint32_t)-1)
119 dy = td->td_imagelength;
120 if (dz == (uint32_t)-1)
121 dz = td->td_imagedepth;
122 ntiles =
123 (dx == 0 || dy == 0 || dz == 0)
124 ? 0
125 : _TIFFMultiply32(
126 tif,
127 _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
128 TIFFhowmany_32(td->td_imagelength, dy),
129 "TIFFNumberOfTiles"),
130 TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
131 if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
132 ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
133 "TIFFNumberOfTiles");
134 return (ntiles);
135 }
136
137 /*
138 * Compute the # bytes in each row of a tile.
139 */
TIFFTileRowSize64(TIFF * tif)140 uint64_t TIFFTileRowSize64(TIFF *tif)
141 {
142 static const char module[] = "TIFFTileRowSize64";
143 TIFFDirectory *td = &tif->tif_dir;
144 uint64_t rowsize;
145 uint64_t tilerowsize;
146
147 if (td->td_tilelength == 0)
148 {
149 TIFFErrorExtR(tif, module, "Tile length is zero");
150 return 0;
151 }
152 if (td->td_tilewidth == 0)
153 {
154 TIFFErrorExtR(tif, module, "Tile width is zero");
155 return (0);
156 }
157 rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
158 "TIFFTileRowSize");
159 if (td->td_planarconfig == PLANARCONFIG_CONTIG)
160 {
161 if (td->td_samplesperpixel == 0)
162 {
163 TIFFErrorExtR(tif, module, "Samples per pixel is zero");
164 return 0;
165 }
166 rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
167 "TIFFTileRowSize");
168 }
169 tilerowsize = TIFFhowmany8_64(rowsize);
170 if (tilerowsize == 0)
171 {
172 TIFFErrorExtR(tif, module, "Computed tile row size is zero");
173 return 0;
174 }
175 return (tilerowsize);
176 }
TIFFTileRowSize(TIFF * tif)177 tmsize_t TIFFTileRowSize(TIFF *tif)
178 {
179 static const char module[] = "TIFFTileRowSize";
180 uint64_t m;
181 m = TIFFTileRowSize64(tif);
182 return _TIFFCastUInt64ToSSize(tif, m, module);
183 }
184
185 /*
186 * Compute the # bytes in a variable length, row-aligned tile.
187 */
TIFFVTileSize64(TIFF * tif,uint32_t nrows)188 uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
189 {
190 static const char module[] = "TIFFVTileSize64";
191 TIFFDirectory *td = &tif->tif_dir;
192 if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
193 td->td_tiledepth == 0)
194 return (0);
195 if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
196 (td->td_photometric == PHOTOMETRIC_YCBCR) &&
197 (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
198 {
199 /*
200 * Packed YCbCr data contain one Cb+Cr for every
201 * HorizontalSampling*VerticalSampling Y values.
202 * Must also roundup width and height when calculating
203 * since images that are not a multiple of the
204 * horizontal/vertical subsampling area include
205 * YCbCr data for the extended image.
206 */
207 uint16_t ycbcrsubsampling[2];
208 uint16_t samplingblock_samples;
209 uint32_t samplingblocks_hor;
210 uint32_t samplingblocks_ver;
211 uint64_t samplingrow_samples;
212 uint64_t samplingrow_size;
213 TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
214 ycbcrsubsampling + 0, ycbcrsubsampling + 1);
215 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
216 ycbcrsubsampling[0] != 4) ||
217 (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
218 ycbcrsubsampling[1] != 4))
219 {
220 TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
221 ycbcrsubsampling[0], ycbcrsubsampling[1]);
222 return 0;
223 }
224 samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
225 samplingblocks_hor =
226 TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
227 samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
228 samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
229 samplingblock_samples, module);
230 samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
231 tif, samplingrow_samples, td->td_bitspersample, module));
232 return (
233 _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
234 }
235 else
236 return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
237 }
TIFFVTileSize(TIFF * tif,uint32_t nrows)238 tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows)
239 {
240 static const char module[] = "TIFFVTileSize";
241 uint64_t m;
242 m = TIFFVTileSize64(tif, nrows);
243 return _TIFFCastUInt64ToSSize(tif, m, module);
244 }
245
246 /*
247 * Compute the # bytes in a row-aligned tile.
248 */
TIFFTileSize64(TIFF * tif)249 uint64_t TIFFTileSize64(TIFF *tif)
250 {
251 return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
252 }
TIFFTileSize(TIFF * tif)253 tmsize_t TIFFTileSize(TIFF *tif)
254 {
255 static const char module[] = "TIFFTileSize";
256 uint64_t m;
257 m = TIFFTileSize64(tif);
258 return _TIFFCastUInt64ToSSize(tif, m, module);
259 }
260
261 /*
262 * Compute a default tile size based on the image
263 * characteristics and a requested value. If a
264 * request is <1 then we choose a size according
265 * to certain heuristics.
266 */
TIFFDefaultTileSize(TIFF * tif,uint32_t * tw,uint32_t * th)267 void TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
268 {
269 (*tif->tif_deftilesize)(tif, tw, th);
270 }
271
_TIFFDefaultTileSize(TIFF * tif,uint32_t * tw,uint32_t * th)272 void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
273 {
274 (void)tif;
275 if (*(int32_t *)tw < 1)
276 *tw = 256;
277 if (*(int32_t *)th < 1)
278 *th = 256;
279 /* roundup to a multiple of 16 per the spec */
280 if (*tw & 0xf)
281 *tw = TIFFroundup_32(*tw, 16);
282 if (*th & 0xf)
283 *th = TIFFroundup_32(*th, 16);
284 }
285