[wxWidgets.git] / src / tiff / test / strip.c

/* $Id$ */

/*
 * Copyright (c) 2004, Andrey Kiselev  <dron@ak4719.spb.edu>
 *
 * 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
 *
 * Functions to test strip interface of libtiff.
 */

#include <stdio.h>
#include <string.h>

#include "tiffio.h"

int
write_strips(TIFF *tif, const tdata_t array, const tsize_t size)
{
	tstrip_t	strip, nstrips;
	tsize_t		stripsize, offset;

	stripsize = TIFFStripSize(tif);
	if (!stripsize) {
		fprintf (stderr, "Wrong size of strip.\n");
		return -1;
	}

	nstrips = TIFFNumberOfStrips(tif);
	for (offset = 0, strip = 0;
	     offset < size && strip < nstrips;
	     offset+=stripsize, strip++) {
		/*
		 * Properly write last strip.
		 */
		tsize_t	bufsize = size - offset;
		if (bufsize > stripsize)
			bufsize = stripsize;

		if (TIFFWriteEncodedStrip(tif, strip, (char *)array + offset,
					  bufsize) != bufsize) {
			fprintf (stderr, "Can't write strip %lu.\n",
				 (unsigned long)strip);
			return -1;
		}
        }

	return 0;
}

int
read_strips(TIFF *tif, const tdata_t array, const tsize_t size)
{
	tstrip_t	strip, nstrips;
	tsize_t		stripsize, offset;
	tdata_t		buf = NULL;

	stripsize = TIFFStripSize(tif);
	if (!stripsize) {
		fprintf (stderr, "Wrong size of strip.\n");
		return -1;
	}

	buf = _TIFFmalloc(stripsize);
	if (!buf) {
		fprintf (stderr, "Can't allocate space for strip buffer.\n");
		return -1;
	}

	nstrips = TIFFNumberOfStrips(tif);
	for (offset = 0, strip = 0;
	     offset < size && strip < nstrips;
	     offset+=stripsize, strip++) {
		/*
		 * Properly read last strip.
		 */
		tsize_t	bufsize = size - offset;
		if (bufsize > stripsize)
			bufsize = stripsize;

		if (TIFFReadEncodedStrip(tif, strip, buf, -1) != bufsize) {
			fprintf (stderr, "Can't read strip %lu.\n",
				 (unsigned long)strip);
			return -1;
		}
		if (memcmp(buf, (char *)array + offset, bufsize) != 0) {
			fprintf (stderr, "Wrong data read for strip %lu.\n",
				 (unsigned long)strip);
			_TIFFfree(buf);
			return -1;
		}
        }

	_TIFFfree(buf);

	return 0;
}

int
create_image_striped(const char *name, uint32 width, uint32 length,
		      uint32 rowsperstrip, uint16 compression,
		      uint16 spp, uint16 bps, uint16 photometric,
		      uint16 sampleformat, uint16 planarconfig,
		      const tdata_t array, const tsize_t size)
{
	TIFF		*tif;

	/* Test whether we can write tags. */
	tif = TIFFOpen(name, "w");
	if (!tif)
		goto openfailure;

	if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width)) {
		fprintf (stderr, "Can't set ImageWidth tag.\n");
		goto failure;
	}
	if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH, length)) {
		fprintf (stderr, "Can't set ImageLength tag.\n");
		goto failure;
	}
	if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps)) {
		fprintf (stderr, "Can't set BitsPerSample tag.\n");
		goto failure;
	}
	if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, spp)) {
		fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
		goto failure;
	}
	if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip)) {
		fprintf (stderr, "Can't set RowsPerStrip tag.\n");
		goto failure;
	}
	if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, planarconfig)) {
		fprintf (stderr, "Can't set PlanarConfiguration tag.\n");
		goto failure;
	}
	if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photometric)) {
		fprintf (stderr, "Can't set PhotometricInterpretation tag.\n");
		goto failure;
	}

	if (write_strips(tif, array, size) < 0) {
		fprintf (stderr, "Can't write image data.\n");
		goto failure;
	}

	TIFFClose(tif);
	return 0;

failure:
	TIFFClose(tif);
openfailure:
	fprintf (stderr, "Can't create test TIFF file %s:\n"
"    ImageWidth=%ld, ImageLength=%ld, RowsPerStrip=%ld, Compression=%d,\n"
"    BitsPerSample=%d, SamplesPerPixel=%d, SampleFormat=%d,\n"
"    PlanarConfiguration=%d, PhotometricInterpretation=%d.\n",
		 name, width, length, rowsperstrip, compression,
		 bps, spp, sampleformat, planarconfig,
		 photometric);
	return -1;
}

int
read_image_striped(const char *name, uint32 width, uint32 length,
		    uint32 rowsperstrip, uint16 compression,
		    uint16 spp, uint16 bps, uint16 photometric,
		    uint16 sampleformat, uint16 planarconfig,
		    const tdata_t array, const tsize_t size)
{
	TIFF		*tif;
	uint16		value_u16;
	uint32		value_u32;

	/* Test whether we can read written values. */
	tif = TIFFOpen(name, "r");
	if (!tif)
		goto openfailure;
	
	if (TIFFIsTiled(tif)) {
		fprintf (stderr, "Can't read image %s, it is tiled.\n",
			 name);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &value_u32)
	    || value_u32 != width) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_IMAGEWIDTH);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &value_u32)
	    || value_u32 != length) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_IMAGELENGTH);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &value_u16)
	    || value_u16 != bps) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_BITSPERSAMPLE);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &value_u16)
	    || value_u16 != photometric) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_PHOTOMETRIC);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &value_u16)
	    || value_u16 != spp) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_SAMPLESPERPIXEL);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &value_u32)
	    || value_u32 != rowsperstrip) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_ROWSPERSTRIP);
		goto failure;
	}
	if (!TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &value_u16)
	    || value_u16 != planarconfig) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_PLANARCONFIG);
		goto failure;
	}

	if (read_strips(tif, array, size) < 0) {
		fprintf (stderr, "Can't read image data.\n");
		goto failure;
	}

	TIFFClose(tif);
	return 0;

failure:
	TIFFClose(tif);
openfailure:
	fprintf (stderr, "Can't read test TIFF file %s:\n"
"    ImageWidth=%ld, ImageLength=%ld, RowsPerStrip=%ld, Compression=%d,\n"
"    BitsPerSample=%d, SamplesPerPixel=%d, SampleFormat=%d,\n"
"    PlanarConfiguration=%d, PhotometricInterpretation=%d.\n",
		 name, width, length, rowsperstrip, compression,
		 bps, spp, sampleformat, planarconfig,
		 photometric);
	return -1;
}

int
write_scanlines(TIFF *tif, const tdata_t array, const tsize_t size)
{
	uint32		length, row;
	tsize_t		scanlinesize, offset;

	if (!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &length)) {
		fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_IMAGELENGTH);
		return -1;
	}
	
	scanlinesize = TIFFScanlineSize(tif);
	if (!scanlinesize) {
		fprintf (stderr, "Wrong size of scanline.\n");
		return -1;
	}

	for (offset = 0, row = 0; row < length; offset+=scanlinesize, row++) {
		if (TIFFWriteScanline(tif, (char *)array + offset, row, 0) < 0) {
			fprintf (stderr,
				 "Can't write image data at row %lu.\n", row);
			return -1;
		}
        }

	return 0;
}

/* vim: set ts=8 sts=8 sw=8 noet: */
Commit	Line	Data
8414a40c VZ	1	/* $Id$ */
	2
	3	/*
	4	* Copyright (c) 2004, Andrey Kiselev <dron@ak4719.spb.edu>
	5	*
	6	* Permission to use, copy, modify, distribute, and sell this software and
	7	* its documentation for any purpose is hereby granted without fee, provided
	8	* that (i) the above copyright notices and this permission notice appear in
	9	* all copies of the software and related documentation, and (ii) the names of
	10	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	11	* publicity relating to the software without the specific, prior written
	12	* permission of Sam Leffler and Silicon Graphics.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	15	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	16	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	17	*
	18	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	19	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	20	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	21	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	22	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	23	* OF THIS SOFTWARE.
	24	*/
	25
	26	/*
	27	* TIFF Library
	28	*
	29	* Functions to test strip interface of libtiff.
	30	*/
	31
	32	#include <stdio.h>
	33	#include <string.h>
	34
	35	#include "tiffio.h"
	36
	37	int
	38	write_strips(TIFF *tif, const tdata_t array, const tsize_t size)
	39	{
	40	tstrip_t strip, nstrips;
	41	tsize_t stripsize, offset;
	42
	43	stripsize = TIFFStripSize(tif);
	44	if (!stripsize) {
	45	fprintf (stderr, "Wrong size of strip.\n");
	46	return -1;
	47	}
	48
	49	nstrips = TIFFNumberOfStrips(tif);
	50	for (offset = 0, strip = 0;
	51	offset < size && strip < nstrips;
	52	offset+=stripsize, strip++) {
	53	/*
	54	* Properly write last strip.
	55	*/
	56	tsize_t bufsize = size - offset;
	57	if (bufsize > stripsize)
	58	bufsize = stripsize;
	59
	60	if (TIFFWriteEncodedStrip(tif, strip, (char *)array + offset,
	61	bufsize) != bufsize) {
	62	fprintf (stderr, "Can't write strip %lu.\n",
	63	(unsigned long)strip);
	64	return -1;
65	}
66	}
67
68	return 0;
69	}
70
71	int
72	read_strips(TIFF *tif, const tdata_t array, const tsize_t size)
73	{
74	tstrip_t strip, nstrips;
75	tsize_t stripsize, offset;
76	tdata_t buf = NULL;
77
78	stripsize = TIFFStripSize(tif);
79	if (!stripsize) {
80	fprintf (stderr, "Wrong size of strip.\n");
81	return -1;
82	}
83
84	buf = _TIFFmalloc(stripsize);
85	if (!buf) {
86	fprintf (stderr, "Can't allocate space for strip buffer.\n");
87	return -1;
88	}
89
90	nstrips = TIFFNumberOfStrips(tif);
91	for (offset = 0, strip = 0;
92	offset < size && strip < nstrips;
93	offset+=stripsize, strip++) {
94	/*
95	* Properly read last strip.
96	*/
97	tsize_t bufsize = size - offset;
98	if (bufsize > stripsize)
99	bufsize = stripsize;
100
101	if (TIFFReadEncodedStrip(tif, strip, buf, -1) != bufsize) {
102	fprintf (stderr, "Can't read strip %lu.\n",
103	(unsigned long)strip);
104	return -1;
105	}
106	if (memcmp(buf, (char *)array + offset, bufsize) != 0) {
107	fprintf (stderr, "Wrong data read for strip %lu.\n",
108	(unsigned long)strip);
109	_TIFFfree(buf);
110	return -1;
111	}
112	}
113
114	_TIFFfree(buf);
115
116	return 0;
117	}
118
119	int
120	create_image_striped(const char *name, uint32 width, uint32 length,
121	uint32 rowsperstrip, uint16 compression,
122	uint16 spp, uint16 bps, uint16 photometric,
123	uint16 sampleformat, uint16 planarconfig,
124	const tdata_t array, const tsize_t size)
125	{
126	TIFF *tif;
127
128	/* Test whether we can write tags. */
129	tif = TIFFOpen(name, "w");
130	if (!tif)
131	goto openfailure;
132
133	if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width)) {
134	fprintf (stderr, "Can't set ImageWidth tag.\n");
135	goto failure;
136	}
137	if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH, length)) {
138	fprintf (stderr, "Can't set ImageLength tag.\n");
139	goto failure;
140	}
141	if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps)) {
142	fprintf (stderr, "Can't set BitsPerSample tag.\n");
143	goto failure;
144	}
145	if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, spp)) {
146	fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
147	goto failure;
148	}
149	if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip)) {
150	fprintf (stderr, "Can't set RowsPerStrip tag.\n");
151	goto failure;
152	}
153	if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, planarconfig)) {
154	fprintf (stderr, "Can't set PlanarConfiguration tag.\n");
155	goto failure;
156	}
157	if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photometric)) {
158	fprintf (stderr, "Can't set PhotometricInterpretation tag.\n");
159	goto failure;
160	}
161
162	if (write_strips(tif, array, size) < 0) {
163	fprintf (stderr, "Can't write image data.\n");
164	goto failure;
165	}
166
167	TIFFClose(tif);
168	return 0;
169
170	failure:
171	TIFFClose(tif);
172	openfailure:
173	fprintf (stderr, "Can't create test TIFF file %s:\n"
174	" ImageWidth=%ld, ImageLength=%ld, RowsPerStrip=%ld, Compression=%d,\n"
175	" BitsPerSample=%d, SamplesPerPixel=%d, SampleFormat=%d,\n"
176	" PlanarConfiguration=%d, PhotometricInterpretation=%d.\n",
177	name, width, length, rowsperstrip, compression,
178	bps, spp, sampleformat, planarconfig,
179	photometric);
180	return -1;
181	}
182
183	int
184	read_image_striped(const char *name, uint32 width, uint32 length,
185	uint32 rowsperstrip, uint16 compression,
186	uint16 spp, uint16 bps, uint16 photometric,
187	uint16 sampleformat, uint16 planarconfig,
188	const tdata_t array, const tsize_t size)
189	{
190	TIFF *tif;
191	uint16 value_u16;
192	uint32 value_u32;
193
194	/* Test whether we can read written values. */
195	tif = TIFFOpen(name, "r");
196	if (!tif)
197	goto openfailure;
198
199	if (TIFFIsTiled(tif)) {
200	fprintf (stderr, "Can't read image %s, it is tiled.\n",
201	name);
202	goto failure;
203	}
204	if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &value_u32)
205	\|\| value_u32 != width) {
206	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_IMAGEWIDTH);
207	goto failure;
208	}
209	if (!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &value_u32)
210	\|\| value_u32 != length) {
211	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_IMAGELENGTH);
212	goto failure;
213	}
214	if (!TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &value_u16)
215	\|\| value_u16 != bps) {
216	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_BITSPERSAMPLE);
217	goto failure;
218	}
219	if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &value_u16)
220	\|\| value_u16 != photometric) {
221	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_PHOTOMETRIC);
222	goto failure;
223	}
224	if (!TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &value_u16)
225	\|\| value_u16 != spp) {
226	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_SAMPLESPERPIXEL);
227	goto failure;
228	}
229	if (!TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &value_u32)
230	\|\| value_u32 != rowsperstrip) {
231	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_ROWSPERSTRIP);
232	goto failure;
233	}
234	if (!TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &value_u16)
235	\|\| value_u16 != planarconfig) {
236	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_PLANARCONFIG);
237	goto failure;
238	}
239
240	if (read_strips(tif, array, size) < 0) {
241	fprintf (stderr, "Can't read image data.\n");
242	goto failure;
243	}
244
245	TIFFClose(tif);
246	return 0;
247
248	failure:
249	TIFFClose(tif);
250	openfailure:
251	fprintf (stderr, "Can't read test TIFF file %s:\n"
252	" ImageWidth=%ld, ImageLength=%ld, RowsPerStrip=%ld, Compression=%d,\n"
253	" BitsPerSample=%d, SamplesPerPixel=%d, SampleFormat=%d,\n"
254	" PlanarConfiguration=%d, PhotometricInterpretation=%d.\n",
255	name, width, length, rowsperstrip, compression,
256	bps, spp, sampleformat, planarconfig,
257	photometric);
258	return -1;
259	}
260
261	int
262	write_scanlines(TIFF *tif, const tdata_t array, const tsize_t size)
263	{
264	uint32 length, row;
265	tsize_t scanlinesize, offset;
266
267	if (!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &length)) {
268	fprintf (stderr, "Can't get tag %d.\n", TIFFTAG_IMAGELENGTH);
269	return -1;
270	}
271
272	scanlinesize = TIFFScanlineSize(tif);
273	if (!scanlinesize) {
274	fprintf (stderr, "Wrong size of scanline.\n");
275	return -1;
276	}
277
278	for (offset = 0, row = 0; row < length; offset+=scanlinesize, row++) {
279	if (TIFFWriteScanline(tif, (char *)array + offset, row, 0) < 0) {
280	fprintf (stderr,
281	"Can't write image data at row %lu.\n", row);
282	return -1;
283	}
284	}
285
286	return 0;
287	}
288
289	/* vim: set ts=8 sts=8 sw=8 noet: */