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


/*
 * Copyright (c) 2007, Frank Warmerdam <warmerdam@pobox.com>
 *
 * 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
 *
 * Module to test _TIFFRewriteField().
 */

#include "tif_config.h"

#include <stdio.h>

#ifdef HAVE_UNISTD_H 
# include <unistd.h> 
#endif 

#include "tiffio.h"
#include "tiffiop.h"

const uint32	width = 10;
const uint32	length = 40;
const uint32	rows_per_strip = 1;

int test_packbits()

{
    TIFF	    *tif;
    int             i;
    unsigned char   buf[10] = {0,0,0,0,0,0,0,0,0,0};

    int  length = 20;
    const char *filename = "test_packbits.tif";

    /* Test whether we can write tags. */
    tif = TIFFOpen(filename, "w");

    if (!tif) {
        fprintf (stderr, "Can't create test TIFF file %s.\n", filename);
        return 1;
    }

    if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS)) {
        fprintf (stderr, "Can't set Compression tag.\n");
        goto failure;
    }
    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, 8)) {
        fprintf (stderr, "Can't set BitsPerSample tag.\n");
        goto failure;
    }
    if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1)) {
        fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
        goto failure;
    }
    if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rows_per_strip)) {
        fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
        goto failure;
    }
    if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) {
        fprintf (stderr, "Can't set PlanarConfiguration tag.\n");
        goto failure;
    }

    for (i = 0; i < length; i++ )
    {
        if( !TIFFWriteEncodedStrip( tif, i, buf, 10 ) )
        {
            fprintf (stderr, "Can't write image data.\n");
            goto failure;
        }
    }

    TIFFClose(tif);

    /* Test whether we can write tags. */

    tif = TIFFOpen(filename, "r+");

    if (!tif) {
        fprintf (stderr, "Can't create test TIFF file %s.\n", filename);
        return 1;
    }

    buf[3] = 17;
    buf[6] = 12;

    if( !TIFFWriteEncodedStrip( tif, 6, buf, 10 ) )
    {
        fprintf (stderr, "Can't write image data.\n");
        goto failure;
    }

    TIFFClose(tif);

    unlink(filename);

    return 0;

  failure:
    /* Something goes wrong; close file and return unsuccessful status. */
    TIFFClose(tif);
    /*  unlink(filename); */

    return 1;
    
}

/************************************************************************/
/*                            rewrite_test()                            */
/************************************************************************/
int rewrite_test( const char *filename, int length, int bigtiff, 
                  uint64 base_value )

{
    TIFF		*tif;
    int			i;
    unsigned char	buf[10] = {5,6,7,8,9,10,11,12,13,14};
    uint64		*rowoffset, *rowbytes;
    uint64		*upd_rowoffset;
    uint64		*upd_bytecount;

    /* Test whether we can write tags. */
    if( bigtiff )
        tif = TIFFOpen(filename, "w8");
    else
        tif = TIFFOpen(filename, "w4");

    if (!tif) {
        fprintf (stderr, "Can't create test TIFF file %s.\n", filename);
        return 1;
    }

    if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS)) {
        fprintf (stderr, "Can't set Compression tag.\n");
        goto failure;
    }
    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, 8)) {
        fprintf (stderr, "Can't set BitsPerSample tag.\n");
        goto failure;
    }
    if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1)) {
        fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
        goto failure;
    }
    if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rows_per_strip)) {
        fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
        goto failure;
    }
    if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) {
        fprintf (stderr, "Can't set PlanarConfiguration tag.\n");
        goto failure;
    }

    for (i = 0; i < length; i++ )
    {
        if( !TIFFWriteScanline( tif, buf, i, 0 ) )
        {
            fprintf (stderr, "Can't write image data.\n");
            goto failure;
        }
    }

    TIFFClose(tif);
	
    /* Ok, now test whether we can read written values. */
    tif = TIFFOpen(filename, "r+");
    if (!tif) {
        fprintf (stderr, "Can't open test TIFF file %s.\n", filename);
        return 1;
    }
        
    if( !TIFFGetField( tif, TIFFTAG_STRIPOFFSETS, &rowoffset ) )
    {
        fprintf (stderr, "Can't fetch STRIPOFFSETS.\n");
        goto failure;
    }
        
    if( !TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &rowbytes ) )
    {
        fprintf (stderr, "Can't fetch STRIPBYTECOUNTS.\n");
        goto failure;
    }

    upd_rowoffset = (uint64 *) _TIFFmalloc(sizeof(uint64) * length);
    for( i = 0; i < length; i++ )
        upd_rowoffset[i] = base_value + i*10;

    if( !_TIFFRewriteField( tif, TIFFTAG_STRIPOFFSETS, TIFF_LONG8, 
                            length, upd_rowoffset ) )
    {
        fprintf (stderr, "Can't rewrite STRIPOFFSETS.\n");
        goto failure;
    }

    _TIFFfree( upd_rowoffset );

    upd_bytecount = (uint64 *) _TIFFmalloc(sizeof(uint64) * length);
    for( i = 0; i < length; i++ )
        upd_bytecount[i] = 100 + i*10;

    if( !_TIFFRewriteField( tif, TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG8, 
                            length, upd_bytecount ) )
    {
        fprintf (stderr, "Can't rewrite STRIPBYTECOUNTS.\n");
        goto failure;
    }

    _TIFFfree( upd_bytecount );

    TIFFClose(tif);

    /* Reopen file and read back to verify contents */

    tif = TIFFOpen(filename, "r");
    if (!tif) {
        fprintf (stderr, "Can't open test TIFF file %s.\n", filename);
        return 1;
    }
        
    if( !TIFFGetField( tif, TIFFTAG_STRIPOFFSETS, &rowoffset ) )
    {
        fprintf (stderr, "Can't fetch STRIPOFFSETS.\n");
        goto failure;
    }
        
    for( i = 0; i < length; i++ )
    {
        uint64 expect = base_value + i*10;

        if( rowoffset[i] != expect )
        {
            fprintf( stderr, 
                     "%s:STRIPOFFSETS[%d]: Got %X:%08X instead of %X:%08X.\n",
                     filename, i, 
                     (int) (rowoffset[i] >> 32), 
                     (int) (rowoffset[i]&0xFFFFFFFF), 
                     (int) (expect >> 32), 
                     (int) (expect & 0xFFFFFFFF) );
            goto failure;
        }
    }

    if( !TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &rowbytes ) )
    {
        fprintf (stderr, "Can't fetch STRIPBYTECOUNTS.\n");
        goto failure;
    }
        
    for( i = 0; i < length; i++ )
    {
        uint64 expect = 100 + i*10;

        if( rowbytes[i] != expect )
        {
            fprintf( stderr, 
                     "%s:STRIPBYTECOUNTS[%d]: Got %X:%08X instead of %X:%08X.\n",
                     filename, i, 
                     (int) (rowbytes[i] >> 32), 
                     (int) (rowbytes[i] & 0xFFFFFFFF), 
                     (int) (expect >> 32), 
                     (int) (expect & 0xFFFFFFFF) );
            goto failure;
        }
    }

    TIFFClose( tif );

    /* All tests passed; delete file and exit with success status. */
    unlink(filename);
    return 0;

  failure:
    /* Something goes wrong; close file and return unsuccessful status. */
    TIFFClose(tif);
    /*  unlink(filename); */

    return 1;
    
}

/************************************************************************/
/*                                main()                                */
/************************************************************************/
int
main(int argc, char **argv)
{
    (void) argc;
    (void) argv;
    int failure = 0;

    failure |= test_packbits();

    /* test fairly normal use */
    failure |= rewrite_test( "rewrite1.tif", 10, 0, 100 );
    failure |= rewrite_test( "rewrite2.tif", 10, 1, 100 );

    /* test case of fitting all in directory entry */
    failure |= rewrite_test( "rewrite3.tif", 1, 0, 100 );
    failure |= rewrite_test( "rewrite4.tif", 1, 1, 100 );

    /* test with very large values that don't fit in 4bytes (bigtiff only) */
    failure |= rewrite_test( "rewrite5.tif", 1000, 1, 0x6000000000ULL );
    failure |= rewrite_test( "rewrite6.tif", 1, 1, 0x6000000000ULL );

    return failure;
}

/* vim: set ts=8 sts=8 sw=8 noet: */
Commit	Line	Data
80ed523f VZ	1
	2	/*
	3	* Copyright (c) 2007, Frank Warmerdam <warmerdam@pobox.com>
	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	* Module to test _TIFFRewriteField().
	29	*/
	30
	31	#include "tif_config.h"
	32
	33	#include <stdio.h>
	34
	35	#ifdef HAVE_UNISTD_H
	36	# include <unistd.h>
	37	#endif
	38
	39	#include "tiffio.h"
	40	#include "tiffiop.h"
	41
	42	const uint32 width = 10;
	43	const uint32 length = 40;
	44	const uint32 rows_per_strip = 1;
	45
	46	int test_packbits()
	47
	48	{
	49	TIFF *tif;
	50	int i;
	51	unsigned char buf[10] = {0,0,0,0,0,0,0,0,0,0};
	52
	53	int length = 20;
	54	const char *filename = "test_packbits.tif";
	55
	56	/* Test whether we can write tags. */
	57	tif = TIFFOpen(filename, "w");
	58
	59	if (!tif) {
	60	fprintf (stderr, "Can't create test TIFF file %s.\n", filename);
	61	return 1;
	62	}
	63
	64	if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS)) {
65	fprintf (stderr, "Can't set Compression tag.\n");
66	goto failure;
67	}
68	if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width)) {
69	fprintf (stderr, "Can't set ImageWidth tag.\n");
70	goto failure;
71	}
72	if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH, length)) {
73	fprintf (stderr, "Can't set ImageLength tag.\n");
74	goto failure;
75	}
76	if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8)) {
77	fprintf (stderr, "Can't set BitsPerSample tag.\n");
78	goto failure;
79	}
80	if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1)) {
81	fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
82	goto failure;
83	}
84	if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rows_per_strip)) {
85	fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
86	goto failure;
87	}
88	if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) {
89	fprintf (stderr, "Can't set PlanarConfiguration tag.\n");
90	goto failure;
91	}
92
93	for (i = 0; i < length; i++ )
94	{
95	if( !TIFFWriteEncodedStrip( tif, i, buf, 10 ) )
96	{
97	fprintf (stderr, "Can't write image data.\n");
98	goto failure;
99	}
100	}
101
102	TIFFClose(tif);
103
104	/* Test whether we can write tags. */
105
106	tif = TIFFOpen(filename, "r+");
107
108	if (!tif) {
109	fprintf (stderr, "Can't create test TIFF file %s.\n", filename);
110	return 1;
111	}
112
113	buf[3] = 17;
114	buf[6] = 12;
115
116	if( !TIFFWriteEncodedStrip( tif, 6, buf, 10 ) )
117	{
118	fprintf (stderr, "Can't write image data.\n");
119	goto failure;
120	}
121
122	TIFFClose(tif);
123
124	unlink(filename);
125
126	return 0;
127
128	failure:
129	/* Something goes wrong; close file and return unsuccessful status. */
130	TIFFClose(tif);
131	/* unlink(filename); */
132
133	return 1;
134
135	}
136
137	/************************************************************************/
138	/* rewrite_test() */
139	/************************************************************************/
140	int rewrite_test( const char *filename, int length, int bigtiff,
141	uint64 base_value )
142
143	{
144	TIFF *tif;
145	int i;
146	unsigned char buf[10] = {5,6,7,8,9,10,11,12,13,14};
147	uint64 rowoffset, rowbytes;
148	uint64 *upd_rowoffset;
149	uint64 *upd_bytecount;
150
151	/* Test whether we can write tags. */
152	if( bigtiff )
153	tif = TIFFOpen(filename, "w8");
154	else
155	tif = TIFFOpen(filename, "w4");
156
157	if (!tif) {
158	fprintf (stderr, "Can't create test TIFF file %s.\n", filename);
159	return 1;
160	}
161
162	if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS)) {
163	fprintf (stderr, "Can't set Compression tag.\n");
164	goto failure;
165	}
166	if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width)) {
167	fprintf (stderr, "Can't set ImageWidth tag.\n");
168	goto failure;
169	}
170	if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH, length)) {
171	fprintf (stderr, "Can't set ImageLength tag.\n");
172	goto failure;
173	}
174	if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8)) {
175	fprintf (stderr, "Can't set BitsPerSample tag.\n");
176	goto failure;
177	}
178	if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1)) {
179	fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
180	goto failure;
181	}
182	if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rows_per_strip)) {
183	fprintf (stderr, "Can't set SamplesPerPixel tag.\n");
184	goto failure;
185	}
186	if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) {
187	fprintf (stderr, "Can't set PlanarConfiguration tag.\n");
188	goto failure;
189	}
190
191	for (i = 0; i < length; i++ )
192	{
193	if( !TIFFWriteScanline( tif, buf, i, 0 ) )
194	{
195	fprintf (stderr, "Can't write image data.\n");
196	goto failure;
197	}
198	}
199
200	TIFFClose(tif);
201
202	/* Ok, now test whether we can read written values. */
203	tif = TIFFOpen(filename, "r+");
204	if (!tif) {
205	fprintf (stderr, "Can't open test TIFF file %s.\n", filename);
206	return 1;
207	}
208
209	if( !TIFFGetField( tif, TIFFTAG_STRIPOFFSETS, &rowoffset ) )
210	{
211	fprintf (stderr, "Can't fetch STRIPOFFSETS.\n");
212	goto failure;
213	}
214
215	if( !TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &rowbytes ) )
216	{
217	fprintf (stderr, "Can't fetch STRIPBYTECOUNTS.\n");
218	goto failure;
219	}
220
221	upd_rowoffset = (uint64 ) _TIFFmalloc(sizeof(uint64) length);
222	for( i = 0; i < length; i++ )
223	upd_rowoffset[i] = base_value + i*10;
224
225	if( !_TIFFRewriteField( tif, TIFFTAG_STRIPOFFSETS, TIFF_LONG8,
226	length, upd_rowoffset ) )
227	{
228	fprintf (stderr, "Can't rewrite STRIPOFFSETS.\n");
229	goto failure;
230	}
231
232	_TIFFfree( upd_rowoffset );
233
234	upd_bytecount = (uint64 ) _TIFFmalloc(sizeof(uint64) length);
235	for( i = 0; i < length; i++ )
236	upd_bytecount[i] = 100 + i*10;
237
238	if( !_TIFFRewriteField( tif, TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG8,
239	length, upd_bytecount ) )
240	{
241	fprintf (stderr, "Can't rewrite STRIPBYTECOUNTS.\n");
242	goto failure;
243	}
244
245	_TIFFfree( upd_bytecount );
246
247	TIFFClose(tif);
248
249	/* Reopen file and read back to verify contents */
250
251	tif = TIFFOpen(filename, "r");
252	if (!tif) {
253	fprintf (stderr, "Can't open test TIFF file %s.\n", filename);
254	return 1;
255	}
256
257	if( !TIFFGetField( tif, TIFFTAG_STRIPOFFSETS, &rowoffset ) )
258	{
259	fprintf (stderr, "Can't fetch STRIPOFFSETS.\n");
260	goto failure;
261	}
262
263	for( i = 0; i < length; i++ )
264	{
265	uint64 expect = base_value + i*10;
266
267	if( rowoffset[i] != expect )
268	{
269	fprintf( stderr,
270	"%s:STRIPOFFSETS[%d]: Got %X:%08X instead of %X:%08X.\n",
271	filename, i,
272	(int) (rowoffset[i] >> 32),
273	(int) (rowoffset[i]&0xFFFFFFFF),
274	(int) (expect >> 32),
275	(int) (expect & 0xFFFFFFFF) );
276	goto failure;
277	}
278	}
279
280	if( !TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &rowbytes ) )
281	{
282	fprintf (stderr, "Can't fetch STRIPBYTECOUNTS.\n");
283	goto failure;
284	}
285
286	for( i = 0; i < length; i++ )
287	{
288	uint64 expect = 100 + i*10;
289
290	if( rowbytes[i] != expect )
291	{
292	fprintf( stderr,
293	"%s:STRIPBYTECOUNTS[%d]: Got %X:%08X instead of %X:%08X.\n",
294	filename, i,
295	(int) (rowbytes[i] >> 32),
296	(int) (rowbytes[i] & 0xFFFFFFFF),
297	(int) (expect >> 32),
298	(int) (expect & 0xFFFFFFFF) );
299	goto failure;
300	}
301	}
302
303	TIFFClose( tif );
304
305	/* All tests passed; delete file and exit with success status. */
306	unlink(filename);
307	return 0;
308
309	failure:
310	/* Something goes wrong; close file and return unsuccessful status. */
311	TIFFClose(tif);
312	/* unlink(filename); */
313
314	return 1;
315
316	}
317
318	/************************************************************************/
319	/* main() */
320	/************************************************************************/
321	int
322	main(int argc, char **argv)
323	{
324	(void) argc;
325	(void) argv;
326	int failure = 0;
327
328	failure \|= test_packbits();
329
330	/* test fairly normal use */
331	failure \|= rewrite_test( "rewrite1.tif", 10, 0, 100 );
332	failure \|= rewrite_test( "rewrite2.tif", 10, 1, 100 );
333
334	/* test case of fitting all in directory entry */
335	failure \|= rewrite_test( "rewrite3.tif", 1, 0, 100 );
336	failure \|= rewrite_test( "rewrite4.tif", 1, 1, 100 );
337
338	/* test with very large values that don't fit in 4bytes (bigtiff only) */
339	failure \|= rewrite_test( "rewrite5.tif", 1000, 1, 0x6000000000ULL );
340	failure \|= rewrite_test( "rewrite6.tif", 1, 1, 0x6000000000ULL );
341
342	return failure;
343	}
344
345	/* vim: set ts=8 sts=8 sw=8 noet: */