Mercurial > fife-parpg

comparison ext/libpng-1.2.29/pngtest.c @ 0:4a0efb7baf70

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* Datasets becomes the new trunk and retires after that :-)
author mvbarracuda@33b003aa-7bff-0310-803a-e67f0ece8222
date Sun, 29 Jun 2008 18:44:17 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4a0efb7baf70
1
2 /* pngtest.c - a simple test program to test libpng
3 *
4 * Last changed in libpng 1.2.27 - [April 29, 2008]
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1998-2008 Glenn Randers-Pehrson
7 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
8 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9 *
10 * This program reads in a PNG image, writes it out again, and then
11 * compares the two files. If the files are identical, this shows that
12 * the basic chunk handling, filtering, and (de)compression code is working
13 * properly. It does not currently test all of the transforms, although
14 * it probably should.
15 *
16 * The program will report "FAIL" in certain legitimate cases:
17 * 1) when the compression level or filter selection method is changed.
18 * 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192.
19 * 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks
20 * exist in the input file.
21 * 4) others not listed here...
22 * In these cases, it is best to check with another tool such as "pngcheck"
23 * to see what the differences between the two files are.
24 *
25 * If a filename is given on the command-line, then this file is used
26 * for the input, rather than the default "pngtest.png". This allows
27 * testing a wide variety of files easily. You can also test a number
28 * of files at once by typing "pngtest -m file1.png file2.png ..."
29 */
30
31 #include "png.h"
32
33 #if defined(_WIN32_WCE)
34 # if _WIN32_WCE < 211
35 __error__ (f|w)printf functions are not supported on old WindowsCE.;
36 # endif
37 # include <windows.h>
38 # include <stdlib.h>
39 # define READFILE(file, data, length, check) \
40 if (ReadFile(file, data, length, &check,NULL)) check = 0
41 # define WRITEFILE(file, data, length, check)) \
42 if (WriteFile(file, data, length, &check, NULL)) check = 0
43 # define FCLOSE(file) CloseHandle(file)
44 #else
45 # include <stdio.h>
46 # include <stdlib.h>
47 # define READFILE(file, data, length, check) \
48 check=(png_size_t)fread(data,(png_size_t)1,length,file)
49 # define WRITEFILE(file, data, length, check) \
50 check=(png_size_t)fwrite(data,(png_size_t)1, length, file)
51 # define FCLOSE(file) fclose(file)
52 #endif
53
54 #if defined(PNG_NO_STDIO)
55 # if defined(_WIN32_WCE)
56 typedef HANDLE png_FILE_p;
57 # else
58 typedef FILE * png_FILE_p;
59 # endif
60 #endif
61
62 /* Makes pngtest verbose so we can find problems (needs to be before png.h) */
63 #ifndef PNG_DEBUG
64 # define PNG_DEBUG 0
65 #endif
66
67 #if !PNG_DEBUG
68 # define SINGLE_ROWBUF_ALLOC /* makes buffer overruns easier to nail */
69 #endif
70
71 /* Turn on CPU timing
72 #define PNGTEST_TIMING
73 */
74
75 #ifdef PNG_NO_FLOATING_POINT_SUPPORTED
76 #undef PNGTEST_TIMING
77 #endif
78
79 #ifdef PNGTEST_TIMING
80 static float t_start, t_stop, t_decode, t_encode, t_misc;
81 #include <time.h>
82 #endif
83
84 #if defined(PNG_TIME_RFC1123_SUPPORTED)
85 #define PNG_tIME_STRING_LENGTH 30
86 static int tIME_chunk_present=0;
87 static char tIME_string[PNG_tIME_STRING_LENGTH] = "no tIME chunk present in file";
88 #endif
89
90 static int verbose = 0;
91
92 int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
93
94 #ifdef __TURBOC__
95 #include <mem.h>
96 #endif
97
98 /* defined so I can write to a file on gui/windowing platforms */
99 /* #define STDERR stderr */
100 #define STDERR stdout /* for DOS */
101
102 /* example of using row callbacks to make a simple progress meter */
103 static int status_pass=1;
104 static int status_dots_requested=0;
105 static int status_dots=1;
106
107 /* In case a system header (e.g., on AIX) defined jmpbuf */
108 #ifdef jmpbuf
109 # undef jmpbuf
110 #endif
111
112 /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
113 #ifndef png_jmpbuf
114 # define png_jmpbuf(png_ptr) png_ptr->jmpbuf
115 #endif
116
117 void
118 #ifdef PNG_1_0_X
119 PNGAPI
120 #endif
121 read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
122 void
123 #ifdef PNG_1_0_X
124 PNGAPI
125 #endif
126 read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
127 {
128 if(png_ptr == NULL || row_number > PNG_UINT_31_MAX) return;
129 if(status_pass != pass)
130 {
131 fprintf(stdout,"\n Pass %d: ",pass);
132 status_pass = pass;
133 status_dots = 31;
134 }
135 status_dots--;
136 if(status_dots == 0)
137 {
138 fprintf(stdout, "\n ");
139 status_dots=30;
140 }
141 fprintf(stdout, "r");
142 }
143
144 void
145 #ifdef PNG_1_0_X
146 PNGAPI
147 #endif
148 write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
149 void
150 #ifdef PNG_1_0_X
151 PNGAPI
152 #endif
153 write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
154 {
155 if(png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7) return;
156 fprintf(stdout, "w");
157 }
158
159
160 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
161 /* Example of using user transform callback (we don't transform anything,
162 but merely examine the row filters. We set this to 256 rather than
163 5 in case illegal filter values are present.) */
164 static png_uint_32 filters_used[256];
165 void
166 #ifdef PNG_1_0_X
167 PNGAPI
168 #endif
169 count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data);
170 void
171 #ifdef PNG_1_0_X
172 PNGAPI
173 #endif
174 count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
175 {
176 if(png_ptr != NULL && row_info != NULL)
177 ++filters_used[*(data-1)];
178 }
179 #endif
180
181 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
182 /* example of using user transform callback (we don't transform anything,
183 but merely count the zero samples) */
184
185 static png_uint_32 zero_samples;
186
187 void
188 #ifdef PNG_1_0_X
189 PNGAPI
190 #endif
191 count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data);
192 void
193 #ifdef PNG_1_0_X
194 PNGAPI
195 #endif
196 count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
197 {
198 png_bytep dp = data;
199 if(png_ptr == NULL)return;
200
201 /* contents of row_info:
202 * png_uint_32 width width of row
203 * png_uint_32 rowbytes number of bytes in row
204 * png_byte color_type color type of pixels
205 * png_byte bit_depth bit depth of samples
206 * png_byte channels number of channels (1-4)
207 * png_byte pixel_depth bits per pixel (depth*channels)
208 */
209
210
211 /* counts the number of zero samples (or zero pixels if color_type is 3 */
212
213 if(row_info->color_type == 0 || row_info->color_type == 3)
214 {
215 int pos=0;
216 png_uint_32 n, nstop;
217 for (n=0, nstop=row_info->width; n<nstop; n++)
218 {
219 if(row_info->bit_depth == 1)
220 {
221 if(((*dp << pos++ ) & 0x80) == 0) zero_samples++;
222 if(pos == 8)
223 {
224 pos = 0;
225 dp++;
226 }
227 }
228 if(row_info->bit_depth == 2)
229 {
230 if(((*dp << (pos+=2)) & 0xc0) == 0) zero_samples++;
231 if(pos == 8)
232 {
233 pos = 0;
234 dp++;
235 }
236 }
237 if(row_info->bit_depth == 4)
238 {
239 if(((*dp << (pos+=4)) & 0xf0) == 0) zero_samples++;
240 if(pos == 8)
241 {
242 pos = 0;
243 dp++;
244 }
245 }
246 if(row_info->bit_depth == 8)
247 if(*dp++ == 0) zero_samples++;
248 if(row_info->bit_depth == 16)
249 {
250 if((*dp | *(dp+1)) == 0) zero_samples++;
251 dp+=2;
252 }
253 }
254 }
255 else /* other color types */
256 {
257 png_uint_32 n, nstop;
258 int channel;
259 int color_channels = row_info->channels;
260 if(row_info->color_type > 3)color_channels--;
261
262 for (n=0, nstop=row_info->width; n<nstop; n++)
263 {
264 for (channel = 0; channel < color_channels; channel++)
265 {
266 if(row_info->bit_depth == 8)
267 if(*dp++ == 0) zero_samples++;
268 if(row_info->bit_depth == 16)
269 {
270 if((*dp | *(dp+1)) == 0) zero_samples++;
271 dp+=2;
272 }
273 }
274 if(row_info->color_type > 3)
275 {
276 dp++;
277 if(row_info->bit_depth == 16)dp++;
278 }
279 }
280 }
281 }
282 #endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */
283
284 static int wrote_question = 0;
285
286 #if defined(PNG_NO_STDIO)
287 /* START of code to validate stdio-free compilation */
288 /* These copies of the default read/write functions come from pngrio.c and */
289 /* pngwio.c. They allow "don't include stdio" testing of the library. */
290 /* This is the function that does the actual reading of data. If you are
291 not reading from a standard C stream, you should create a replacement
292 read_data function and use it at run time with png_set_read_fn(), rather
293 than changing the library. */
294
295 #ifndef USE_FAR_KEYWORD
296 static void
297 pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
298 {
299 png_size_t check;
300
301 /* fread() returns 0 on error, so it is OK to store this in a png_size_t
302 * instead of an int, which is what fread() actually returns.
303 */
304 READFILE((png_FILE_p)png_ptr->io_ptr, data, length, check);
305
306 if (check != length)
307 {
308 png_error(png_ptr, "Read Error!");
309 }
310 }
311 #else
312 /* this is the model-independent version. Since the standard I/O library
313 can't handle far buffers in the medium and small models, we have to copy
314 the data.
315 */
316
317 #define NEAR_BUF_SIZE 1024
318 #define MIN(a,b) (a <= b ? a : b)
319
320 static void
321 pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
322 {
323 int check;
324 png_byte *n_data;
325 png_FILE_p io_ptr;
326
327 /* Check if data really is near. If so, use usual code. */
328 n_data = (png_byte *)CVT_PTR_NOCHECK(data);
329 io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
330 if ((png_bytep)n_data == data)
331 {
332 READFILE(io_ptr, n_data, length, check);
333 }
334 else
335 {
336 png_byte buf[NEAR_BUF_SIZE];
337 png_size_t read, remaining, err;
338 check = 0;
339 remaining = length;
340 do
341 {
342 read = MIN(NEAR_BUF_SIZE, remaining);
343 READFILE(io_ptr, buf, 1, err);
344 png_memcpy(data, buf, read); /* copy far buffer to near buffer */
345 if(err != read)
346 break;
347 else
348 check += err;
349 data += read;
350 remaining -= read;
351 }
352 while (remaining != 0);
353 }
354 if (check != length)
355 {
356 png_error(png_ptr, "read Error");
357 }
358 }
359 #endif /* USE_FAR_KEYWORD */
360
361 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
362 static void
363 pngtest_flush(png_structp png_ptr)
364 {
365 #if !defined(_WIN32_WCE)
366 png_FILE_p io_ptr;
367 io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
368 if (io_ptr != NULL)
369 fflush(io_ptr);
370 #endif
371 }
372 #endif
373
374 /* This is the function that does the actual writing of data. If you are
375 not writing to a standard C stream, you should create a replacement
376 write_data function and use it at run time with png_set_write_fn(), rather
377 than changing the library. */
378 #ifndef USE_FAR_KEYWORD
379 static void
380 pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
381 {
382 png_uint_32 check;
383
384 WRITEFILE((png_FILE_p)png_ptr->io_ptr, data, length, check);
385 if (check != length)
386 {
387 png_error(png_ptr, "Write Error");
388 }
389 }
390 #else
391 /* this is the model-independent version. Since the standard I/O library
392 can't handle far buffers in the medium and small models, we have to copy
393 the data.
394 */
395
396 #define NEAR_BUF_SIZE 1024
397 #define MIN(a,b) (a <= b ? a : b)
398
399 static void
400 pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
401 {
402 png_uint_32 check;
403 png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
404 png_FILE_p io_ptr;
405
406 /* Check if data really is near. If so, use usual code. */
407 near_data = (png_byte *)CVT_PTR_NOCHECK(data);
408 io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
409 if ((png_bytep)near_data == data)
410 {
411 WRITEFILE(io_ptr, near_data, length, check);
412 }
413 else
414 {
415 png_byte buf[NEAR_BUF_SIZE];
416 png_size_t written, remaining, err;
417 check = 0;
418 remaining = length;
419 do
420 {
421 written = MIN(NEAR_BUF_SIZE, remaining);
422 png_memcpy(buf, data, written); /* copy far buffer to near buffer */
423 WRITEFILE(io_ptr, buf, written, err);
424 if (err != written)
425 break;
426 else
427 check += err;
428 data += written;
429 remaining -= written;
430 }
431 while (remaining != 0);
432 }
433 if (check != length)
434 {
435 png_error(png_ptr, "Write Error");
436 }
437 }
438 #endif /* USE_FAR_KEYWORD */
439 #endif /* PNG_NO_STDIO */
440 /* END of code to validate stdio-free compilation */
441
442 /* This function is called when there is a warning, but the library thinks
443 * it can continue anyway. Replacement functions don't have to do anything
444 * here if you don't want to. In the default configuration, png_ptr is
445 * not used, but it is passed in case it may be useful.
446 */
447 static void
448 pngtest_warning(png_structp png_ptr, png_const_charp message)
449 {
450 PNG_CONST char *name = "UNKNOWN (ERROR!)";
451 if (png_ptr != NULL && png_ptr->error_ptr != NULL)
452 name = png_ptr->error_ptr;
453 fprintf(STDERR, "%s: libpng warning: %s\n", name, message);
454 }
455
456 /* This is the default error handling function. Note that replacements for
457 * this function MUST NOT RETURN, or the program will likely crash. This
458 * function is used by default, or if the program supplies NULL for the
459 * error function pointer in png_set_error_fn().
460 */
461 static void
462 pngtest_error(png_structp png_ptr, png_const_charp message)
463 {
464 pngtest_warning(png_ptr, message);
465 /* We can return because png_error calls the default handler, which is
466 * actually OK in this case. */
467 }
468
469 /* START of code to validate memory allocation and deallocation */
470 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
471
472 /* Allocate memory. For reasonable files, size should never exceed
473 64K. However, zlib may allocate more then 64K if you don't tell
474 it not to. See zconf.h and png.h for more information. zlib does
475 need to allocate exactly 64K, so whatever you call here must
476 have the ability to do that.
477
478 This piece of code can be compiled to validate max 64K allocations
479 by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */
480 typedef struct memory_information
481 {
482 png_uint_32 size;
483 png_voidp pointer;
484 struct memory_information FAR *next;
485 } memory_information;
486 typedef memory_information FAR *memory_infop;
487
488 static memory_infop pinformation = NULL;
489 static int current_allocation = 0;
490 static int maximum_allocation = 0;
491 static int total_allocation = 0;
492 static int num_allocations = 0;
493
494 png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size));
495 void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));
496
497 png_voidp
498 png_debug_malloc(png_structp png_ptr, png_uint_32 size)
499 {
500
501 /* png_malloc has already tested for NULL; png_create_struct calls
502 png_debug_malloc directly, with png_ptr == NULL which is OK */
503
504 if (size == 0)
505 return (NULL);
506
507 /* This calls the library allocator twice, once to get the requested
508 buffer and once to get a new free list entry. */
509 {
510 /* Disable malloc_fn and free_fn */
511 memory_infop pinfo;
512 png_set_mem_fn(png_ptr, NULL, NULL, NULL);
513 pinfo = (memory_infop)png_malloc(png_ptr,
514 (png_uint_32)png_sizeof (*pinfo));
515 pinfo->size = size;
516 current_allocation += size;
517 total_allocation += size;
518 num_allocations ++;
519 if (current_allocation > maximum_allocation)
520 maximum_allocation = current_allocation;
521 pinfo->pointer = (png_voidp)png_malloc(png_ptr, size);
522 /* Restore malloc_fn and free_fn */
523 png_set_mem_fn(png_ptr, png_voidp_NULL, (png_malloc_ptr)png_debug_malloc,
524 (png_free_ptr)png_debug_free);
525 if (size != 0 && pinfo->pointer == NULL)
526 {
527 current_allocation -= size;
528 total_allocation -= size;
529 png_error(png_ptr,
530 "out of memory in pngtest->png_debug_malloc.");
531 }
532 pinfo->next = pinformation;
533 pinformation = pinfo;
534 /* Make sure the caller isn't assuming zeroed memory. */
535 png_memset(pinfo->pointer, 0xdd, pinfo->size);
536 if(verbose)
537 printf("png_malloc %lu bytes at %x\n",(unsigned long)size,
538 pinfo->pointer);
539 return (png_voidp)(pinfo->pointer);
540 }
541 }
542
543 /* Free a pointer. It is removed from the list at the same time. */
544 void
545 png_debug_free(png_structp png_ptr, png_voidp ptr)
546 {
547 if (png_ptr == NULL)
548 fprintf(STDERR, "NULL pointer to png_debug_free.\n");
549 if (ptr == 0)
550 {
551 #if 0 /* This happens all the time. */
552 fprintf(STDERR, "WARNING: freeing NULL pointer\n");
553 #endif
554 return;
555 }
556
557 /* Unlink the element from the list. */
558 {
559 memory_infop FAR *ppinfo = &pinformation;
560 for (;;)
561 {
562 memory_infop pinfo = *ppinfo;
563 if (pinfo->pointer == ptr)
564 {
565 *ppinfo = pinfo->next;
566 current_allocation -= pinfo->size;
567 if (current_allocation < 0)
568 fprintf(STDERR, "Duplicate free of memory\n");
569 /* We must free the list element too, but first kill
570 the memory that is to be freed. */
571 png_memset(ptr, 0x55, pinfo->size);
572 png_free_default(png_ptr, pinfo);
573 pinfo=NULL;
574 break;
575 }
576 if (pinfo->next == NULL)
577 {
578 fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);
579 break;
580 }
581 ppinfo = &pinfo->next;
582 }
583 }
584
585 /* Finally free the data. */
586 if(verbose)
587 printf("Freeing %x\n",ptr);
588 png_free_default(png_ptr, ptr);
589 ptr=NULL;
590 }
591 #endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */
592 /* END of code to test memory allocation/deallocation */
593
594 /* Test one file */
595 int
596 test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
597 {
598 static png_FILE_p fpin;
599 static png_FILE_p fpout; /* "static" prevents setjmp corruption */
600 png_structp read_ptr;
601 png_infop read_info_ptr, end_info_ptr;
602 #ifdef PNG_WRITE_SUPPORTED
603 png_structp write_ptr;
604 png_infop write_info_ptr;
605 png_infop write_end_info_ptr;
606 #else
607 png_structp write_ptr = NULL;
608 png_infop write_info_ptr = NULL;
609 png_infop write_end_info_ptr = NULL;
610 #endif
611 png_bytep row_buf;
612 png_uint_32 y;
613 png_uint_32 width, height;
614 int num_pass, pass;
615 int bit_depth, color_type;
616 #ifdef PNG_SETJMP_SUPPORTED
617 #ifdef USE_FAR_KEYWORD
618 jmp_buf jmpbuf;
619 #endif
620 #endif
621
622 #if defined(_WIN32_WCE)
623 TCHAR path[MAX_PATH];
624 #endif
625 char inbuf[256], outbuf[256];
626
627 row_buf = NULL;
628
629 #if defined(_WIN32_WCE)
630 MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);
631 if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
632 #else
633 if ((fpin = fopen(inname, "rb")) == NULL)
634 #endif
635 {
636 fprintf(STDERR, "Could not find input file %s\n", inname);
637 return (1);
638 }
639
640 #if defined(_WIN32_WCE)
641 MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);
642 if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)
643 #else
644 if ((fpout = fopen(outname, "wb")) == NULL)
645 #endif
646 {
647 fprintf(STDERR, "Could not open output file %s\n", outname);
648 FCLOSE(fpin);
649 return (1);
650 }
651
652 png_debug(0, "Allocating read and write structures\n");
653 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
654 read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
655 png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,
656 (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
657 #else
658 read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
659 png_error_ptr_NULL, png_error_ptr_NULL);
660 #endif
661 png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,
662 pngtest_warning);
663 #ifdef PNG_WRITE_SUPPORTED
664 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
665 write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
666 png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,
667 (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
668 #else
669 write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
670 png_error_ptr_NULL, png_error_ptr_NULL);
671 #endif
672 png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,
673 pngtest_warning);
674 #endif
675 png_debug(0, "Allocating read_info, write_info and end_info structures\n");
676 read_info_ptr = png_create_info_struct(read_ptr);
677 end_info_ptr = png_create_info_struct(read_ptr);
678 #ifdef PNG_WRITE_SUPPORTED
679 write_info_ptr = png_create_info_struct(write_ptr);
680 write_end_info_ptr = png_create_info_struct(write_ptr);
681 #endif
682
683 #ifdef PNG_SETJMP_SUPPORTED
684 png_debug(0, "Setting jmpbuf for read struct\n");
685 #ifdef USE_FAR_KEYWORD
686 if (setjmp(jmpbuf))
687 #else
688 if (setjmp(png_jmpbuf(read_ptr)))
689 #endif
690 {
691 fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
692 png_free(read_ptr, row_buf);
693 png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
694 #ifdef PNG_WRITE_SUPPORTED
695 png_destroy_info_struct(write_ptr, &write_end_info_ptr);
696 png_destroy_write_struct(&write_ptr, &write_info_ptr);
697 #endif
698 FCLOSE(fpin);
699 FCLOSE(fpout);
700 return (1);
701 }
702 #ifdef USE_FAR_KEYWORD
703 png_memcpy(png_jmpbuf(read_ptr),jmpbuf,png_sizeof(jmp_buf));
704 #endif
705
706 #ifdef PNG_WRITE_SUPPORTED
707 png_debug(0, "Setting jmpbuf for write struct\n");
708 #ifdef USE_FAR_KEYWORD
709 if (setjmp(jmpbuf))
710 #else
711 if (setjmp(png_jmpbuf(write_ptr)))
712 #endif
713 {
714 fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
715 png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
716 png_destroy_info_struct(write_ptr, &write_end_info_ptr);
717 #ifdef PNG_WRITE_SUPPORTED
718 png_destroy_write_struct(&write_ptr, &write_info_ptr);
719 #endif
720 FCLOSE(fpin);
721 FCLOSE(fpout);
722 return (1);
723 }
724 #ifdef USE_FAR_KEYWORD
725 png_memcpy(png_jmpbuf(write_ptr),jmpbuf,png_sizeof(jmp_buf));
726 #endif
727 #endif
728 #endif
729
730 png_debug(0, "Initializing input and output streams\n");
731 #if !defined(PNG_NO_STDIO)
732 png_init_io(read_ptr, fpin);
733 # ifdef PNG_WRITE_SUPPORTED
734 png_init_io(write_ptr, fpout);
735 # endif
736 #else
737 png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);
738 # ifdef PNG_WRITE_SUPPORTED
739 png_set_write_fn(write_ptr, (png_voidp)fpout, pngtest_write_data,
740 # if defined(PNG_WRITE_FLUSH_SUPPORTED)
741 pngtest_flush);
742 # else
743 NULL);
744 # endif
745 # endif
746 #endif
747 if(status_dots_requested == 1)
748 {
749 #ifdef PNG_WRITE_SUPPORTED
750 png_set_write_status_fn(write_ptr, write_row_callback);
751 #endif
752 png_set_read_status_fn(read_ptr, read_row_callback);
753 }
754 else
755 {
756 #ifdef PNG_WRITE_SUPPORTED
757 png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL);
758 #endif
759 png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL);
760 }
761
762 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
763 {
764 int i;
765 for(i=0; i<256; i++)
766 filters_used[i]=0;
767 png_set_read_user_transform_fn(read_ptr, count_filters);
768 }
769 #endif
770 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
771 zero_samples=0;
772 png_set_write_user_transform_fn(write_ptr, count_zero_samples);
773 #endif
774
775 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
776 # ifndef PNG_HANDLE_CHUNK_ALWAYS
777 # define PNG_HANDLE_CHUNK_ALWAYS 3
778 # endif
779 png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,
780 png_bytep_NULL, 0);
781 #endif
782 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
783 # ifndef PNG_HANDLE_CHUNK_IF_SAFE
784 # define PNG_HANDLE_CHUNK_IF_SAFE 2
785 # endif
786 png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,
787 png_bytep_NULL, 0);
788 #endif
789
790 png_debug(0, "Reading info struct\n");
791 png_read_info(read_ptr, read_info_ptr);
792
793 png_debug(0, "Transferring info struct\n");
794 {
795 int interlace_type, compression_type, filter_type;
796
797 if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
798 &color_type, &interlace_type, &compression_type, &filter_type))
799 {
800 png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
801 #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
802 color_type, interlace_type, compression_type, filter_type);
803 #else
804 color_type, PNG_INTERLACE_NONE, compression_type, filter_type);
805 #endif
806 }
807 }
808 #if defined(PNG_FIXED_POINT_SUPPORTED)
809 #if defined(PNG_cHRM_SUPPORTED)
810 {
811 png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
812 blue_y;
813 if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
814 &red_y, &green_x, &green_y, &blue_x, &blue_y))
815 {
816 png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,
817 red_y, green_x, green_y, blue_x, blue_y);
818 }
819 }
820 #endif
821 #if defined(PNG_gAMA_SUPPORTED)
822 {
823 png_fixed_point gamma;
824
825 if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))
826 {
827 png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
828 }
829 }
830 #endif
831 #else /* Use floating point versions */
832 #if defined(PNG_FLOATING_POINT_SUPPORTED)
833 #if defined(PNG_cHRM_SUPPORTED)
834 {
835 double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
836 blue_y;
837 if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
838 &red_y, &green_x, &green_y, &blue_x, &blue_y))
839 {
840 png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
841 red_y, green_x, green_y, blue_x, blue_y);
842 }
843 }
844 #endif
845 #if defined(PNG_gAMA_SUPPORTED)
846 {
847 double gamma;
848
849 if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
850 {
851 png_set_gAMA(write_ptr, write_info_ptr, gamma);
852 }
853 }
854 #endif
855 #endif /* floating point */
856 #endif /* fixed point */
857 #if defined(PNG_iCCP_SUPPORTED)
858 {
859 png_charp name;
860 png_charp profile;
861 png_uint_32 proflen;
862 int compression_type;
863
864 if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,
865 &profile, &proflen))
866 {
867 png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,
868 profile, proflen);
869 }
870 }
871 #endif
872 #if defined(PNG_sRGB_SUPPORTED)
873 {
874 int intent;
875
876 if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
877 {
878 png_set_sRGB(write_ptr, write_info_ptr, intent);
879 }
880 }
881 #endif
882 {
883 png_colorp palette;
884 int num_palette;
885
886 if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
887 {
888 png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
889 }
890 }
891 #if defined(PNG_bKGD_SUPPORTED)
892 {
893 png_color_16p background;
894
895 if (png_get_bKGD(read_ptr, read_info_ptr, &background))
896 {
897 png_set_bKGD(write_ptr, write_info_ptr, background);
898 }
899 }
900 #endif
901 #if defined(PNG_hIST_SUPPORTED)
902 {
903 png_uint_16p hist;
904
905 if (png_get_hIST(read_ptr, read_info_ptr, &hist))
906 {
907 png_set_hIST(write_ptr, write_info_ptr, hist);
908 }
909 }
910 #endif
911 #if defined(PNG_oFFs_SUPPORTED)
912 {
913 png_int_32 offset_x, offset_y;
914 int unit_type;
915
916 if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type))
917 {
918 png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
919 }
920 }
921 #endif
922 #if defined(PNG_pCAL_SUPPORTED)
923 {
924 png_charp purpose, units;
925 png_charpp params;
926 png_int_32 X0, X1;
927 int type, nparams;
928
929 if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
930 &nparams, &units, &params))
931 {
932 png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
933 nparams, units, params);
934 }
935 }
936 #endif
937 #if defined(PNG_pHYs_SUPPORTED)
938 {
939 png_uint_32 res_x, res_y;
940 int unit_type;
941
942 if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
943 {
944 png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
945 }
946 }
947 #endif
948 #if defined(PNG_sBIT_SUPPORTED)
949 {
950 png_color_8p sig_bit;
951
952 if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
953 {
954 png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
955 }
956 }
957 #endif
958 #if defined(PNG_sCAL_SUPPORTED)
959 #ifdef PNG_FLOATING_POINT_SUPPORTED
960 {
961 int unit;
962 double scal_width, scal_height;
963
964 if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,
965 &scal_height))
966 {
967 png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);
968 }
969 }
970 #else
971 #ifdef PNG_FIXED_POINT_SUPPORTED
972 {
973 int unit;
974 png_charp scal_width, scal_height;
975
976 if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,
977 &scal_height))
978 {
979 png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height);
980 }
981 }
982 #endif
983 #endif
984 #endif
985 #if defined(PNG_TEXT_SUPPORTED)
986 {
987 png_textp text_ptr;
988 int num_text;
989
990 if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
991 {
992 png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);
993 png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
994 }
995 }
996 #endif
997 #if defined(PNG_tIME_SUPPORTED)
998 {
999 png_timep mod_time;
1000
1001 if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
1002 {
1003 png_set_tIME(write_ptr, write_info_ptr, mod_time);
1004 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1005 /* we have to use png_memcpy instead of "=" because the string
1006 pointed to by png_convert_to_rfc1123() gets free'ed before
1007 we use it */
1008 png_memcpy(tIME_string,
1009 png_convert_to_rfc1123(read_ptr, mod_time),
1010 png_sizeof(tIME_string));
1011 tIME_string[png_sizeof(tIME_string)-1] = '\0';
1012 tIME_chunk_present++;
1013 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1014 }
1015 }
1016 #endif
1017 #if defined(PNG_tRNS_SUPPORTED)
1018 {
1019 png_bytep trans;
1020 int num_trans;
1021 png_color_16p trans_values;
1022
1023 if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,
1024 &trans_values))
1025 {
1026 int sample_max = (1 << read_info_ptr->bit_depth);
1027 /* libpng doesn't reject a tRNS chunk with out-of-range samples */
1028 if (!((read_info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
1029 (int)trans_values->gray > sample_max) ||
1030 (read_info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
1031 ((int)trans_values->red > sample_max ||
1032 (int)trans_values->green > sample_max ||
1033 (int)trans_values->blue > sample_max))))
1034 png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
1035 trans_values);
1036 }
1037 }
1038 #endif
1039 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
1040 {
1041 png_unknown_chunkp unknowns;
1042 int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,
1043 &unknowns);
1044 if (num_unknowns)
1045 {
1046 png_size_t i;
1047 png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
1048 num_unknowns);
1049 /* copy the locations from the read_info_ptr. The automatically
1050 generated locations in write_info_ptr are wrong because we
1051 haven't written anything yet */
1052 for (i = 0; i < (png_size_t)num_unknowns; i++)
1053 png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
1054 unknowns[i].location);
1055 }
1056 }
1057 #endif
1058
1059 #ifdef PNG_WRITE_SUPPORTED
1060 png_debug(0, "\nWriting info struct\n");
1061
1062 /* If we wanted, we could write info in two steps:
1063 png_write_info_before_PLTE(write_ptr, write_info_ptr);
1064 */
1065 png_write_info(write_ptr, write_info_ptr);
1066 #endif
1067
1068 #ifdef SINGLE_ROWBUF_ALLOC
1069 png_debug(0, "\nAllocating row buffer...");
1070 row_buf = (png_bytep)png_malloc(read_ptr,
1071 png_get_rowbytes(read_ptr, read_info_ptr));
1072 png_debug1(0, "0x%08lx\n\n", (unsigned long)row_buf);
1073 #endif /* SINGLE_ROWBUF_ALLOC */
1074 png_debug(0, "Writing row data\n");
1075
1076 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
1077 defined(PNG_WRITE_INTERLACING_SUPPORTED)
1078 num_pass = png_set_interlace_handling(read_ptr);
1079 # ifdef PNG_WRITE_SUPPORTED
1080 png_set_interlace_handling(write_ptr);
1081 # endif
1082 #else
1083 num_pass=1;
1084 #endif
1085
1086 #ifdef PNGTEST_TIMING
1087 t_stop = (float)clock();
1088 t_misc += (t_stop - t_start);
1089 t_start = t_stop;
1090 #endif
1091 for (pass = 0; pass < num_pass; pass++)
1092 {
1093 png_debug1(0, "Writing row data for pass %d\n",pass);
1094 for (y = 0; y < height; y++)
1095 {
1096 #ifndef SINGLE_ROWBUF_ALLOC
1097 png_debug2(0, "\nAllocating row buffer (pass %d, y = %ld)...", pass,y);
1098 row_buf = (png_bytep)png_malloc(read_ptr,
1099 png_get_rowbytes(read_ptr, read_info_ptr));
1100 png_debug2(0, "0x%08lx (%ld bytes)\n", (unsigned long)row_buf,
1101 png_get_rowbytes(read_ptr, read_info_ptr));
1102 #endif /* !SINGLE_ROWBUF_ALLOC */
1103 png_read_rows(read_ptr, (png_bytepp)&row_buf, png_bytepp_NULL, 1);
1104
1105 #ifdef PNG_WRITE_SUPPORTED
1106 #ifdef PNGTEST_TIMING
1107 t_stop = (float)clock();
1108 t_decode += (t_stop - t_start);
1109 t_start = t_stop;
1110 #endif
1111 png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
1112 #ifdef PNGTEST_TIMING
1113 t_stop = (float)clock();
1114 t_encode += (t_stop - t_start);
1115 t_start = t_stop;
1116 #endif
1117 #endif /* PNG_WRITE_SUPPORTED */
1118
1119 #ifndef SINGLE_ROWBUF_ALLOC
1120 png_debug2(0, "Freeing row buffer (pass %d, y = %ld)\n\n", pass, y);
1121 png_free(read_ptr, row_buf);
1122 #endif /* !SINGLE_ROWBUF_ALLOC */
1123 }
1124 }
1125
1126 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1127 png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
1128 #endif
1129 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
1130 png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
1131 #endif
1132
1133 png_debug(0, "Reading and writing end_info data\n");
1134
1135 png_read_end(read_ptr, end_info_ptr);
1136 #if defined(PNG_TEXT_SUPPORTED)
1137 {
1138 png_textp text_ptr;
1139 int num_text;
1140
1141 if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)
1142 {
1143 png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);
1144 png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);
1145 }
1146 }
1147 #endif
1148 #if defined(PNG_tIME_SUPPORTED)
1149 {
1150 png_timep mod_time;
1151
1152 if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))
1153 {
1154 png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
1155 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1156 /* we have to use png_memcpy instead of "=" because the string
1157 pointed to by png_convert_to_rfc1123() gets free'ed before
1158 we use it */
1159 png_memcpy(tIME_string,
1160 png_convert_to_rfc1123(read_ptr, mod_time),
1161 png_sizeof(tIME_string));
1162 tIME_string[png_sizeof(tIME_string)-1] = '\0';
1163 tIME_chunk_present++;
1164 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1165 }
1166 }
1167 #endif
1168 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
1169 {
1170 png_unknown_chunkp unknowns;
1171 int num_unknowns;
1172 num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr,
1173 &unknowns);
1174 if (num_unknowns)
1175 {
1176 png_size_t i;
1177 png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
1178 num_unknowns);
1179 /* copy the locations from the read_info_ptr. The automatically
1180 generated locations in write_end_info_ptr are wrong because we
1181 haven't written the end_info yet */
1182 for (i = 0; i < (png_size_t)num_unknowns; i++)
1183 png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
1184 unknowns[i].location);
1185 }
1186 }
1187 #endif
1188 #ifdef PNG_WRITE_SUPPORTED
1189 png_write_end(write_ptr, write_end_info_ptr);
1190 #endif
1191
1192 #ifdef PNG_EASY_ACCESS_SUPPORTED
1193 if(verbose)
1194 {
1195 png_uint_32 iwidth, iheight;
1196 iwidth = png_get_image_width(write_ptr, write_info_ptr);
1197 iheight = png_get_image_height(write_ptr, write_info_ptr);
1198 fprintf(STDERR, "Image width = %lu, height = %lu\n",
1199 (unsigned long)iwidth, (unsigned long)iheight);
1200 }
1201 #endif
1202
1203 png_debug(0, "Destroying data structs\n");
1204 #ifdef SINGLE_ROWBUF_ALLOC
1205 png_debug(1, "destroying row_buf for read_ptr\n");
1206 png_free(read_ptr, row_buf);
1207 row_buf=NULL;
1208 #endif /* SINGLE_ROWBUF_ALLOC */
1209 png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr\n");
1210 png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
1211 #ifdef PNG_WRITE_SUPPORTED
1212 png_debug(1, "destroying write_end_info_ptr\n");
1213 png_destroy_info_struct(write_ptr, &write_end_info_ptr);
1214 png_debug(1, "destroying write_ptr, write_info_ptr\n");
1215 png_destroy_write_struct(&write_ptr, &write_info_ptr);
1216 #endif
1217 png_debug(0, "Destruction complete.\n");
1218
1219 FCLOSE(fpin);
1220 FCLOSE(fpout);
1221
1222 png_debug(0, "Opening files for comparison\n");
1223 #if defined(_WIN32_WCE)
1224 MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);
1225 if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
1226 #else
1227 if ((fpin = fopen(inname, "rb")) == NULL)
1228 #endif
1229 {
1230 fprintf(STDERR, "Could not find file %s\n", inname);
1231 return (1);
1232 }
1233
1234 #if defined(_WIN32_WCE)
1235 MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);
1236 if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
1237 #else
1238 if ((fpout = fopen(outname, "rb")) == NULL)
1239 #endif
1240 {
1241 fprintf(STDERR, "Could not find file %s\n", outname);
1242 FCLOSE(fpin);
1243 return (1);
1244 }
1245
1246 for(;;)
1247 {
1248 png_size_t num_in, num_out;
1249
1250 READFILE(fpin, inbuf, 1, num_in);
1251 READFILE(fpout, outbuf, 1, num_out);
1252
1253 if (num_in != num_out)
1254 {
1255 fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
1256 inname, outname);
1257 if(wrote_question == 0)
1258 {
1259 fprintf(STDERR,
1260 " Was %s written with the same maximum IDAT chunk size (%d bytes),",
1261 inname,PNG_ZBUF_SIZE);
1262 fprintf(STDERR,
1263 "\n filtering heuristic (libpng default), compression");
1264 fprintf(STDERR,
1265 " level (zlib default),\n and zlib version (%s)?\n\n",
1266 ZLIB_VERSION);
1267 wrote_question=1;
1268 }
1269 FCLOSE(fpin);
1270 FCLOSE(fpout);
1271 return (0);
1272 }
1273
1274 if (!num_in)
1275 break;
1276
1277 if (png_memcmp(inbuf, outbuf, num_in))
1278 {
1279 fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);
1280 if(wrote_question == 0)
1281 {
1282 fprintf(STDERR,
1283 " Was %s written with the same maximum IDAT chunk size (%d bytes),",
1284 inname,PNG_ZBUF_SIZE);
1285 fprintf(STDERR,
1286 "\n filtering heuristic (libpng default), compression");
1287 fprintf(STDERR,
1288 " level (zlib default),\n and zlib version (%s)?\n\n",
1289 ZLIB_VERSION);
1290 wrote_question=1;
1291 }
1292 FCLOSE(fpin);
1293 FCLOSE(fpout);
1294 return (0);
1295 }
1296 }
1297
1298 FCLOSE(fpin);
1299 FCLOSE(fpout);
1300
1301 return (0);
1302 }
1303
1304 /* input and output filenames */
1305 #ifdef RISCOS
1306 static PNG_CONST char *inname = "pngtest/png";
1307 static PNG_CONST char *outname = "pngout/png";
1308 #else
1309 static PNG_CONST char *inname = "pngtest.png";
1310 static PNG_CONST char *outname = "pngout.png";
1311 #endif
1312
1313 int
1314 main(int argc, char *argv[])
1315 {
1316 int multiple = 0;
1317 int ierror = 0;
1318
1319 fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
1320 fprintf(STDERR, " with zlib version %s\n", ZLIB_VERSION);
1321 fprintf(STDERR,"%s",png_get_copyright(NULL));
1322 /* Show the version of libpng used in building the library */
1323 fprintf(STDERR," library (%lu):%s",
1324 (unsigned long)png_access_version_number(),
1325 png_get_header_version(NULL));
1326 /* Show the version of libpng used in building the application */
1327 fprintf(STDERR," pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,
1328 PNG_HEADER_VERSION_STRING);
1329 fprintf(STDERR," png_sizeof(png_struct)=%ld, png_sizeof(png_info)=%ld\n",
1330 (long)png_sizeof(png_struct), (long)png_sizeof(png_info));
1331
1332 /* Do some consistency checking on the memory allocation settings, I'm
1333 not sure this matters, but it is nice to know, the first of these
1334 tests should be impossible because of the way the macros are set
1335 in pngconf.h */
1336 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
1337 fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
1338 #endif
1339 /* I think the following can happen. */
1340 #if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
1341 fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");
1342 #endif
1343
1344 if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
1345 {
1346 fprintf(STDERR,
1347 "Warning: versions are different between png.h and png.c\n");
1348 fprintf(STDERR, " png.h version: %s\n", PNG_LIBPNG_VER_STRING);
1349 fprintf(STDERR, " png.c version: %s\n\n", png_libpng_ver);
1350 ++ierror;
1351 }
1352
1353 if (argc > 1)
1354 {
1355 if (strcmp(argv[1], "-m") == 0)
1356 {
1357 multiple = 1;
1358 status_dots_requested = 0;
1359 }
1360 else if (strcmp(argv[1], "-mv") == 0 ||
1361 strcmp(argv[1], "-vm") == 0 )
1362 {
1363 multiple = 1;
1364 verbose = 1;
1365 status_dots_requested = 1;
1366 }
1367 else if (strcmp(argv[1], "-v") == 0)
1368 {
1369 verbose = 1;
1370 status_dots_requested = 1;
1371 inname = argv[2];
1372 }
1373 else
1374 {
1375 inname = argv[1];
1376 status_dots_requested = 0;
1377 }
1378 }
1379
1380 if (!multiple && argc == 3+verbose)
1381 outname = argv[2+verbose];
1382
1383 if ((!multiple && argc > 3+verbose) || (multiple && argc < 2))
1384 {
1385 fprintf(STDERR,
1386 "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
1387 argv[0], argv[0]);
1388 fprintf(STDERR,
1389 " reads/writes one PNG file (without -m) or multiple files (-m)\n");
1390 fprintf(STDERR,
1391 " with -m %s is used as a temporary file\n", outname);
1392 exit(1);
1393 }
1394
1395 if (multiple)
1396 {
1397 int i;
1398 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1399 int allocation_now = current_allocation;
1400 #endif
1401 for (i=2; i<argc; ++i)
1402 {
1403 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1404 int k;
1405 #endif
1406 int kerror;
1407 fprintf(STDERR, "Testing %s:",argv[i]);
1408 kerror = test_one_file(argv[i], outname);
1409 if (kerror == 0)
1410 {
1411 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
1412 fprintf(STDERR, "\n PASS (%lu zero samples)\n",
1413 (unsigned long)zero_samples);
1414 #else
1415 fprintf(STDERR, " PASS\n");
1416 #endif
1417 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1418 for (k=0; k<256; k++)
1419 if(filters_used[k])
1420 fprintf(STDERR, " Filter %d was used %lu times\n",
1421 k,(unsigned long)filters_used[k]);
1422 #endif
1423 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1424 if(tIME_chunk_present != 0)
1425 fprintf(STDERR, " tIME = %s\n",tIME_string);
1426 tIME_chunk_present = 0;
1427 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1428 }
1429 else
1430 {
1431 fprintf(STDERR, " FAIL\n");
1432 ierror += kerror;
1433 }
1434 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1435 if (allocation_now != current_allocation)
1436 fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
1437 current_allocation-allocation_now);
1438 if (current_allocation != 0)
1439 {
1440 memory_infop pinfo = pinformation;
1441
1442 fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
1443 current_allocation);
1444 while (pinfo != NULL)
1445 {
1446 fprintf(STDERR, " %lu bytes at %x\n", (unsigned long)pinfo->size,
1447 (unsigned int) pinfo->pointer);
1448 pinfo = pinfo->next;
1449 }
1450 }
1451 #endif
1452 }
1453 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1454 fprintf(STDERR, " Current memory allocation: %10d bytes\n",
1455 current_allocation);
1456 fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
1457 maximum_allocation);
1458 fprintf(STDERR, " Total memory allocation: %10d bytes\n",
1459 total_allocation);
1460 fprintf(STDERR, " Number of allocations: %10d\n",
1461 num_allocations);
1462 #endif
1463 }
1464 else
1465 {
1466 int i;
1467 for (i=0; i<3; ++i)
1468 {
1469 int kerror;
1470 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1471 int allocation_now = current_allocation;
1472 #endif
1473 if (i == 1) status_dots_requested = 1;
1474 else if(verbose == 0)status_dots_requested = 0;
1475 if (i == 0 || verbose == 1 || ierror != 0)
1476 fprintf(STDERR, "Testing %s:",inname);
1477 kerror = test_one_file(inname, outname);
1478 if(kerror == 0)
1479 {
1480 if(verbose == 1 || i == 2)
1481 {
1482 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1483 int k;
1484 #endif
1485 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
1486 fprintf(STDERR, "\n PASS (%lu zero samples)\n",
1487 (unsigned long)zero_samples);
1488 #else
1489 fprintf(STDERR, " PASS\n");
1490 #endif
1491 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1492 for (k=0; k<256; k++)
1493 if(filters_used[k])
1494 fprintf(STDERR, " Filter %d was used %lu times\n",
1495 k,(unsigned long)filters_used[k]);
1496 #endif
1497 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1498 if(tIME_chunk_present != 0)
1499 fprintf(STDERR, " tIME = %s\n",tIME_string);
1500 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1501 }
1502 }
1503 else
1504 {
1505 if(verbose == 0 && i != 2)
1506 fprintf(STDERR, "Testing %s:",inname);
1507 fprintf(STDERR, " FAIL\n");
1508 ierror += kerror;
1509 }
1510 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1511 if (allocation_now != current_allocation)
1512 fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
1513 current_allocation-allocation_now);
1514 if (current_allocation != 0)
1515 {
1516 memory_infop pinfo = pinformation;
1517
1518 fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
1519 current_allocation);
1520 while (pinfo != NULL)
1521 {
1522 fprintf(STDERR," %lu bytes at %x\n",
1523 (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);
1524 pinfo = pinfo->next;
1525 }
1526 }
1527 #endif
1528 }
1529 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1530 fprintf(STDERR, " Current memory allocation: %10d bytes\n",
1531 current_allocation);
1532 fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
1533 maximum_allocation);
1534 fprintf(STDERR, " Total memory allocation: %10d bytes\n",
1535 total_allocation);
1536 fprintf(STDERR, " Number of allocations: %10d\n",
1537 num_allocations);
1538 #endif
1539 }
1540
1541 #ifdef PNGTEST_TIMING
1542 t_stop = (float)clock();
1543 t_misc += (t_stop - t_start);
1544 t_start = t_stop;
1545 fprintf(STDERR," CPU time used = %.3f seconds",
1546 (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);
1547 fprintf(STDERR," (decoding %.3f,\n",
1548 t_decode/(float)CLOCKS_PER_SEC);
1549 fprintf(STDERR," encoding %.3f ,",
1550 t_encode/(float)CLOCKS_PER_SEC);
1551 fprintf(STDERR," other %.3f seconds)\n\n",
1552 t_misc/(float)CLOCKS_PER_SEC);
1553 #endif
1554
1555 if (ierror == 0)
1556 fprintf(STDERR, "libpng passes test\n");
1557 else
1558 fprintf(STDERR, "libpng FAILS test\n");
1559 return (int)(ierror != 0);
1560 }
1561
1562 /* Generate a compiler error if there is an old png.h in the search path. */
1563 typedef version_1_2_29 your_png_h_is_not_version_1_2_29;