Line data Source code
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 : */
35 6 : uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
36 : uint16_t s)
37 : {
38 6 : TIFFDirectory *td = &tif->tif_dir;
39 6 : uint32_t dx = td->td_tilewidth;
40 6 : uint32_t dy = td->td_tilelength;
41 6 : uint32_t dz = td->td_tiledepth;
42 6 : uint32_t tile = 1;
43 :
44 6 : if (td->td_imagedepth == 1)
45 6 : z = 0;
46 6 : if (dx == (uint32_t)-1)
47 0 : dx = td->td_imagewidth;
48 6 : if (dy == (uint32_t)-1)
49 0 : dy = td->td_imagelength;
50 6 : if (dz == (uint32_t)-1)
51 0 : dz = td->td_imagedepth;
52 6 : if (dx != 0 && dy != 0 && dz != 0)
53 : {
54 6 : uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
55 6 : uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
56 6 : uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
57 :
58 6 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
59 4 : tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
60 4 : xpt * (y / dy) + x / dx;
61 : else
62 2 : tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
63 : }
64 6 : return (tile);
65 : }
66 :
67 : /*
68 : * Check an (x,y,z,s) coordinate
69 : * against the image bounds.
70 : */
71 6 : int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
72 : {
73 6 : TIFFDirectory *td = &tif->tif_dir;
74 :
75 6 : if (x >= td->td_imagewidth)
76 : {
77 0 : TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu",
78 0 : (unsigned long)x, (unsigned long)(td->td_imagewidth - 1));
79 0 : return (0);
80 : }
81 6 : if (y >= td->td_imagelength)
82 : {
83 0 : TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu",
84 : (unsigned long)y,
85 0 : (unsigned long)(td->td_imagelength - 1));
86 0 : return (0);
87 : }
88 6 : if (z >= td->td_imagedepth)
89 : {
90 0 : TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
91 0 : (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
92 0 : return (0);
93 : }
94 6 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
95 4 : s >= td->td_samplesperpixel)
96 : {
97 0 : TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
98 : (unsigned long)s,
99 0 : (unsigned long)(td->td_samplesperpixel - 1));
100 0 : return (0);
101 : }
102 6 : return (1);
103 : }
104 :
105 : /*
106 : * Compute how many tiles are in an image.
107 : */
108 43156 : uint32_t TIFFNumberOfTiles(TIFF *tif)
109 : {
110 43156 : TIFFDirectory *td = &tif->tif_dir;
111 43156 : uint32_t dx = td->td_tilewidth;
112 43156 : uint32_t dy = td->td_tilelength;
113 43156 : uint32_t dz = td->td_tiledepth;
114 : uint32_t ntiles;
115 :
116 43156 : if (dx == (uint32_t)-1)
117 0 : dx = td->td_imagewidth;
118 43156 : if (dy == (uint32_t)-1)
119 0 : dy = td->td_imagelength;
120 43156 : if (dz == (uint32_t)-1)
121 0 : dz = td->td_imagedepth;
122 43156 : ntiles =
123 43156 : (dx == 0 || dy == 0 || dz == 0)
124 : ? 0
125 86312 : : _TIFFMultiply32(
126 : tif,
127 43156 : _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
128 43156 : TIFFhowmany_32(td->td_imagelength, dy),
129 : "TIFFNumberOfTiles"),
130 43156 : TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
131 43156 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
132 5384 : ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
133 : "TIFFNumberOfTiles");
134 43156 : return (ntiles);
135 : }
136 :
137 : /*
138 : * Compute the # bytes in each row of a tile.
139 : */
140 156521 : uint64_t TIFFTileRowSize64(TIFF *tif)
141 : {
142 : static const char module[] = "TIFFTileRowSize64";
143 156521 : TIFFDirectory *td = &tif->tif_dir;
144 : uint64_t rowsize;
145 : uint64_t tilerowsize;
146 :
147 156521 : if (td->td_tilelength == 0)
148 : {
149 0 : TIFFErrorExtR(tif, module, "Tile length is zero");
150 0 : return 0;
151 : }
152 156521 : if (td->td_tilewidth == 0)
153 : {
154 0 : TIFFErrorExtR(tif, module, "Tile width is zero");
155 0 : return (0);
156 : }
157 156521 : rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
158 : "TIFFTileRowSize");
159 156498 : if (td->td_planarconfig == PLANARCONFIG_CONTIG)
160 : {
161 145021 : if (td->td_samplesperpixel == 0)
162 : {
163 0 : TIFFErrorExtR(tif, module, "Samples per pixel is zero");
164 0 : return 0;
165 : }
166 145021 : rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
167 : "TIFFTileRowSize");
168 : }
169 156487 : tilerowsize = TIFFhowmany8_64(rowsize);
170 156487 : if (tilerowsize == 0)
171 : {
172 0 : TIFFErrorExtR(tif, module, "Computed tile row size is zero");
173 0 : return 0;
174 : }
175 156487 : return (tilerowsize);
176 : }
177 1153 : tmsize_t TIFFTileRowSize(TIFF *tif)
178 : {
179 : static const char module[] = "TIFFTileRowSize";
180 : uint64_t m;
181 1153 : m = TIFFTileRowSize64(tif);
182 1153 : return _TIFFCastUInt64ToSSize(tif, m, module);
183 : }
184 :
185 : /*
186 : * Compute the # bytes in a variable length, row-aligned tile.
187 : */
188 156226 : uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
189 : {
190 : static const char module[] = "TIFFVTileSize64";
191 156226 : TIFFDirectory *td = &tif->tif_dir;
192 156226 : if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
193 156216 : td->td_tiledepth == 0)
194 29 : return (0);
195 156197 : if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
196 144820 : (td->td_photometric == PHOTOMETRIC_YCBCR) &&
197 3177 : (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 859 : TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
214 : ycbcrsubsampling + 0, ycbcrsubsampling + 1);
215 859 : if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
216 0 : ycbcrsubsampling[0] != 4) ||
217 859 : (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
218 0 : ycbcrsubsampling[1] != 4))
219 : {
220 0 : TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
221 0 : ycbcrsubsampling[0], ycbcrsubsampling[1]);
222 0 : return 0;
223 : }
224 859 : samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
225 859 : samplingblocks_hor =
226 859 : TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
227 859 : samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
228 859 : samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
229 : samplingblock_samples, module);
230 859 : samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
231 : tif, samplingrow_samples, td->td_bitspersample, module));
232 : return (
233 859 : _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
234 : }
235 : else
236 155338 : return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
237 : }
238 0 : tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows)
239 : {
240 : static const char module[] = "TIFFVTileSize";
241 : uint64_t m;
242 0 : m = TIFFVTileSize64(tif, nrows);
243 0 : return _TIFFCastUInt64ToSSize(tif, m, module);
244 : }
245 :
246 : /*
247 : * Compute the # bytes in a row-aligned tile.
248 : */
249 141000 : uint64_t TIFFTileSize64(TIFF *tif)
250 : {
251 141000 : return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
252 : }
253 132899 : tmsize_t TIFFTileSize(TIFF *tif)
254 : {
255 : static const char module[] = "TIFFTileSize";
256 : uint64_t m;
257 132899 : m = TIFFTileSize64(tif);
258 132898 : 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 : */
267 0 : void TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
268 : {
269 0 : (*tif->tif_deftilesize)(tif, tw, th);
270 0 : }
271 :
272 0 : void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
273 : {
274 : (void)tif;
275 0 : if (*(int32_t *)tw < 1)
276 0 : *tw = 256;
277 0 : if (*(int32_t *)th < 1)
278 0 : *th = 256;
279 : /* roundup to a multiple of 16 per the spec */
280 0 : if (*tw & 0xf)
281 0 : *tw = TIFFroundup_32(*tw, 16);
282 0 : if (*th & 0xf)
283 0 : *th = TIFFroundup_32(*th, 16);
284 0 : }
|
