2 /* pngtest.c - a simple test program to test libpng
4 * Last changed in libpng 1.2.23 - [November 6, 2007]
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1998-2007 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.)
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
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.
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 ..."
33 #if defined(_WIN32_WCE)
35 __error__ (f
|w
)printf functions are
not supported on old WindowsCE
.;
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)
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)
54 #if defined(PNG_NO_STDIO)
55 # if defined(_WIN32_WCE)
56 typedef HANDLE png_FILE_p
;
58 typedef FILE * png_FILE_p
;
62 /* Makes pngtest verbose so we can find problems (needs to be before png.h) */
68 # define SINGLE_ROWBUF_ALLOC /* makes buffer overruns easier to nail */
72 #define PNGTEST_TIMING
75 #ifdef PNG_NO_FLOATING_POINT_SUPPORTED
80 static float t_start
, t_stop
, t_decode
, t_encode
, t_misc
;
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";
90 static int verbose
= 0;
92 int test_one_file
PNGARG((PNG_CONST
char *inname
, PNG_CONST
char *outname
));
98 /* defined so I can write to a file on gui/windowing platforms */
99 /* #define STDERR stderr */
100 #define STDERR stdout /* for DOS */
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;
107 /* In case a system header (e.g., on AIX) defined jmpbuf */
112 /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
114 # define png_jmpbuf(png_ptr) png_ptr->jmpbuf
121 read_row_callback(png_structp png_ptr
, png_uint_32 row_number
, int pass
);
126 read_row_callback(png_structp png_ptr
, png_uint_32 row_number
, int pass
)
128 if(png_ptr
== NULL
|| row_number
> PNG_UINT_31_MAX
) return;
129 if(status_pass
!= pass
)
131 fprintf(stdout
,"\n Pass %d: ",pass
);
138 fprintf(stdout
, "\n ");
141 fprintf(stdout
, "r");
148 write_row_callback(png_structp png_ptr
, png_uint_32 row_number
, int pass
);
153 write_row_callback(png_structp png_ptr
, png_uint_32 row_number
, int pass
)
155 if(png_ptr
== NULL
|| row_number
> PNG_UINT_31_MAX
|| pass
> 7) return;
156 fprintf(stdout
, "w");
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];
169 count_filters(png_structp png_ptr
, png_row_infop row_info
, png_bytep data
);
174 count_filters(png_structp png_ptr
, png_row_infop row_info
, png_bytep data
)
176 if(png_ptr
!= NULL
&& row_info
!= NULL
)
177 ++filters_used
[*(data
-1)];
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) */
185 static png_uint_32 zero_samples
;
191 count_zero_samples(png_structp png_ptr
, png_row_infop row_info
, png_bytep data
);
196 count_zero_samples(png_structp png_ptr
, png_row_infop row_info
, png_bytep data
)
199 if(png_ptr
== NULL
)return;
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)
211 /* counts the number of zero samples (or zero pixels if color_type is 3 */
213 if(row_info
->color_type
== 0 || row_info
->color_type
== 3)
216 png_uint_32 n
, nstop
;
217 for (n
=0, nstop
=row_info
->width
; n
<nstop
; n
++)
219 if(row_info
->bit_depth
== 1)
221 if(((*dp
<< pos
++ ) & 0x80) == 0) zero_samples
++;
228 if(row_info
->bit_depth
== 2)
230 if(((*dp
<< (pos
+=2)) & 0xc0) == 0) zero_samples
++;
237 if(row_info
->bit_depth
== 4)
239 if(((*dp
<< (pos
+=4)) & 0xf0) == 0) zero_samples
++;
246 if(row_info
->bit_depth
== 8)
247 if(*dp
++ == 0) zero_samples
++;
248 if(row_info
->bit_depth
== 16)
250 if((*dp
| *(dp
+1)) == 0) zero_samples
++;
255 else /* other color types */
257 png_uint_32 n
, nstop
;
259 int color_channels
= row_info
->channels
;
260 if(row_info
->color_type
> 3)color_channels
--;
262 for (n
=0, nstop
=row_info
->width
; n
<nstop
; n
++)
264 for (channel
= 0; channel
< color_channels
; channel
++)
266 if(row_info
->bit_depth
== 8)
267 if(*dp
++ == 0) zero_samples
++;
268 if(row_info
->bit_depth
== 16)
270 if((*dp
| *(dp
+1)) == 0) zero_samples
++;
274 if(row_info
->color_type
> 3)
277 if(row_info
->bit_depth
== 16)dp
++;
282 #endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */
284 static int wrote_question
= 0;
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. */
295 #ifndef USE_FAR_KEYWORD
297 pngtest_read_data(png_structp png_ptr
, png_bytep data
, png_size_t length
)
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.
304 READFILE((png_FILE_p
)png_ptr
->io_ptr
, data
, length
, check
);
308 png_error(png_ptr
, "Read Error!");
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
317 #define NEAR_BUF_SIZE 1024
318 #define MIN(a,b) (a <= b ? a : b)
321 pngtest_read_data(png_structp png_ptr
, png_bytep data
, png_size_t length
)
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
)
332 READFILE(io_ptr
, n_data
, length
, check
);
336 png_byte buf
[NEAR_BUF_SIZE
];
337 png_size_t read
, remaining
, err
;
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 */
352 while (remaining
!= 0);
356 png_error(png_ptr
, "read Error");
359 #endif /* USE_FAR_KEYWORD */
361 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
363 pngtest_flush(png_structp png_ptr
)
365 #if !defined(_WIN32_WCE)
367 io_ptr
= (png_FILE_p
)CVT_PTR((png_ptr
->io_ptr
));
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
380 pngtest_write_data(png_structp png_ptr
, png_bytep data
, png_size_t length
)
384 WRITEFILE((png_FILE_p
)png_ptr
->io_ptr
, data
, length
, check
);
387 png_error(png_ptr
, "Write Error");
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
396 #define NEAR_BUF_SIZE 1024
397 #define MIN(a,b) (a <= b ? a : b)
400 pngtest_write_data(png_structp png_ptr
, png_bytep data
, png_size_t length
)
403 png_byte
*near_data
; /* Needs to be "png_byte *" instead of "png_bytep" */
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
)
411 WRITEFILE(io_ptr
, near_data
, length
, check
);
415 png_byte buf
[NEAR_BUF_SIZE
];
416 png_size_t written
, remaining
, err
;
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
);
429 remaining
-= written
;
431 while (remaining
!= 0);
435 png_error(png_ptr
, "Write Error");
438 #endif /* USE_FAR_KEYWORD */
439 #endif /* PNG_NO_STDIO */
440 /* END of code to validate stdio-free compilation */
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.
448 pngtest_warning(png_structp png_ptr
, png_const_charp message
)
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
);
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().
462 pngtest_error(png_structp png_ptr
, png_const_charp message
)
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. */
469 /* START of code to validate memory allocation and deallocation */
470 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
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.
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
484 struct memory_information FAR
*next
;
485 } memory_information
;
486 typedef memory_information FAR
*memory_infop
;
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;
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
));
498 png_debug_malloc(png_structp png_ptr
, png_uint_32 size
)
501 /* png_malloc has already tested for NULL; png_create_struct calls
502 png_debug_malloc directly, with png_ptr == NULL which is OK */
507 /* This calls the library allocator twice, once to get the requested
508 buffer and once to get a new free list entry. */
510 /* Disable malloc_fn and free_fn */
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
));
516 current_allocation
+= size
;
517 total_allocation
+= size
;
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
)
527 current_allocation
-= size
;
528 total_allocation
-= size
;
530 "out of memory in pngtest->png_debug_malloc.");
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
);
537 printf("png_malloc %lu bytes at %x\n",(unsigned long)size
,
539 return (png_voidp
)(pinfo
->pointer
);
543 /* Free a pointer. It is removed from the list at the same time. */
545 png_debug_free(png_structp png_ptr
, png_voidp ptr
)
548 fprintf(STDERR
, "NULL pointer to png_debug_free.\n");
551 #if 0 /* This happens all the time. */
552 fprintf(STDERR
, "WARNING: freeing NULL pointer\n");
557 /* Unlink the element from the list. */
559 memory_infop FAR
*ppinfo
= &pinformation
;
562 memory_infop pinfo
= *ppinfo
;
563 if (pinfo
->pointer
== ptr
)
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
);
576 if (pinfo
->next
== NULL
)
578 fprintf(STDERR
, "Pointer %x not found\n", (unsigned int)ptr
);
581 ppinfo
= &pinfo
->next
;
585 /* Finally free the data. */
587 printf("Freeing %x\n",ptr
);
588 png_free_default(png_ptr
, ptr
);
591 #endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */
592 /* END of code to test memory allocation/deallocation */
596 test_one_file(PNG_CONST
char *inname
, PNG_CONST
char *outname
)
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
;
607 png_structp write_ptr
= NULL
;
608 png_infop write_info_ptr
= NULL
;
609 png_infop write_end_info_ptr
= NULL
;
613 png_uint_32 width
, height
;
615 int bit_depth
, color_type
;
616 #ifdef PNG_SETJMP_SUPPORTED
617 #ifdef USE_FAR_KEYWORD
622 #if defined(_WIN32_WCE)
623 TCHAR path
[MAX_PATH
];
625 char inbuf
[256], outbuf
[256];
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
)
633 if ((fpin
= fopen(inname
, "rb")) == NULL
)
636 fprintf(STDERR
, "Could not find input file %s\n", inname
);
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
)
644 if ((fpout
= fopen(outname
, "wb")) == NULL
)
647 fprintf(STDERR
, "Could not open output file %s\n", outname
);
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
);
658 read_ptr
= png_create_read_struct(PNG_LIBPNG_VER_STRING
, png_voidp_NULL
,
659 png_error_ptr_NULL
, png_error_ptr_NULL
);
661 png_set_error_fn(read_ptr
, (png_voidp
)inname
, pngtest_error
,
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
);
669 write_ptr
= png_create_write_struct(PNG_LIBPNG_VER_STRING
, png_voidp_NULL
,
670 png_error_ptr_NULL
, png_error_ptr_NULL
);
672 png_set_error_fn(write_ptr
, (png_voidp
)inname
, pngtest_error
,
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
);
683 #ifdef PNG_SETJMP_SUPPORTED
684 png_debug(0, "Setting jmpbuf for read struct\n");
685 #ifdef USE_FAR_KEYWORD
688 if (setjmp(png_jmpbuf(read_ptr
)))
691 fprintf(STDERR
, "%s -> %s: libpng read error\n", inname
, outname
);
693 png_free(read_ptr
, row_buf
);
694 png_destroy_read_struct(&read_ptr
, &read_info_ptr
, &end_info_ptr
);
695 #ifdef PNG_WRITE_SUPPORTED
696 png_destroy_info_struct(write_ptr
, &write_end_info_ptr
);
697 png_destroy_write_struct(&write_ptr
, &write_info_ptr
);
703 #ifdef USE_FAR_KEYWORD
704 png_memcpy(png_jmpbuf(read_ptr
),jmpbuf
,png_sizeof(jmp_buf));
707 #ifdef PNG_WRITE_SUPPORTED
708 png_debug(0, "Setting jmpbuf for write struct\n");
709 #ifdef USE_FAR_KEYWORD
712 if (setjmp(png_jmpbuf(write_ptr
)))
715 fprintf(STDERR
, "%s -> %s: libpng write error\n", inname
, outname
);
716 png_destroy_read_struct(&read_ptr
, &read_info_ptr
, &end_info_ptr
);
717 png_destroy_info_struct(write_ptr
, &write_end_info_ptr
);
718 #ifdef PNG_WRITE_SUPPORTED
719 png_destroy_write_struct(&write_ptr
, &write_info_ptr
);
725 #ifdef USE_FAR_KEYWORD
726 png_memcpy(png_jmpbuf(write_ptr
),jmpbuf
,png_sizeof(jmp_buf));
731 png_debug(0, "Initializing input and output streams\n");
732 #if !defined(PNG_NO_STDIO)
733 png_init_io(read_ptr
, fpin
);
734 # ifdef PNG_WRITE_SUPPORTED
735 png_init_io(write_ptr
, fpout
);
738 png_set_read_fn(read_ptr
, (png_voidp
)fpin
, pngtest_read_data
);
739 # ifdef PNG_WRITE_SUPPORTED
740 png_set_write_fn(write_ptr
, (png_voidp
)fpout
, pngtest_write_data
,
741 # if defined(PNG_WRITE_FLUSH_SUPPORTED)
748 if(status_dots_requested
== 1)
750 #ifdef PNG_WRITE_SUPPORTED
751 png_set_write_status_fn(write_ptr
, write_row_callback
);
753 png_set_read_status_fn(read_ptr
, read_row_callback
);
757 #ifdef PNG_WRITE_SUPPORTED
758 png_set_write_status_fn(write_ptr
, png_write_status_ptr_NULL
);
760 png_set_read_status_fn(read_ptr
, png_read_status_ptr_NULL
);
763 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
768 png_set_read_user_transform_fn(read_ptr
, count_filters
);
771 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
773 png_set_write_user_transform_fn(write_ptr
, count_zero_samples
);
776 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
777 # ifndef PNG_HANDLE_CHUNK_ALWAYS
778 # define PNG_HANDLE_CHUNK_ALWAYS 3
780 png_set_keep_unknown_chunks(read_ptr
, PNG_HANDLE_CHUNK_ALWAYS
,
783 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
784 # ifndef PNG_HANDLE_CHUNK_IF_SAFE
785 # define PNG_HANDLE_CHUNK_IF_SAFE 2
787 png_set_keep_unknown_chunks(write_ptr
, PNG_HANDLE_CHUNK_IF_SAFE
,
791 png_debug(0, "Reading info struct\n");
792 png_read_info(read_ptr
, read_info_ptr
);
794 png_debug(0, "Transferring info struct\n");
796 int interlace_type
, compression_type
, filter_type
;
798 if (png_get_IHDR(read_ptr
, read_info_ptr
, &width
, &height
, &bit_depth
,
799 &color_type
, &interlace_type
, &compression_type
, &filter_type
))
801 png_set_IHDR(write_ptr
, write_info_ptr
, width
, height
, bit_depth
,
802 #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
803 color_type
, interlace_type
, compression_type
, filter_type
);
805 color_type
, PNG_INTERLACE_NONE
, compression_type
, filter_type
);
809 #if defined(PNG_FIXED_POINT_SUPPORTED)
810 #if defined(PNG_cHRM_SUPPORTED)
812 png_fixed_point white_x
, white_y
, red_x
, red_y
, green_x
, green_y
, blue_x
,
814 if (png_get_cHRM_fixed(read_ptr
, read_info_ptr
, &white_x
, &white_y
, &red_x
,
815 &red_y
, &green_x
, &green_y
, &blue_x
, &blue_y
))
817 png_set_cHRM_fixed(write_ptr
, write_info_ptr
, white_x
, white_y
, red_x
,
818 red_y
, green_x
, green_y
, blue_x
, blue_y
);
822 #if defined(PNG_gAMA_SUPPORTED)
824 png_fixed_point gamma
;
826 if (png_get_gAMA_fixed(read_ptr
, read_info_ptr
, &gamma
))
828 png_set_gAMA_fixed(write_ptr
, write_info_ptr
, gamma
);
832 #else /* Use floating point versions */
833 #if defined(PNG_FLOATING_POINT_SUPPORTED)
834 #if defined(PNG_cHRM_SUPPORTED)
836 double white_x
, white_y
, red_x
, red_y
, green_x
, green_y
, blue_x
,
838 if (png_get_cHRM(read_ptr
, read_info_ptr
, &white_x
, &white_y
, &red_x
,
839 &red_y
, &green_x
, &green_y
, &blue_x
, &blue_y
))
841 png_set_cHRM(write_ptr
, write_info_ptr
, white_x
, white_y
, red_x
,
842 red_y
, green_x
, green_y
, blue_x
, blue_y
);
846 #if defined(PNG_gAMA_SUPPORTED)
850 if (png_get_gAMA(read_ptr
, read_info_ptr
, &gamma
))
852 png_set_gAMA(write_ptr
, write_info_ptr
, gamma
);
856 #endif /* floating point */
857 #endif /* fixed point */
858 #if defined(PNG_iCCP_SUPPORTED)
863 int compression_type
;
865 if (png_get_iCCP(read_ptr
, read_info_ptr
, &name
, &compression_type
,
868 png_set_iCCP(write_ptr
, write_info_ptr
, name
, compression_type
,
873 #if defined(PNG_sRGB_SUPPORTED)
877 if (png_get_sRGB(read_ptr
, read_info_ptr
, &intent
))
879 png_set_sRGB(write_ptr
, write_info_ptr
, intent
);
887 if (png_get_PLTE(read_ptr
, read_info_ptr
, &palette
, &num_palette
))
889 png_set_PLTE(write_ptr
, write_info_ptr
, palette
, num_palette
);
892 #if defined(PNG_bKGD_SUPPORTED)
894 png_color_16p background
;
896 if (png_get_bKGD(read_ptr
, read_info_ptr
, &background
))
898 png_set_bKGD(write_ptr
, write_info_ptr
, background
);
902 #if defined(PNG_hIST_SUPPORTED)
906 if (png_get_hIST(read_ptr
, read_info_ptr
, &hist
))
908 png_set_hIST(write_ptr
, write_info_ptr
, hist
);
912 #if defined(PNG_oFFs_SUPPORTED)
914 png_int_32 offset_x
, offset_y
;
917 if (png_get_oFFs(read_ptr
, read_info_ptr
,&offset_x
,&offset_y
,&unit_type
))
919 png_set_oFFs(write_ptr
, write_info_ptr
, offset_x
, offset_y
, unit_type
);
923 #if defined(PNG_pCAL_SUPPORTED)
925 png_charp purpose
, units
;
930 if (png_get_pCAL(read_ptr
, read_info_ptr
, &purpose
, &X0
, &X1
, &type
,
931 &nparams
, &units
, ¶ms
))
933 png_set_pCAL(write_ptr
, write_info_ptr
, purpose
, X0
, X1
, type
,
934 nparams
, units
, params
);
938 #if defined(PNG_pHYs_SUPPORTED)
940 png_uint_32 res_x
, res_y
;
943 if (png_get_pHYs(read_ptr
, read_info_ptr
, &res_x
, &res_y
, &unit_type
))
945 png_set_pHYs(write_ptr
, write_info_ptr
, res_x
, res_y
, unit_type
);
949 #if defined(PNG_sBIT_SUPPORTED)
951 png_color_8p sig_bit
;
953 if (png_get_sBIT(read_ptr
, read_info_ptr
, &sig_bit
))
955 png_set_sBIT(write_ptr
, write_info_ptr
, sig_bit
);
959 #if defined(PNG_sCAL_SUPPORTED)
960 #ifdef PNG_FLOATING_POINT_SUPPORTED
963 double scal_width
, scal_height
;
965 if (png_get_sCAL(read_ptr
, read_info_ptr
, &unit
, &scal_width
,
968 png_set_sCAL(write_ptr
, write_info_ptr
, unit
, scal_width
, scal_height
);
972 #ifdef PNG_FIXED_POINT_SUPPORTED
975 png_charp scal_width
, scal_height
;
977 if (png_get_sCAL_s(read_ptr
, read_info_ptr
, &unit
, &scal_width
,
980 png_set_sCAL_s(write_ptr
, write_info_ptr
, unit
, scal_width
, scal_height
);
986 #if defined(PNG_TEXT_SUPPORTED)
991 if (png_get_text(read_ptr
, read_info_ptr
, &text_ptr
, &num_text
) > 0)
993 png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text
);
994 png_set_text(write_ptr
, write_info_ptr
, text_ptr
, num_text
);
998 #if defined(PNG_tIME_SUPPORTED)
1002 if (png_get_tIME(read_ptr
, read_info_ptr
, &mod_time
))
1004 png_set_tIME(write_ptr
, write_info_ptr
, mod_time
);
1005 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1006 /* we have to use png_memcpy instead of "=" because the string
1007 pointed to by png_convert_to_rfc1123() gets free'ed before
1009 png_memcpy(tIME_string
,
1010 png_convert_to_rfc1123(read_ptr
, mod_time
),
1011 png_sizeof(tIME_string
));
1012 tIME_string
[png_sizeof(tIME_string
)-1] = '\0';
1013 tIME_chunk_present
++;
1014 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1018 #if defined(PNG_tRNS_SUPPORTED)
1022 png_color_16p trans_values
;
1024 if (png_get_tRNS(read_ptr
, read_info_ptr
, &trans
, &num_trans
,
1027 png_set_tRNS(write_ptr
, write_info_ptr
, trans
, num_trans
,
1032 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
1034 png_unknown_chunkp unknowns
;
1035 int num_unknowns
= (int)png_get_unknown_chunks(read_ptr
, read_info_ptr
,
1040 png_set_unknown_chunks(write_ptr
, write_info_ptr
, unknowns
,
1042 /* copy the locations from the read_info_ptr. The automatically
1043 generated locations in write_info_ptr are wrong because we
1044 haven't written anything yet */
1045 for (i
= 0; i
< (png_size_t
)num_unknowns
; i
++)
1046 png_set_unknown_chunk_location(write_ptr
, write_info_ptr
, i
,
1047 unknowns
[i
].location
);
1052 #ifdef PNG_WRITE_SUPPORTED
1053 png_debug(0, "\nWriting info struct\n");
1055 /* If we wanted, we could write info in two steps:
1056 png_write_info_before_PLTE(write_ptr, write_info_ptr);
1058 png_write_info(write_ptr
, write_info_ptr
);
1061 #ifdef SINGLE_ROWBUF_ALLOC
1062 png_debug(0, "\nAllocating row buffer...");
1063 row_buf
= (png_bytep
)png_malloc(read_ptr
,
1064 png_get_rowbytes(read_ptr
, read_info_ptr
));
1065 png_debug1(0, "0x%08lx\n\n", (unsigned long)row_buf
);
1066 #endif /* SINGLE_ROWBUF_ALLOC */
1067 png_debug(0, "Writing row data\n");
1069 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
1070 defined(PNG_WRITE_INTERLACING_SUPPORTED)
1071 num_pass
= png_set_interlace_handling(read_ptr
);
1072 # ifdef PNG_WRITE_SUPPORTED
1073 png_set_interlace_handling(write_ptr
);
1079 #ifdef PNGTEST_TIMING
1080 t_stop
= (float)clock();
1081 t_misc
+= (t_stop
- t_start
);
1084 for (pass
= 0; pass
< num_pass
; pass
++)
1086 png_debug1(0, "Writing row data for pass %d\n",pass
);
1087 for (y
= 0; y
< height
; y
++)
1089 #ifndef SINGLE_ROWBUF_ALLOC
1090 png_debug2(0, "\nAllocating row buffer (pass %d, y = %ld)...", pass
,y
);
1091 row_buf
= (png_bytep
)png_malloc(read_ptr
,
1092 png_get_rowbytes(read_ptr
, read_info_ptr
));
1093 png_debug2(0, "0x%08lx (%ld bytes)\n", (unsigned long)row_buf
,
1094 png_get_rowbytes(read_ptr
, read_info_ptr
));
1095 #endif /* !SINGLE_ROWBUF_ALLOC */
1096 png_read_rows(read_ptr
, (png_bytepp
)&row_buf
, png_bytepp_NULL
, 1);
1098 #ifdef PNG_WRITE_SUPPORTED
1099 #ifdef PNGTEST_TIMING
1100 t_stop
= (float)clock();
1101 t_decode
+= (t_stop
- t_start
);
1104 png_write_rows(write_ptr
, (png_bytepp
)&row_buf
, 1);
1105 #ifdef PNGTEST_TIMING
1106 t_stop
= (float)clock();
1107 t_encode
+= (t_stop
- t_start
);
1110 #endif /* PNG_WRITE_SUPPORTED */
1112 #ifndef SINGLE_ROWBUF_ALLOC
1113 png_debug2(0, "Freeing row buffer (pass %d, y = %ld)\n\n", pass
, y
);
1114 png_free(read_ptr
, row_buf
);
1115 #endif /* !SINGLE_ROWBUF_ALLOC */
1119 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1120 png_free_data(read_ptr
, read_info_ptr
, PNG_FREE_UNKN
, -1);
1122 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
1123 png_free_data(write_ptr
, write_info_ptr
, PNG_FREE_UNKN
, -1);
1126 png_debug(0, "Reading and writing end_info data\n");
1128 png_read_end(read_ptr
, end_info_ptr
);
1129 #if defined(PNG_TEXT_SUPPORTED)
1134 if (png_get_text(read_ptr
, end_info_ptr
, &text_ptr
, &num_text
) > 0)
1136 png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text
);
1137 png_set_text(write_ptr
, write_end_info_ptr
, text_ptr
, num_text
);
1141 #if defined(PNG_tIME_SUPPORTED)
1145 if (png_get_tIME(read_ptr
, end_info_ptr
, &mod_time
))
1147 png_set_tIME(write_ptr
, write_end_info_ptr
, mod_time
);
1148 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1149 /* we have to use png_memcpy instead of "=" because the string
1150 pointed to by png_convert_to_rfc1123() gets free'ed before
1152 png_memcpy(tIME_string
,
1153 png_convert_to_rfc1123(read_ptr
, mod_time
),
1154 png_sizeof(tIME_string
));
1155 tIME_string
[png_sizeof(tIME_string
)-1] = '\0';
1156 tIME_chunk_present
++;
1157 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1161 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
1163 png_unknown_chunkp unknowns
;
1165 num_unknowns
= (int)png_get_unknown_chunks(read_ptr
, end_info_ptr
,
1170 png_set_unknown_chunks(write_ptr
, write_end_info_ptr
, unknowns
,
1172 /* copy the locations from the read_info_ptr. The automatically
1173 generated locations in write_end_info_ptr are wrong because we
1174 haven't written the end_info yet */
1175 for (i
= 0; i
< (png_size_t
)num_unknowns
; i
++)
1176 png_set_unknown_chunk_location(write_ptr
, write_end_info_ptr
, i
,
1177 unknowns
[i
].location
);
1181 #ifdef PNG_WRITE_SUPPORTED
1182 png_write_end(write_ptr
, write_end_info_ptr
);
1185 #ifdef PNG_EASY_ACCESS_SUPPORTED
1188 png_uint_32 iwidth
, iheight
;
1189 iwidth
= png_get_image_width(write_ptr
, write_info_ptr
);
1190 iheight
= png_get_image_height(write_ptr
, write_info_ptr
);
1191 fprintf(STDERR
, "Image width = %lu, height = %lu\n",
1192 (unsigned long)iwidth
, (unsigned long)iheight
);
1196 png_debug(0, "Destroying data structs\n");
1197 #ifdef SINGLE_ROWBUF_ALLOC
1198 png_debug(1, "destroying row_buf for read_ptr\n");
1199 png_free(read_ptr
, row_buf
);
1201 #endif /* SINGLE_ROWBUF_ALLOC */
1202 png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr\n");
1203 png_destroy_read_struct(&read_ptr
, &read_info_ptr
, &end_info_ptr
);
1204 #ifdef PNG_WRITE_SUPPORTED
1205 png_debug(1, "destroying write_end_info_ptr\n");
1206 png_destroy_info_struct(write_ptr
, &write_end_info_ptr
);
1207 png_debug(1, "destroying write_ptr, write_info_ptr\n");
1208 png_destroy_write_struct(&write_ptr
, &write_info_ptr
);
1210 png_debug(0, "Destruction complete.\n");
1215 png_debug(0, "Opening files for comparison\n");
1216 #if defined(_WIN32_WCE)
1217 MultiByteToWideChar(CP_ACP
, 0, inname
, -1, path
, MAX_PATH
);
1218 if ((fpin
= CreateFile(path
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
)) == INVALID_HANDLE_VALUE
)
1220 if ((fpin
= fopen(inname
, "rb")) == NULL
)
1223 fprintf(STDERR
, "Could not find file %s\n", inname
);
1227 #if defined(_WIN32_WCE)
1228 MultiByteToWideChar(CP_ACP
, 0, outname
, -1, path
, MAX_PATH
);
1229 if ((fpout
= CreateFile(path
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
)) == INVALID_HANDLE_VALUE
)
1231 if ((fpout
= fopen(outname
, "rb")) == NULL
)
1234 fprintf(STDERR
, "Could not find file %s\n", outname
);
1241 png_size_t num_in
, num_out
;
1243 READFILE(fpin
, inbuf
, 1, num_in
);
1244 READFILE(fpout
, outbuf
, 1, num_out
);
1246 if (num_in
!= num_out
)
1248 fprintf(STDERR
, "\nFiles %s and %s are of a different size\n",
1250 if(wrote_question
== 0)
1253 " Was %s written with the same maximum IDAT chunk size (%d bytes),",
1254 inname
,PNG_ZBUF_SIZE
);
1256 "\n filtering heuristic (libpng default), compression");
1258 " level (zlib default),\n and zlib version (%s)?\n\n",
1270 if (png_memcmp(inbuf
, outbuf
, num_in
))
1272 fprintf(STDERR
, "\nFiles %s and %s are different\n", inname
, outname
);
1273 if(wrote_question
== 0)
1276 " Was %s written with the same maximum IDAT chunk size (%d bytes),",
1277 inname
,PNG_ZBUF_SIZE
);
1279 "\n filtering heuristic (libpng default), compression");
1281 " level (zlib default),\n and zlib version (%s)?\n\n",
1297 /* input and output filenames */
1299 static PNG_CONST
char *inname
= "pngtest/png";
1300 static PNG_CONST
char *outname
= "pngout/png";
1302 static PNG_CONST
char *inname
= "pngtest.png";
1303 static PNG_CONST
char *outname
= "pngout.png";
1307 main(int argc
, char *argv
[])
1312 fprintf(STDERR
, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING
);
1313 fprintf(STDERR
, " with zlib version %s\n", ZLIB_VERSION
);
1314 fprintf(STDERR
,"%s",png_get_copyright(NULL
));
1315 /* Show the version of libpng used in building the library */
1316 fprintf(STDERR
," library (%lu):%s",
1317 (unsigned long)png_access_version_number(),
1318 png_get_header_version(NULL
));
1319 /* Show the version of libpng used in building the application */
1320 fprintf(STDERR
," pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER
,
1321 PNG_HEADER_VERSION_STRING
);
1322 fprintf(STDERR
," png_sizeof(png_struct)=%ld, png_sizeof(png_info)=%ld\n",
1323 (long)png_sizeof(png_struct
), (long)png_sizeof(png_info
));
1325 /* Do some consistency checking on the memory allocation settings, I'm
1326 not sure this matters, but it is nice to know, the first of these
1327 tests should be impossible because of the way the macros are set
1329 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
1330 fprintf(STDERR
, " NOTE: Zlib compiled for max 64k, libpng not\n");
1332 /* I think the following can happen. */
1333 #if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
1334 fprintf(STDERR
, " NOTE: libpng compiled for max 64k, zlib not\n");
1337 if (strcmp(png_libpng_ver
, PNG_LIBPNG_VER_STRING
))
1340 "Warning: versions are different between png.h and png.c\n");
1341 fprintf(STDERR
, " png.h version: %s\n", PNG_LIBPNG_VER_STRING
);
1342 fprintf(STDERR
, " png.c version: %s\n\n", png_libpng_ver
);
1348 if (strcmp(argv
[1], "-m") == 0)
1351 status_dots_requested
= 0;
1353 else if (strcmp(argv
[1], "-mv") == 0 ||
1354 strcmp(argv
[1], "-vm") == 0 )
1358 status_dots_requested
= 1;
1360 else if (strcmp(argv
[1], "-v") == 0)
1363 status_dots_requested
= 1;
1369 status_dots_requested
= 0;
1373 if (!multiple
&& argc
== 3+verbose
)
1374 outname
= argv
[2+verbose
];
1376 if ((!multiple
&& argc
> 3+verbose
) || (multiple
&& argc
< 2))
1379 "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
1382 " reads/writes one PNG file (without -m) or multiple files (-m)\n");
1384 " with -m %s is used as a temporary file\n", outname
);
1391 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1392 int allocation_now
= current_allocation
;
1394 for (i
=2; i
<argc
; ++i
)
1396 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1400 fprintf(STDERR
, "Testing %s:",argv
[i
]);
1401 kerror
= test_one_file(argv
[i
], outname
);
1404 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
1405 fprintf(STDERR
, "\n PASS (%lu zero samples)\n",
1406 (unsigned long)zero_samples
);
1408 fprintf(STDERR
, " PASS\n");
1410 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1411 for (k
=0; k
<256; k
++)
1413 fprintf(STDERR
, " Filter %d was used %lu times\n",
1414 k
,(unsigned long)filters_used
[k
]);
1416 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1417 if(tIME_chunk_present
!= 0)
1418 fprintf(STDERR
, " tIME = %s\n",tIME_string
);
1419 tIME_chunk_present
= 0;
1420 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1424 fprintf(STDERR
, " FAIL\n");
1427 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1428 if (allocation_now
!= current_allocation
)
1429 fprintf(STDERR
, "MEMORY ERROR: %d bytes lost\n",
1430 current_allocation
-allocation_now
);
1431 if (current_allocation
!= 0)
1433 memory_infop pinfo
= pinformation
;
1435 fprintf(STDERR
, "MEMORY ERROR: %d bytes still allocated\n",
1436 current_allocation
);
1437 while (pinfo
!= NULL
)
1439 fprintf(STDERR
, " %lu bytes at %x\n", (unsigned long)pinfo
->size
,
1440 (unsigned int) pinfo
->pointer
);
1441 pinfo
= pinfo
->next
;
1446 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1447 fprintf(STDERR
, " Current memory allocation: %10d bytes\n",
1448 current_allocation
);
1449 fprintf(STDERR
, " Maximum memory allocation: %10d bytes\n",
1450 maximum_allocation
);
1451 fprintf(STDERR
, " Total memory allocation: %10d bytes\n",
1453 fprintf(STDERR
, " Number of allocations: %10d\n",
1463 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1464 int allocation_now
= current_allocation
;
1466 if (i
== 1) status_dots_requested
= 1;
1467 else if(verbose
== 0)status_dots_requested
= 0;
1468 if (i
== 0 || verbose
== 1 || ierror
!= 0)
1469 fprintf(STDERR
, "Testing %s:",inname
);
1470 kerror
= test_one_file(inname
, outname
);
1473 if(verbose
== 1 || i
== 2)
1475 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1478 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
1479 fprintf(STDERR
, "\n PASS (%lu zero samples)\n",
1480 (unsigned long)zero_samples
);
1482 fprintf(STDERR
, " PASS\n");
1484 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1485 for (k
=0; k
<256; k
++)
1487 fprintf(STDERR
, " Filter %d was used %lu times\n",
1488 k
,(unsigned long)filters_used
[k
]);
1490 #if defined(PNG_TIME_RFC1123_SUPPORTED)
1491 if(tIME_chunk_present
!= 0)
1492 fprintf(STDERR
, " tIME = %s\n",tIME_string
);
1493 #endif /* PNG_TIME_RFC1123_SUPPORTED */
1498 if(verbose
== 0 && i
!= 2)
1499 fprintf(STDERR
, "Testing %s:",inname
);
1500 fprintf(STDERR
, " FAIL\n");
1503 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1504 if (allocation_now
!= current_allocation
)
1505 fprintf(STDERR
, "MEMORY ERROR: %d bytes lost\n",
1506 current_allocation
-allocation_now
);
1507 if (current_allocation
!= 0)
1509 memory_infop pinfo
= pinformation
;
1511 fprintf(STDERR
, "MEMORY ERROR: %d bytes still allocated\n",
1512 current_allocation
);
1513 while (pinfo
!= NULL
)
1515 fprintf(STDERR
," %lu bytes at %x\n",
1516 (unsigned long)pinfo
->size
, (unsigned int)pinfo
->pointer
);
1517 pinfo
= pinfo
->next
;
1522 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1523 fprintf(STDERR
, " Current memory allocation: %10d bytes\n",
1524 current_allocation
);
1525 fprintf(STDERR
, " Maximum memory allocation: %10d bytes\n",
1526 maximum_allocation
);
1527 fprintf(STDERR
, " Total memory allocation: %10d bytes\n",
1529 fprintf(STDERR
, " Number of allocations: %10d\n",
1534 #ifdef PNGTEST_TIMING
1535 t_stop
= (float)clock();
1536 t_misc
+= (t_stop
- t_start
);
1538 fprintf(STDERR
," CPU time used = %.3f seconds",
1539 (t_misc
+t_decode
+t_encode
)/(float)CLOCKS_PER_SEC
);
1540 fprintf(STDERR
," (decoding %.3f,\n",
1541 t_decode
/(float)CLOCKS_PER_SEC
);
1542 fprintf(STDERR
," encoding %.3f ,",
1543 t_encode
/(float)CLOCKS_PER_SEC
);
1544 fprintf(STDERR
," other %.3f seconds)\n\n",
1545 t_misc
/(float)CLOCKS_PER_SEC
);
1549 fprintf(STDERR
, "libpng passes test\n");
1551 fprintf(STDERR
, "libpng FAILS test\n");
1552 return (int)(ierror
!= 0);
1555 /* Generate a compiler error if there is an old png.h in the search path. */
1556 typedef version_1_2_24 your_png_h_is_not_version_1_2_24
;