[wxWidgets.git] / src / tiff / libtiff / tif_tile.c

/* $Id$ */

/*
 * 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"

static uint32
summarize(TIFF* tif, size_t summand1, size_t summand2, const char* where)
{
	/*
	 * XXX: We are using casting to uint32 here, because sizeof(size_t)
	 * may be larger than sizeof(uint32) on 64-bit architectures.
	 */
	uint32	bytes = summand1 + summand2;

	if (bytes - summand1 != summand2) {
		TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
		bytes = 0;
	}

	return (bytes);
}

static uint32
multiply(TIFF* tif, size_t nmemb, size_t elem_size, const char* where)
{
	uint32	bytes = nmemb * elem_size;

	if (elem_size && bytes / elem_size != nmemb) {
		TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
		bytes = 0;
	}

	return (bytes);
}

/*
 * Compute which tile an (x,y,z,s) value is in.
 */
ttile_t
TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
{
	TIFFDirectory *td = &tif->tif_dir;
	uint32 dx = td->td_tilewidth;
	uint32 dy = td->td_tilelength;
	uint32 dz = td->td_tiledepth;
	ttile_t tile = 1;

	if (td->td_imagedepth == 1)
		z = 0;
	if (dx == (uint32) -1)
		dx = td->td_imagewidth;
	if (dy == (uint32) -1)
		dy = td->td_imagelength;
	if (dz == (uint32) -1)
		dz = td->td_imagedepth;
	if (dx != 0 && dy != 0 && dz != 0) {
		uint32 xpt = TIFFhowmany(td->td_imagewidth, dx); 
		uint32 ypt = TIFFhowmany(td->td_imagelength, dy); 
		uint32 zpt = TIFFhowmany(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 x, uint32 y, uint32 z, tsample_t s)
{
	TIFFDirectory *td = &tif->tif_dir;

	if (x >= td->td_imagewidth) {
		TIFFErrorExt(tif->tif_clientdata, 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) {
		TIFFErrorExt(tif->tif_clientdata, 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) {
		TIFFErrorExt(tif->tif_clientdata, 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) {
		TIFFErrorExt(tif->tif_clientdata, 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.
 */
ttile_t
TIFFNumberOfTiles(TIFF* tif)
{
	TIFFDirectory *td = &tif->tif_dir;
	uint32 dx = td->td_tilewidth;
	uint32 dy = td->td_tilelength;
	uint32 dz = td->td_tiledepth;
	ttile_t ntiles;

	if (dx == (uint32) -1)
		dx = td->td_imagewidth;
	if (dy == (uint32) -1)
		dy = td->td_imagelength;
	if (dz == (uint32) -1)
		dz = td->td_imagedepth;
	ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
	    multiply(tif, multiply(tif, TIFFhowmany(td->td_imagewidth, dx),
				   TIFFhowmany(td->td_imagelength, dy),
				   "TIFFNumberOfTiles"),
		     TIFFhowmany(td->td_imagedepth, dz), "TIFFNumberOfTiles");
	if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
		ntiles = multiply(tif, ntiles, td->td_samplesperpixel,
				  "TIFFNumberOfTiles");
	return (ntiles);
}

/*
 * Compute the # bytes in each row of a tile.
 */
tsize_t
TIFFTileRowSize(TIFF* tif)
{
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t rowsize;
	
	if (td->td_tilelength == 0 || td->td_tilewidth == 0)
		return ((tsize_t) 0);
	rowsize = multiply(tif, td->td_bitspersample, td->td_tilewidth,
			   "TIFFTileRowSize");
	if (td->td_planarconfig == PLANARCONFIG_CONTIG)
		rowsize = multiply(tif, rowsize, td->td_samplesperpixel,
				   "TIFFTileRowSize");
	return ((tsize_t) TIFFhowmany8(rowsize));
}

/*
 * Compute the # bytes in a variable length, row-aligned tile.
 */
tsize_t
TIFFVTileSize(TIFF* tif, uint32 nrows)
{
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t tilesize;

	if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
	    td->td_tiledepth == 0)
		return ((tsize_t) 0);
	if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
	    td->td_photometric == PHOTOMETRIC_YCBCR &&
	    !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.
		 */
		tsize_t w =
		    TIFFroundup(td->td_tilewidth, td->td_ycbcrsubsampling[0]);
		tsize_t rowsize =
		    TIFFhowmany8(multiply(tif, w, td->td_bitspersample,
					  "TIFFVTileSize"));
		tsize_t samplingarea =
		    td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1];
		if (samplingarea == 0) {
			TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Invalid YCbCr subsampling");
			return 0;
		}
		nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]);
		/* NB: don't need TIFFhowmany here 'cuz everything is rounded */
		tilesize = multiply(tif, nrows, rowsize, "TIFFVTileSize");
		tilesize = summarize(tif, tilesize,
				     multiply(tif, 2, tilesize / samplingarea,
					      "TIFFVTileSize"),
				     "TIFFVTileSize");
	} else
		tilesize = multiply(tif, nrows, TIFFTileRowSize(tif),
				    "TIFFVTileSize");
	return ((tsize_t)
	    multiply(tif, tilesize, td->td_tiledepth, "TIFFVTileSize"));
}

/*
 * Compute the # bytes in a row-aligned tile.
 */
tsize_t
TIFFTileSize(TIFF* tif)
{
	return (TIFFVTileSize(tif, tif->tif_dir.td_tilelength));
}

/*
 * 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* tw, uint32* th)
{
	(*tif->tif_deftilesize)(tif, tw, th);
}

void
_TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
{
	(void) tif;
	if (*(int32*) tw < 1)
		*tw = 256;
	if (*(int32*) th < 1)
		*th = 256;
	/* roundup to a multiple of 16 per the spec */
	if (*tw & 0xf)
		*tw = TIFFroundup(*tw, 16);
	if (*th & 0xf)
		*th = TIFFroundup(*th, 16);
}

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