← Back to branch summary

~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/LibPNG/pngtest.c

  • Committer: Bazaar Package Importer
  • Author(s): Cosme Domínguez Díaz
  • Date: 2010-07-20 13:42:15 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100720134215-xt1454zaedv3b604
Tags: 3.13.1-0ubuntu1
https://launchpad.net/bugs/607800
* New upstream release. Closes: (LP: #607800)
 - Updated debian/freeimage-get-orig-source script.
 - Removing no longer necessary debian/patches/* and
   the patch system in debian/rules.
 - Updated debian/rules to work with the new Makefiles.
 - Drop from -O3 to -O2 and use lzma compression saves
   ~10 MB of free space. 
* lintian stuff
 - fixed debhelper-but-no-misc-depends
 - fixed ldconfig-symlink-missing-for-shlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/LibPNG/pngtest.c
1
1
 
2
2
/* pngtest.c - a simple test program to test libpng
3
3
 *
4
 
 * Last changed in libpng 1.2.22 - [November 6, 2007]
5
 
 * For conditions of distribution and use, see copyright notice in png.h
6
 
 * Copyright (c) 1998-2004 Glenn Randers-Pehrson
 
4
 * Last changed in libpng 1.2.41 [December 3, 2009]
 
5
 * Copyright (c) 1998-2009 Glenn Randers-Pehrson
7
6
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
8
7
 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9
8
 *
 
9
 * This code is released under the libpng license.
 
10
 * For conditions of distribution and use, see the disclaimer
 
11
 * and license in png.h
 
12
 *
10
13
 * This program reads in a PNG image, writes it out again, and then
11
14
 * compares the two files.  If the files are identical, this shows that
12
15
 * the basic chunk handling, filtering, and (de)compression code is working
28
31
 * of files at once by typing "pngtest -m file1.png file2.png ..."
29
32
 */
30
33
 
 
34
#define PNG_PEDANTIC_WARNINGS
31
35
#include "png.h"
32
36
 
33
 
#if defined(_WIN32_WCE)
 
37
#ifdef _WIN32_WCE
34
38
#  if _WIN32_WCE < 211
35
39
     __error__ (f|w)printf functions are not supported on old WindowsCE.;
36
40
#  endif
37
41
#  include <windows.h>
38
42
#  include <stdlib.h>
39
43
#  define READFILE(file, data, length, check) \
40
 
     if (ReadFile(file, data, length, &check,NULL)) check = 0
 
44
     if (ReadFile(file, data, length, &check, NULL)) check = 0
41
45
#  define WRITEFILE(file, data, length, check)) \
42
46
     if (WriteFile(file, data, length, &check, NULL)) check = 0
43
47
#  define FCLOSE(file) CloseHandle(file)
45
49
#  include <stdio.h>
46
50
#  include <stdlib.h>
47
51
#  define READFILE(file, data, length, check) \
48
 
     check=(png_size_t)fread(data,(png_size_t)1,length,file)
 
52
     check=(png_size_t)fread(data, (png_size_t)1, length, file)
49
53
#  define WRITEFILE(file, data, length, check) \
50
 
     check=(png_size_t)fwrite(data,(png_size_t)1, length, file)
 
54
     check=(png_size_t)fwrite(data, (png_size_t)1, length, file)
51
55
#  define FCLOSE(file) fclose(file)
52
56
#endif
53
57
 
54
 
#if defined(PNG_NO_STDIO)
55
 
#  if defined(_WIN32_WCE)
 
58
#ifndef PNG_STDIO_SUPPORTED
 
59
#  ifdef _WIN32_WCE
56
60
     typedef HANDLE                png_FILE_p;
57
61
#  else
58
62
     typedef FILE                * png_FILE_p;
65
69
#endif
66
70
 
67
71
#if !PNG_DEBUG
68
 
#  define SINGLE_ROWBUF_ALLOC  /* makes buffer overruns easier to nail */
 
72
#  define SINGLE_ROWBUF_ALLOC  /* Makes buffer overruns easier to nail */
69
73
#endif
70
74
 
71
75
/* Turn on CPU timing
72
76
#define PNGTEST_TIMING
73
77
*/
74
78
 
75
 
#ifdef PNG_NO_FLOATING_POINT_SUPPORTED
 
79
#ifndef PNG_FLOATING_POINT_SUPPORTED
76
80
#undef PNGTEST_TIMING
77
81
#endif
78
82
 
81
85
#include <time.h>
82
86
#endif
83
87
 
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
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
89
#define PNG_tIME_STRING_LENGTH 29
 
90
static int tIME_chunk_present = 0;
 
91
static char tIME_string[PNG_tIME_STRING_LENGTH] = "tIME chunk is not present";
88
92
#endif
89
93
 
90
94
static int verbose = 0;
95
99
#include <mem.h>
96
100
#endif
97
101
 
98
 
/* defined so I can write to a file on gui/windowing platforms */
 
102
/* Defined so I can write to a file on gui/windowing platforms */
99
103
/*  #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;
 
104
#define STDERR stdout   /* For DOS */
106
105
 
107
106
/* In case a system header (e.g., on AIX) defined jmpbuf */
108
107
#ifdef jmpbuf
114
113
#  define png_jmpbuf(png_ptr) png_ptr->jmpbuf
115
114
#endif
116
115
 
 
116
/* Example of using row callbacks to make a simple progress meter */
 
117
static int status_pass = 1;
 
118
static int status_dots_requested = 0;
 
119
static int status_dots = 1;
 
120
 
117
121
void
118
122
#ifdef PNG_1_0_X
119
123
PNGAPI
125
129
#endif
126
130
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
127
131
{
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");
 
132
   if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
 
133
      return;
 
134
   if (status_pass != pass)
 
135
   {
 
136
      fprintf(stdout, "\n Pass %d: ", pass);
 
137
      status_pass = pass;
 
138
      status_dots = 31;
 
139
   }
 
140
   status_dots--;
 
141
   if (status_dots == 0)
 
142
   {
 
143
      fprintf(stdout, "\n         ");
 
144
      status_dots=30;
 
145
   }
 
146
   fprintf(stdout, "r");
142
147
}
143
148
 
144
149
void
152
157
#endif
153
158
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
154
159
{
155
 
    if(png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7) return;
156
 
    fprintf(stdout, "w");
 
160
   if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
 
161
      return;
 
162
   fprintf(stdout, "w");
157
163
}
158
164
 
159
165
 
160
 
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 
166
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
161
167
/* 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.) */
 
168
 * but merely examine the row filters.  We set this to 256 rather than
 
169
 * 5 in case illegal filter values are present.)
 
170
 */
164
171
static png_uint_32 filters_used[256];
165
172
void
166
173
#ifdef PNG_1_0_X
173
180
#endif
174
181
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
175
182
{
176
 
    if(png_ptr != NULL && row_info != NULL)
177
 
      ++filters_used[*(data-1)];
 
183
   if (png_ptr != NULL && row_info != NULL)
 
184
      ++filters_used[*(data - 1)];
178
185
}
179
186
#endif
180
187
 
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) */
 
188
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
 
189
/* Example of using user transform callback (we don't transform anything,
 
190
 * but merely count the zero samples)
 
191
 */
184
192
 
185
193
static png_uint_32 zero_samples;
186
194
 
196
204
count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
197
205
{
198
206
   png_bytep dp = data;
199
 
   if(png_ptr == NULL)return;
 
207
   if (png_ptr == NULL)return;
200
208
 
201
 
   /* contents of row_info:
 
209
   /* Contents of row_info:
202
210
    *  png_uint_32 width      width of row
203
211
    *  png_uint_32 rowbytes   number of bytes in row
204
212
    *  png_byte color_type    color type of pixels
207
215
    *  png_byte pixel_depth   bits per pixel (depth*channels)
208
216
    */
209
217
 
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)
 
218
    /* Counts the number of zero samples (or zero pixels if color_type is 3 */
 
219
 
 
220
    if (row_info->color_type == 0 || row_info->color_type == 3)
214
221
    {
215
 
       int pos=0;
 
222
       int pos = 0;
216
223
       png_uint_32 n, nstop;
217
 
       for (n=0, nstop=row_info->width; n<nstop; n++)
 
224
       for (n = 0, nstop=row_info->width; n<nstop; n++)
218
225
       {
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++;
 
226
          if (row_info->bit_depth == 1)
 
227
          {
 
228
             if (((*dp << pos++ ) & 0x80) == 0)
 
229
                zero_samples++;
 
230
             if (pos == 8)
 
231
             {
 
232
                pos = 0;
 
233
                dp++;
 
234
             }
 
235
          }
 
236
          if (row_info->bit_depth == 2)
 
237
          {
 
238
             if (((*dp << (pos+=2)) & 0xc0) == 0)
 
239
                zero_samples++;
 
240
             if (pos == 8)
 
241
             {
 
242
                pos = 0;
 
243
                dp++;
 
244
             }
 
245
          }
 
246
          if (row_info->bit_depth == 4)
 
247
          {
 
248
             if (((*dp << (pos+=4)) & 0xf0) == 0)
 
249
                zero_samples++;
 
250
             if (pos == 8)
 
251
             {
 
252
                pos = 0;
 
253
                dp++;
 
254
             }
 
255
          }
 
256
          if (row_info->bit_depth == 8)
 
257
             if (*dp++ == 0)
 
258
                zero_samples++;
 
259
          if (row_info->bit_depth == 16)
 
260
          {
 
261
             if ((*dp | *(dp+1)) == 0)
 
262
                zero_samples++;
251
263
             dp+=2;
252
264
          }
253
265
       }
254
266
    }
255
 
    else /* other color types */
 
267
    else /* Other color types */
256
268
    {
257
269
       png_uint_32 n, nstop;
258
270
       int channel;
259
271
       int color_channels = row_info->channels;
260
 
       if(row_info->color_type > 3)color_channels--;
 
272
       if (row_info->color_type > 3)color_channels--;
261
273
 
262
 
       for (n=0, nstop=row_info->width; n<nstop; n++)
 
274
       for (n = 0, nstop=row_info->width; n<nstop; n++)
263
275
       {
264
276
          for (channel = 0; channel < color_channels; channel++)
265
277
          {
266
 
             if(row_info->bit_depth == 8)
267
 
                if(*dp++ == 0) zero_samples++;
268
 
             if(row_info->bit_depth == 16)
 
278
             if (row_info->bit_depth == 8)
 
279
                if (*dp++ == 0)
 
280
                   zero_samples++;
 
281
             if (row_info->bit_depth == 16)
269
282
             {
270
 
                if((*dp | *(dp+1)) == 0) zero_samples++;
 
283
                if ((*dp | *(dp+1)) == 0)
 
284
                   zero_samples++;
271
285
                dp+=2;
272
286
             }
273
287
          }
274
 
          if(row_info->color_type > 3)
 
288
          if (row_info->color_type > 3)
275
289
          {
276
290
             dp++;
277
 
             if(row_info->bit_depth == 16)dp++;
 
291
             if (row_info->bit_depth == 16)
 
292
                dp++;
278
293
          }
279
294
       }
280
295
    }
283
298
 
284
299
static int wrote_question = 0;
285
300
 
286
 
#if defined(PNG_NO_STDIO)
 
301
#ifndef PNG_STDIO_SUPPORTED
287
302
/* 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. */
 
303
/* These copies of the default read/write functions come from pngrio.c and
 
304
 * pngwio.c.  They allow "don't include stdio" testing of the library.
 
305
 * This is the function that does the actual reading of data.  If you are
 
306
 * not reading from a standard C stream, you should create a replacement
 
307
 * read_data function and use it at run time with png_set_read_fn(), rather
 
308
 * than changing the library.
 
309
 */
294
310
 
295
311
#ifndef USE_FAR_KEYWORD
296
312
static void
309
325
   }
310
326
}
311
327
#else
312
 
/* this is the model-independent version. Since the standard I/O library
 
328
/* This is the model-independent version. Since the standard I/O library
313
329
   can't handle far buffers in the medium and small models, we have to copy
314
330
   the data.
315
331
*/
341
357
      {
342
358
         read = MIN(NEAR_BUF_SIZE, remaining);
343
359
         READFILE(io_ptr, buf, 1, err);
344
 
         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
345
 
         if(err != read)
 
360
         png_memcpy(data, buf, read); /* Copy far buffer to near buffer */
 
361
         if (err != read)
346
362
            break;
347
363
         else
348
364
            check += err;
352
368
      while (remaining != 0);
353
369
   }
354
370
   if (check != length)
355
 
   {
356
371
      png_error(png_ptr, "read Error");
357
 
   }
358
372
}
359
373
#endif /* USE_FAR_KEYWORD */
360
374
 
361
 
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
 
375
#ifdef PNG_WRITE_FLUSH_SUPPORTED
362
376
static void
363
377
pngtest_flush(png_structp png_ptr)
364
378
{
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
 
379
   /* Do nothing; fflush() is said to be just a waste of energy. */
 
380
   png_ptr = png_ptr;  /* Stifle compiler warning */
371
381
}
372
382
#endif
373
383
 
374
384
/* 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. */
 
385
 * not writing to a standard C stream, you should create a replacement
 
386
 * write_data function and use it at run time with png_set_write_fn(), rather
 
387
 * than changing the library.
 
388
 */
378
389
#ifndef USE_FAR_KEYWORD
379
390
static void
380
391
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
388
399
   }
389
400
}
390
401
#else
391
 
/* this is the model-independent version. Since the standard I/O library
 
402
/* This is the model-independent version. Since the standard I/O library
392
403
   can't handle far buffers in the medium and small models, we have to copy
393
404
   the data.
394
405
*/
419
430
      do
420
431
      {
421
432
         written = MIN(NEAR_BUF_SIZE, remaining);
422
 
         png_memcpy(buf, data, written); /* copy far buffer to near buffer */
 
433
         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
423
434
         WRITEFILE(io_ptr, buf, written, err);
424
435
         if (err != written)
425
436
            break;
436
447
   }
437
448
}
438
449
#endif /* USE_FAR_KEYWORD */
439
 
#endif /* PNG_NO_STDIO */
440
 
/* END of code to validate stdio-free compilation */
441
450
 
442
451
/* This function is called when there is a warning, but the library thinks
443
452
 * it can continue anyway.  Replacement functions don't have to do anything
463
472
{
464
473
   pngtest_warning(png_ptr, message);
465
474
   /* We can return because png_error calls the default handler, which is
466
 
    * actually OK in this case. */
 
475
    * actually OK in this case.
 
476
    */
467
477
}
 
478
#endif /* !PNG_STDIO_SUPPORTED */
 
479
/* END of code to validate stdio-free compilation */
468
480
 
469
481
/* START of code to validate memory allocation and deallocation */
470
482
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
471
483
 
472
484
/* 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. */
 
485
 * 64K.  However, zlib may allocate more then 64K if you don't tell
 
486
 * it not to.  See zconf.h and png.h for more information.  zlib does
 
487
 * need to allocate exactly 64K, so whatever you call here must
 
488
 * have the ability to do that.
 
489
 *
 
490
 * This piece of code can be compiled to validate max 64K allocations
 
491
 * by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K.
 
492
 */
480
493
typedef struct memory_information
481
494
{
482
495
   png_uint_32               size;
499
512
{
500
513
 
501
514
   /* png_malloc has already tested for NULL; png_create_struct calls
502
 
      png_debug_malloc directly, with png_ptr == NULL which is OK */
 
515
    * png_debug_malloc directly, with png_ptr == NULL which is OK
 
516
    */
503
517
 
504
518
   if (size == 0)
505
519
      return (NULL);
511
525
      memory_infop pinfo;
512
526
      png_set_mem_fn(png_ptr, NULL, NULL, NULL);
513
527
      pinfo = (memory_infop)png_malloc(png_ptr,
514
 
         (png_uint_32)png_sizeof (*pinfo));
 
528
         (png_uint_32)png_sizeof(*pinfo));
515
529
      pinfo->size = size;
516
530
      current_allocation += size;
517
531
      total_allocation += size;
520
534
         maximum_allocation = current_allocation;
521
535
      pinfo->pointer = (png_voidp)png_malloc(png_ptr, size);
522
536
      /* 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);
 
537
      png_set_mem_fn(png_ptr,
 
538
          png_voidp_NULL, (png_malloc_ptr)png_debug_malloc,
 
539
          (png_free_ptr)png_debug_free);
525
540
      if (size != 0 && pinfo->pointer == NULL)
526
541
      {
527
542
         current_allocation -= size;
533
548
      pinformation = pinfo;
534
549
      /* Make sure the caller isn't assuming zeroed memory. */
535
550
      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);
 
551
      if (verbose)
 
552
         printf("png_malloc %lu bytes at %x\n", (unsigned long)size,
 
553
            pinfo->pointer);
539
554
      return (png_voidp)(pinfo->pointer);
540
555
   }
541
556
}
570
585
               the memory that is to be freed. */
571
586
            png_memset(ptr, 0x55, pinfo->size);
572
587
            png_free_default(png_ptr, pinfo);
573
 
            pinfo=NULL;
 
588
            pinfo = NULL;
574
589
            break;
575
590
         }
576
591
         if (pinfo->next == NULL)
583
598
   }
584
599
 
585
600
   /* Finally free the data. */
586
 
   if(verbose)
587
 
      printf("Freeing %x\n",ptr);
 
601
   if (verbose)
 
602
      printf("Freeing %x\n", ptr);
588
603
   png_free_default(png_ptr, ptr);
589
 
   ptr=NULL;
 
604
   ptr = NULL;
590
605
}
591
606
#endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */
592
607
/* END of code to test memory allocation/deallocation */
593
608
 
 
609
 
 
610
/* Demonstration of user chunk support of the sTER and vpAg chunks */
 
611
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
 
612
 
 
613
/* (sTER is a public chunk not yet known by libpng.  vpAg is a private
 
614
chunk used in ImageMagick to store "virtual page" size).  */
 
615
 
 
616
static png_uint_32 user_chunk_data[4];
 
617
 
 
618
    /* 0: sTER mode + 1
 
619
     * 1: vpAg width
 
620
     * 2: vpAg height
 
621
     * 3: vpAg units
 
622
     */
 
623
 
 
624
static int read_user_chunk_callback(png_struct *png_ptr,
 
625
   png_unknown_chunkp chunk)
 
626
{
 
627
   png_uint_32
 
628
     *my_user_chunk_data;
 
629
 
 
630
   /* Return one of the following:
 
631
    *    return (-n);  chunk had an error
 
632
    *    return (0);  did not recognize
 
633
    *    return (n);  success
 
634
    *
 
635
    * The unknown chunk structure contains the chunk data:
 
636
    * png_byte name[5];
 
637
    * png_byte *data;
 
638
    * png_size_t size;
 
639
    *
 
640
    * Note that libpng has already taken care of the CRC handling.
 
641
    */
 
642
 
 
643
   if (chunk->name[0] == 115 && chunk->name[1] ==  84 &&     /* s  T */
 
644
       chunk->name[2] ==  69 && chunk->name[3] ==  82)       /* E  R */
 
645
      {
 
646
         /* Found sTER chunk */
 
647
         if (chunk->size != 1)
 
648
            return (-1); /* Error return */
 
649
         if (chunk->data[0] != 0 && chunk->data[0] != 1)
 
650
            return (-1);  /* Invalid mode */
 
651
         my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
 
652
         my_user_chunk_data[0]=chunk->data[0]+1;
 
653
         return (1);
 
654
      }
 
655
 
 
656
   if (chunk->name[0] != 118 || chunk->name[1] != 112 ||    /* v  p */
 
657
       chunk->name[2] !=  65 || chunk->name[3] != 103)      /* A  g */
 
658
      return (0); /* Did not recognize */
 
659
 
 
660
   /* Found ImageMagick vpAg chunk */
 
661
 
 
662
   if (chunk->size != 9)
 
663
      return (-1); /* Error return */
 
664
 
 
665
   my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
 
666
 
 
667
   my_user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);
 
668
   my_user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);
 
669
   my_user_chunk_data[3]=(png_uint_32)chunk->data[8];
 
670
 
 
671
   return (1);
 
672
 
 
673
}
 
674
#endif
 
675
/* END of code to demonstrate user chunk support */
 
676
 
594
677
/* Test one file */
595
678
int
596
679
test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
619
702
#endif
620
703
#endif
621
704
 
622
 
#if defined(_WIN32_WCE)
 
705
#ifdef _WIN32_WCE
623
706
   TCHAR path[MAX_PATH];
624
707
#endif
625
708
   char inbuf[256], outbuf[256];
626
709
 
627
710
   row_buf = NULL;
628
711
 
629
 
#if defined(_WIN32_WCE)
 
712
#ifdef _WIN32_WCE
630
713
   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);
631
714
   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
632
715
#else
637
720
      return (1);
638
721
   }
639
722
 
640
 
#if defined(_WIN32_WCE)
 
723
#ifdef _WIN32_WCE
641
724
   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);
642
725
   if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)
643
726
#else
649
732
      return (1);
650
733
   }
651
734
 
652
 
   png_debug(0, "Allocating read and write structures\n");
 
735
   png_debug(0, "Allocating read and write structures");
653
736
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
654
 
   read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
 
737
   read_ptr =
 
738
      png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
655
739
      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,
656
740
      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
657
741
#else
658
 
   read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
 
742
   read_ptr =
 
743
      png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
659
744
      png_error_ptr_NULL, png_error_ptr_NULL);
660
745
#endif
 
746
#ifndef PNG_STDIO_SUPPORTED
661
747
   png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,
662
748
       pngtest_warning);
 
749
#endif
 
750
 
 
751
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
 
752
   user_chunk_data[0] = 0;
 
753
   user_chunk_data[1] = 0;
 
754
   user_chunk_data[2] = 0;
 
755
   user_chunk_data[3] = 0;
 
756
   png_set_read_user_chunk_fn(read_ptr, user_chunk_data,
 
757
     read_user_chunk_callback);
 
758
 
 
759
#endif
663
760
#ifdef PNG_WRITE_SUPPORTED
664
761
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
665
 
   write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
 
762
   write_ptr =
 
763
      png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
666
764
      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,
667
765
      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
668
766
#else
669
 
   write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
 
767
   write_ptr =
 
768
      png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,
670
769
      png_error_ptr_NULL, png_error_ptr_NULL);
671
770
#endif
 
771
#ifndef PNG_STDIO_SUPPORTED
672
772
   png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,
673
773
       pngtest_warning);
674
774
#endif
675
 
   png_debug(0, "Allocating read_info, write_info and end_info structures\n");
 
775
#endif
 
776
   png_debug(0, "Allocating read_info, write_info and end_info structures");
676
777
   read_info_ptr = png_create_info_struct(read_ptr);
677
778
   end_info_ptr = png_create_info_struct(read_ptr);
678
779
#ifdef PNG_WRITE_SUPPORTED
681
782
#endif
682
783
 
683
784
#ifdef PNG_SETJMP_SUPPORTED
684
 
   png_debug(0, "Setting jmpbuf for read struct\n");
 
785
   png_debug(0, "Setting jmpbuf for read struct");
685
786
#ifdef USE_FAR_KEYWORD
686
787
   if (setjmp(jmpbuf))
687
788
#else
689
790
#endif
690
791
   {
691
792
      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
692
 
      if (row_buf)
693
 
         png_free(read_ptr, row_buf);
 
793
      png_free(read_ptr, row_buf);
 
794
      row_buf = NULL;
694
795
      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
695
796
#ifdef PNG_WRITE_SUPPORTED
696
797
      png_destroy_info_struct(write_ptr, &write_end_info_ptr);
701
802
      return (1);
702
803
   }
703
804
#ifdef USE_FAR_KEYWORD
704
 
   png_memcpy(png_jmpbuf(read_ptr),jmpbuf,png_sizeof(jmp_buf));
 
805
   png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf));
705
806
#endif
706
807
 
707
808
#ifdef PNG_WRITE_SUPPORTED
708
 
   png_debug(0, "Setting jmpbuf for write struct\n");
 
809
   png_debug(0, "Setting jmpbuf for write struct");
709
810
#ifdef USE_FAR_KEYWORD
710
811
   if (setjmp(jmpbuf))
711
812
#else
723
824
      return (1);
724
825
   }
725
826
#ifdef USE_FAR_KEYWORD
726
 
   png_memcpy(png_jmpbuf(write_ptr),jmpbuf,png_sizeof(jmp_buf));
 
827
   png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf));
727
828
#endif
728
829
#endif
729
830
#endif
730
831
 
731
 
   png_debug(0, "Initializing input and output streams\n");
732
 
#if !defined(PNG_NO_STDIO)
 
832
   png_debug(0, "Initializing input and output streams");
 
833
#ifdef PNG_STDIO_SUPPORTED
733
834
   png_init_io(read_ptr, fpin);
734
835
#  ifdef PNG_WRITE_SUPPORTED
735
836
   png_init_io(write_ptr, fpout);
738
839
   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);
739
840
#  ifdef PNG_WRITE_SUPPORTED
740
841
   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,
741
 
#    if defined(PNG_WRITE_FLUSH_SUPPORTED)
 
842
#    ifdef PNG_WRITE_FLUSH_SUPPORTED
742
843
      pngtest_flush);
743
844
#    else
744
845
      NULL);
745
846
#    endif
746
847
#  endif
747
848
#endif
748
 
   if(status_dots_requested == 1)
 
849
   if (status_dots_requested == 1)
749
850
   {
750
851
#ifdef PNG_WRITE_SUPPORTED
751
852
      png_set_write_status_fn(write_ptr, write_row_callback);
760
861
      png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL);
761
862
   }
762
863
 
763
 
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 
864
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
764
865
   {
765
 
     int i;
766
 
     for(i=0; i<256; i++)
767
 
        filters_used[i]=0;
768
 
     png_set_read_user_transform_fn(read_ptr, count_filters);
 
866
      int i;
 
867
      for (i = 0; i<256; i++)
 
868
         filters_used[i] = 0;
 
869
      png_set_read_user_transform_fn(read_ptr, count_filters);
769
870
   }
770
871
#endif
771
 
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
772
 
   zero_samples=0;
 
872
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
 
873
   zero_samples = 0;
773
874
   png_set_write_user_transform_fn(write_ptr, count_zero_samples);
774
875
#endif
775
876
 
776
 
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
 
877
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
777
878
#  ifndef PNG_HANDLE_CHUNK_ALWAYS
778
879
#    define PNG_HANDLE_CHUNK_ALWAYS       3
779
880
#  endif
780
881
   png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,
781
882
      png_bytep_NULL, 0);
782
883
#endif
783
 
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
 
884
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
784
885
#  ifndef PNG_HANDLE_CHUNK_IF_SAFE
785
886
#    define PNG_HANDLE_CHUNK_IF_SAFE      2
786
887
#  endif
788
889
      png_bytep_NULL, 0);
789
890
#endif
790
891
 
791
 
   png_debug(0, "Reading info struct\n");
 
892
   png_debug(0, "Reading info struct");
792
893
   png_read_info(read_ptr, read_info_ptr);
793
894
 
794
 
   png_debug(0, "Transferring info struct\n");
 
895
   png_debug(0, "Transferring info struct");
795
896
   {
796
897
      int interlace_type, compression_type, filter_type;
797
898
 
799
900
          &color_type, &interlace_type, &compression_type, &filter_type))
800
901
      {
801
902
         png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
802
 
#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
 
903
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
803
904
            color_type, interlace_type, compression_type, filter_type);
804
905
#else
805
906
            color_type, PNG_INTERLACE_NONE, compression_type, filter_type);
806
907
#endif
807
908
      }
808
909
   }
809
 
#if defined(PNG_FIXED_POINT_SUPPORTED)
810
 
#if defined(PNG_cHRM_SUPPORTED)
 
910
#ifdef PNG_FIXED_POINT_SUPPORTED
 
911
#ifdef PNG_cHRM_SUPPORTED
811
912
   {
812
913
      png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
813
914
         blue_y;
819
920
      }
820
921
   }
821
922
#endif
822
 
#if defined(PNG_gAMA_SUPPORTED)
 
923
#ifdef PNG_gAMA_SUPPORTED
823
924
   {
824
925
      png_fixed_point gamma;
825
926
 
826
927
      if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))
827
 
      {
828
928
         png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
829
 
      }
830
929
   }
831
930
#endif
832
931
#else /* Use floating point versions */
833
 
#if defined(PNG_FLOATING_POINT_SUPPORTED)
834
 
#if defined(PNG_cHRM_SUPPORTED)
 
932
#ifdef PNG_FLOATING_POINT_SUPPORTED
 
933
#ifdef PNG_cHRM_SUPPORTED
835
934
   {
836
935
      double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
837
936
         blue_y;
843
942
      }
844
943
   }
845
944
#endif
846
 
#if defined(PNG_gAMA_SUPPORTED)
 
945
#ifdef PNG_gAMA_SUPPORTED
847
946
   {
848
947
      double gamma;
849
948
 
850
949
      if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
851
 
      {
852
950
         png_set_gAMA(write_ptr, write_info_ptr, gamma);
853
 
      }
854
951
   }
855
952
#endif
856
 
#endif /* floating point */
857
 
#endif /* fixed point */
858
 
#if defined(PNG_iCCP_SUPPORTED)
 
953
#endif /* Floating point */
 
954
#endif /* Fixed point */
 
955
#ifdef PNG_iCCP_SUPPORTED
859
956
   {
860
957
      png_charp name;
861
958
      png_charp profile;
870
967
      }
871
968
   }
872
969
#endif
873
 
#if defined(PNG_sRGB_SUPPORTED)
 
970
#ifdef PNG_sRGB_SUPPORTED
874
971
   {
875
972
      int intent;
876
973
 
877
974
      if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
878
 
      {
879
975
         png_set_sRGB(write_ptr, write_info_ptr, intent);
880
 
      }
881
976
   }
882
977
#endif
883
978
   {
885
980
      int num_palette;
886
981
 
887
982
      if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
888
 
      {
889
983
         png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
890
 
      }
891
984
   }
892
 
#if defined(PNG_bKGD_SUPPORTED)
 
985
#ifdef PNG_bKGD_SUPPORTED
893
986
   {
894
987
      png_color_16p background;
895
988
 
899
992
      }
900
993
   }
901
994
#endif
902
 
#if defined(PNG_hIST_SUPPORTED)
 
995
#ifdef PNG_hIST_SUPPORTED
903
996
   {
904
997
      png_uint_16p hist;
905
998
 
906
999
      if (png_get_hIST(read_ptr, read_info_ptr, &hist))
907
 
      {
908
1000
         png_set_hIST(write_ptr, write_info_ptr, hist);
909
 
      }
910
1001
   }
911
1002
#endif
912
 
#if defined(PNG_oFFs_SUPPORTED)
 
1003
#ifdef PNG_oFFs_SUPPORTED
913
1004
   {
914
1005
      png_int_32 offset_x, offset_y;
915
1006
      int unit_type;
916
1007
 
917
 
      if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type))
 
1008
      if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
 
1009
          &unit_type))
918
1010
      {
919
1011
         png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
920
1012
      }
921
1013
   }
922
1014
#endif
923
 
#if defined(PNG_pCAL_SUPPORTED)
 
1015
#ifdef PNG_pCAL_SUPPORTED
924
1016
   {
925
1017
      png_charp purpose, units;
926
1018
      png_charpp params;
935
1027
      }
936
1028
   }
937
1029
#endif
938
 
#if defined(PNG_pHYs_SUPPORTED)
 
1030
#ifdef PNG_pHYs_SUPPORTED
939
1031
   {
940
1032
      png_uint_32 res_x, res_y;
941
1033
      int unit_type;
942
1034
 
943
1035
      if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
944
 
      {
945
1036
         png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
946
 
      }
947
1037
   }
948
1038
#endif
949
 
#if defined(PNG_sBIT_SUPPORTED)
 
1039
#ifdef PNG_sBIT_SUPPORTED
950
1040
   {
951
1041
      png_color_8p sig_bit;
952
1042
 
953
1043
      if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
954
 
      {
955
1044
         png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
956
 
      }
957
1045
   }
958
1046
#endif
959
 
#if defined(PNG_sCAL_SUPPORTED)
 
1047
#ifdef PNG_sCAL_SUPPORTED
960
1048
#ifdef PNG_FLOATING_POINT_SUPPORTED
961
1049
   {
962
1050
      int unit;
983
1071
#endif
984
1072
#endif
985
1073
#endif
986
 
#if defined(PNG_TEXT_SUPPORTED)
 
1074
#ifdef PNG_TEXT_SUPPORTED
987
1075
   {
988
1076
      png_textp text_ptr;
989
1077
      int num_text;
990
1078
 
991
1079
      if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
992
1080
      {
993
 
         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);
 
1081
         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);
994
1082
         png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
995
1083
      }
996
1084
   }
997
1085
#endif
998
 
#if defined(PNG_tIME_SUPPORTED)
 
1086
#ifdef PNG_tIME_SUPPORTED
999
1087
   {
1000
1088
      png_timep mod_time;
1001
1089
 
1002
1090
      if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
1003
1091
      {
1004
1092
         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
1008
 
            we use it */
 
1093
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
1094
         /* We have to use png_memcpy instead of "=" because the string
 
1095
          * pointed to by png_convert_to_rfc1123() gets free'ed before
 
1096
          * we use it.
 
1097
          */
1009
1098
         png_memcpy(tIME_string,
1010
 
                    png_convert_to_rfc1123(read_ptr, mod_time), 
 
1099
                    png_convert_to_rfc1123(read_ptr, mod_time),
1011
1100
                    png_sizeof(tIME_string));
1012
 
         tIME_string[png_sizeof(tIME_string)-1] = '\0';
 
1101
         tIME_string[png_sizeof(tIME_string) - 1] = '\0';
1013
1102
         tIME_chunk_present++;
1014
1103
#endif /* PNG_TIME_RFC1123_SUPPORTED */
1015
1104
      }
1016
1105
   }
1017
1106
#endif
1018
 
#if defined(PNG_tRNS_SUPPORTED)
 
1107
#ifdef PNG_tRNS_SUPPORTED
1019
1108
   {
1020
1109
      png_bytep trans;
1021
1110
      int num_trans;
1024
1113
      if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,
1025
1114
         &trans_values))
1026
1115
      {
1027
 
         png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
1028
 
            trans_values);
 
1116
         int sample_max = (1 << bit_depth);
 
1117
         /* libpng doesn't reject a tRNS chunk with out-of-range samples */
 
1118
         if (!((color_type == PNG_COLOR_TYPE_GRAY &&
 
1119
             (int)trans_values->gray > sample_max) ||
 
1120
             (color_type == PNG_COLOR_TYPE_RGB &&
 
1121
             ((int)trans_values->red > sample_max ||
 
1122
             (int)trans_values->green > sample_max ||
 
1123
             (int)trans_values->blue > sample_max))))
 
1124
            png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
 
1125
               trans_values);
1029
1126
      }
1030
1127
   }
1031
1128
#endif
1032
 
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
 
1129
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1033
1130
   {
1034
1131
      png_unknown_chunkp unknowns;
1035
1132
      int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,
1039
1136
         png_size_t i;
1040
1137
         png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
1041
1138
           num_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 */
 
1139
         /* Copy the locations from the read_info_ptr.  The automatically
 
1140
          * generated locations in write_info_ptr are wrong because we
 
1141
          * haven't written anything yet.
 
1142
          */
1045
1143
         for (i = 0; i < (png_size_t)num_unknowns; i++)
1046
1144
           png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
1047
1145
             unknowns[i].location);
1050
1148
#endif
1051
1149
 
1052
1150
#ifdef PNG_WRITE_SUPPORTED
1053
 
   png_debug(0, "\nWriting info struct\n");
 
1151
   png_debug(0, "Writing info struct");
1054
1152
 
1055
1153
/* If we wanted, we could write info in two steps:
1056
 
   png_write_info_before_PLTE(write_ptr, write_info_ptr);
 
1154
 * png_write_info_before_PLTE(write_ptr, write_info_ptr);
1057
1155
 */
1058
1156
   png_write_info(write_ptr, write_info_ptr);
 
1157
 
 
1158
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
 
1159
   if (user_chunk_data[0] != 0)
 
1160
   {
 
1161
      png_byte png_sTER[5] = {115,  84,  69,  82, '\0'};
 
1162
 
 
1163
      unsigned char
 
1164
        ster_chunk_data[1];
 
1165
 
 
1166
      if (verbose)
 
1167
         fprintf(STDERR, "\n stereo mode = %lu\n",
 
1168
           (unsigned long)(user_chunk_data[0] - 1));
 
1169
      ster_chunk_data[0]=(unsigned char)(user_chunk_data[0] - 1);
 
1170
      png_write_chunk(write_ptr, png_sTER, ster_chunk_data, 1);
 
1171
   }
 
1172
   if (user_chunk_data[1] != 0 || user_chunk_data[2] != 0)
 
1173
   {
 
1174
      png_byte png_vpAg[5] = {118, 112,  65, 103, '\0'};
 
1175
 
 
1176
      unsigned char
 
1177
        vpag_chunk_data[9];
 
1178
 
 
1179
      if (verbose)
 
1180
         fprintf(STDERR, " vpAg = %lu x %lu, units = %lu\n",
 
1181
           (unsigned long)user_chunk_data[1],
 
1182
           (unsigned long)user_chunk_data[2],
 
1183
           (unsigned long)user_chunk_data[3]);
 
1184
      png_save_uint_32(vpag_chunk_data, user_chunk_data[1]);
 
1185
      png_save_uint_32(vpag_chunk_data + 4, user_chunk_data[2]);
 
1186
      vpag_chunk_data[8] = (unsigned char)(user_chunk_data[3] & 0xff);
 
1187
      png_write_chunk(write_ptr, png_vpAg, vpag_chunk_data, 9);
 
1188
   }
 
1189
 
 
1190
#endif
1059
1191
#endif
1060
1192
 
1061
1193
#ifdef SINGLE_ROWBUF_ALLOC
1062
 
   png_debug(0, "\nAllocating row buffer...");
 
1194
   png_debug(0, "Allocating row buffer...");
1063
1195
   row_buf = (png_bytep)png_malloc(read_ptr,
1064
1196
      png_get_rowbytes(read_ptr, read_info_ptr));
1065
 
   png_debug1(0, "0x%08lx\n\n", (unsigned long)row_buf);
 
1197
   png_debug1(0, "0x%08lx", (unsigned long)row_buf);
1066
1198
#endif /* SINGLE_ROWBUF_ALLOC */
1067
 
   png_debug(0, "Writing row data\n");
 
1199
   png_debug(0, "Writing row data");
1068
1200
 
1069
1201
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
1070
1202
  defined(PNG_WRITE_INTERLACING_SUPPORTED)
1073
1205
   png_set_interlace_handling(write_ptr);
1074
1206
#  endif
1075
1207
#else
1076
 
   num_pass=1;
 
1208
   num_pass = 1;
1077
1209
#endif
1078
1210
 
1079
1211
#ifdef PNGTEST_TIMING
1083
1215
#endif
1084
1216
   for (pass = 0; pass < num_pass; pass++)
1085
1217
   {
1086
 
      png_debug1(0, "Writing row data for pass %d\n",pass);
 
1218
      png_debug1(0, "Writing row data for pass %d", pass);
1087
1219
      for (y = 0; y < height; y++)
1088
1220
      {
1089
1221
#ifndef SINGLE_ROWBUF_ALLOC
1090
 
         png_debug2(0, "\nAllocating row buffer (pass %d, y = %ld)...", pass,y);
 
1222
         png_debug2(0, "Allocating row buffer (pass %d, y = %ld)...", pass, y);
1091
1223
         row_buf = (png_bytep)png_malloc(read_ptr,
1092
1224
            png_get_rowbytes(read_ptr, read_info_ptr));
1093
 
         png_debug2(0, "0x%08lx (%ld bytes)\n", (unsigned long)row_buf,
 
1225
         png_debug2(0, "0x%08lx (%ld bytes)", (unsigned long)row_buf,
1094
1226
            png_get_rowbytes(read_ptr, read_info_ptr));
1095
1227
#endif /* !SINGLE_ROWBUF_ALLOC */
1096
1228
         png_read_rows(read_ptr, (png_bytepp)&row_buf, png_bytepp_NULL, 1);
1110
1242
#endif /* PNG_WRITE_SUPPORTED */
1111
1243
 
1112
1244
#ifndef SINGLE_ROWBUF_ALLOC
1113
 
         png_debug2(0, "Freeing row buffer (pass %d, y = %ld)\n\n", pass, y);
 
1245
         png_debug2(0, "Freeing row buffer (pass %d, y = %ld)", pass, y);
1114
1246
         png_free(read_ptr, row_buf);
 
1247
         row_buf = NULL;
1115
1248
#endif /* !SINGLE_ROWBUF_ALLOC */
1116
1249
      }
1117
1250
   }
1118
1251
 
1119
 
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
 
1252
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
1120
1253
   png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
1121
1254
#endif
1122
 
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
 
1255
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1123
1256
   png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
1124
1257
#endif
1125
1258
 
1126
 
   png_debug(0, "Reading and writing end_info data\n");
 
1259
   png_debug(0, "Reading and writing end_info data");
1127
1260
 
1128
1261
   png_read_end(read_ptr, end_info_ptr);
1129
 
#if defined(PNG_TEXT_SUPPORTED)
 
1262
#ifdef PNG_TEXT_SUPPORTED
1130
1263
   {
1131
1264
      png_textp text_ptr;
1132
1265
      int num_text;
1133
1266
 
1134
1267
      if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)
1135
1268
      {
1136
 
         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);
 
1269
         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);
1137
1270
         png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);
1138
1271
      }
1139
1272
   }
1140
1273
#endif
1141
 
#if defined(PNG_tIME_SUPPORTED)
 
1274
#ifdef PNG_tIME_SUPPORTED
1142
1275
   {
1143
1276
      png_timep mod_time;
1144
1277
 
1145
1278
      if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))
1146
1279
      {
1147
1280
         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
 
1281
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
1282
         /* We have to use png_memcpy instead of "=" because the string
1150
1283
            pointed to by png_convert_to_rfc1123() gets free'ed before
1151
1284
            we use it */
1152
1285
         png_memcpy(tIME_string,
1153
1286
                    png_convert_to_rfc1123(read_ptr, mod_time),
1154
1287
                    png_sizeof(tIME_string));
1155
 
         tIME_string[png_sizeof(tIME_string)-1] = '\0';
 
1288
         tIME_string[png_sizeof(tIME_string) - 1] = '\0';
1156
1289
         tIME_chunk_present++;
1157
1290
#endif /* PNG_TIME_RFC1123_SUPPORTED */
1158
1291
      }
1159
1292
   }
1160
1293
#endif
1161
 
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
 
1294
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1162
1295
   {
1163
1296
      png_unknown_chunkp unknowns;
1164
1297
      int num_unknowns;
1169
1302
         png_size_t i;
1170
1303
         png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
1171
1304
           num_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 */
 
1305
         /* Copy the locations from the read_info_ptr.  The automatically
 
1306
          * generated locations in write_end_info_ptr are wrong because we
 
1307
          * haven't written the end_info yet.
 
1308
          */
1175
1309
         for (i = 0; i < (png_size_t)num_unknowns; i++)
1176
1310
           png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
1177
1311
             unknowns[i].location);
1183
1317
#endif
1184
1318
 
1185
1319
#ifdef PNG_EASY_ACCESS_SUPPORTED
1186
 
   if(verbose)
 
1320
   if (verbose)
1187
1321
   {
1188
1322
      png_uint_32 iwidth, iheight;
1189
1323
      iwidth = png_get_image_width(write_ptr, write_info_ptr);
1190
1324
      iheight = png_get_image_height(write_ptr, write_info_ptr);
1191
 
      fprintf(STDERR, "Image width = %lu, height = %lu\n",
 
1325
      fprintf(STDERR, "\n Image width = %lu, height = %lu\n",
1192
1326
         (unsigned long)iwidth, (unsigned long)iheight);
1193
1327
   }
1194
1328
#endif
1195
1329
 
1196
 
   png_debug(0, "Destroying data structs\n");
 
1330
   png_debug(0, "Destroying data structs");
1197
1331
#ifdef SINGLE_ROWBUF_ALLOC
1198
 
   png_debug(1, "destroying row_buf for read_ptr\n");
 
1332
   png_debug(1, "destroying row_buf for read_ptr");
1199
1333
   png_free(read_ptr, row_buf);
1200
 
   row_buf=NULL;
 
1334
   row_buf = NULL;
1201
1335
#endif /* SINGLE_ROWBUF_ALLOC */
1202
 
   png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr\n");
 
1336
   png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr");
1203
1337
   png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
1204
1338
#ifdef PNG_WRITE_SUPPORTED
1205
 
   png_debug(1, "destroying write_end_info_ptr\n");
 
1339
   png_debug(1, "destroying write_end_info_ptr");
1206
1340
   png_destroy_info_struct(write_ptr, &write_end_info_ptr);
1207
 
   png_debug(1, "destroying write_ptr, write_info_ptr\n");
 
1341
   png_debug(1, "destroying write_ptr, write_info_ptr");
1208
1342
   png_destroy_write_struct(&write_ptr, &write_info_ptr);
1209
1343
#endif
1210
 
   png_debug(0, "Destruction complete.\n");
 
1344
   png_debug(0, "Destruction complete.");
1211
1345
 
1212
1346
   FCLOSE(fpin);
1213
1347
   FCLOSE(fpout);
1214
1348
 
1215
 
   png_debug(0, "Opening files for comparison\n");
1216
 
#if defined(_WIN32_WCE)
 
1349
   png_debug(0, "Opening files for comparison");
 
1350
#ifdef _WIN32_WCE
1217
1351
   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);
1218
1352
   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
1219
1353
#else
1224
1358
      return (1);
1225
1359
   }
1226
1360
 
1227
 
#if defined(_WIN32_WCE)
 
1361
#ifdef _WIN32_WCE
1228
1362
   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);
1229
1363
   if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
1230
1364
#else
1236
1370
      return (1);
1237
1371
   }
1238
1372
 
1239
 
   for(;;)
 
1373
   for (;;)
1240
1374
   {
1241
1375
      png_size_t num_in, num_out;
1242
1376
 
1243
 
      READFILE(fpin, inbuf, 1, num_in);
1244
 
      READFILE(fpout, outbuf, 1, num_out);
 
1377
         READFILE(fpin, inbuf, 1, num_in);
 
1378
         READFILE(fpout, outbuf, 1, num_out);
1245
1379
 
1246
1380
      if (num_in != num_out)
1247
1381
      {
1248
1382
         fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
1249
1383
                 inname, outname);
1250
 
         if(wrote_question == 0)
 
1384
         if (wrote_question == 0)
1251
1385
         {
1252
1386
            fprintf(STDERR,
1253
1387
         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",
1254
 
              inname,PNG_ZBUF_SIZE);
 
1388
              inname, PNG_ZBUF_SIZE);
1255
1389
            fprintf(STDERR,
1256
1390
              "\n   filtering heuristic (libpng default), compression");
1257
1391
            fprintf(STDERR,
1258
1392
              " level (zlib default),\n   and zlib version (%s)?\n\n",
1259
1393
              ZLIB_VERSION);
1260
 
            wrote_question=1;
 
1394
            wrote_question = 1;
1261
1395
         }
1262
1396
         FCLOSE(fpin);
1263
1397
         FCLOSE(fpout);
1270
1404
      if (png_memcmp(inbuf, outbuf, num_in))
1271
1405
      {
1272
1406
         fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);
1273
 
         if(wrote_question == 0)
 
1407
         if (wrote_question == 0)
1274
1408
         {
1275
1409
            fprintf(STDERR,
1276
1410
         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",
1277
 
                 inname,PNG_ZBUF_SIZE);
 
1411
                 inname, PNG_ZBUF_SIZE);
1278
1412
            fprintf(STDERR,
1279
1413
              "\n   filtering heuristic (libpng default), compression");
1280
1414
            fprintf(STDERR,
1281
1415
              " level (zlib default),\n   and zlib version (%s)?\n\n",
1282
1416
              ZLIB_VERSION);
1283
 
            wrote_question=1;
 
1417
            wrote_question = 1;
1284
1418
         }
1285
1419
         FCLOSE(fpin);
1286
1420
         FCLOSE(fpout);
1294
1428
   return (0);
1295
1429
}
1296
1430
 
1297
 
/* input and output filenames */
 
1431
/* Input and output filenames */
1298
1432
#ifdef RISCOS
1299
1433
static PNG_CONST char *inname = "pngtest/png";
1300
1434
static PNG_CONST char *outname = "pngout/png";
1309
1443
   int multiple = 0;
1310
1444
   int ierror = 0;
1311
1445
 
1312
 
   fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
 
1446
   fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
1313
1447
   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);
1314
 
   fprintf(STDERR,"%s",png_get_copyright(NULL));
 
1448
   fprintf(STDERR, "%s", png_get_copyright(NULL));
1315
1449
   /* Show the version of libpng used in building the library */
1316
 
   fprintf(STDERR," library (%lu):%s",
 
1450
   fprintf(STDERR, " library (%lu):%s",
1317
1451
      (unsigned long)png_access_version_number(),
1318
1452
      png_get_header_version(NULL));
1319
1453
   /* Show the version of libpng used in building the application */
1320
 
   fprintf(STDERR," pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,
 
1454
   fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,
1321
1455
      PNG_HEADER_VERSION_STRING);
1322
 
   fprintf(STDERR," png_sizeof(png_struct)=%ld, png_sizeof(png_info)=%ld\n",
 
1456
   fprintf(STDERR, " sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n",
1323
1457
                    (long)png_sizeof(png_struct), (long)png_sizeof(png_info));
1324
1458
 
1325
1459
   /* 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
1328
 
      in pngconf.h */
 
1460
    * not sure this matters, but it is nice to know, the first of these
 
1461
    * tests should be impossible because of the way the macros are set
 
1462
    * in pngconf.h
 
1463
    */
1329
1464
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
1330
1465
      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
1331
1466
#endif
1370
1505
      }
1371
1506
   }
1372
1507
 
1373
 
   if (!multiple && argc == 3+verbose)
1374
 
     outname = argv[2+verbose];
 
1508
   if (!multiple && argc == 3 + verbose)
 
1509
     outname = argv[2 + verbose];
1375
1510
 
1376
 
   if ((!multiple && argc > 3+verbose) || (multiple && argc < 2))
 
1511
   if ((!multiple && argc > 3 + verbose) || (multiple && argc < 2))
1377
1512
   {
1378
1513
     fprintf(STDERR,
1379
1514
       "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
1393
1528
#endif
1394
1529
      for (i=2; i<argc; ++i)
1395
1530
      {
1396
 
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 
1531
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1397
1532
         int k;
1398
1533
#endif
1399
1534
         int kerror;
1400
 
         fprintf(STDERR, "Testing %s:",argv[i]);
 
1535
         fprintf(STDERR, "\n Testing %s:", argv[i]);
1401
1536
         kerror = test_one_file(argv[i], outname);
1402
1537
         if (kerror == 0)
1403
1538
         {
1404
 
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 
1539
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1405
1540
            fprintf(STDERR, "\n PASS (%lu zero samples)\n",
1406
1541
               (unsigned long)zero_samples);
1407
1542
#else
1408
1543
            fprintf(STDERR, " PASS\n");
1409
1544
#endif
1410
 
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1411
 
            for (k=0; k<256; k++)
1412
 
               if(filters_used[k])
 
1545
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 
1546
            for (k = 0; k<256; k++)
 
1547
               if (filters_used[k])
1413
1548
                  fprintf(STDERR, " Filter %d was used %lu times\n",
1414
 
                     k,(unsigned long)filters_used[k]);
 
1549
                     k, (unsigned long)filters_used[k]);
1415
1550
#endif
1416
 
#if defined(PNG_TIME_RFC1123_SUPPORTED)
1417
 
         if(tIME_chunk_present != 0)
1418
 
            fprintf(STDERR, " tIME = %s\n",tIME_string);
 
1551
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
1552
         if (tIME_chunk_present != 0)
 
1553
            fprintf(STDERR, " tIME = %s\n", tIME_string);
1419
1554
         tIME_chunk_present = 0;
1420
1555
#endif /* PNG_TIME_RFC1123_SUPPORTED */
1421
1556
         }
1427
1562
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1428
1563
         if (allocation_now != current_allocation)
1429
1564
            fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
1430
 
               current_allocation-allocation_now);
 
1565
               current_allocation - allocation_now);
1431
1566
         if (current_allocation != 0)
1432
1567
         {
1433
1568
            memory_infop pinfo = pinformation;
1436
1571
               current_allocation);
1437
1572
            while (pinfo != NULL)
1438
1573
            {
1439
 
               fprintf(STDERR, " %lu bytes at %x\n", (unsigned long)pinfo->size,
 
1574
               fprintf(STDERR, " %lu bytes at %x\n",
 
1575
                 (unsigned long)pinfo->size,
1440
1576
                 (unsigned int) pinfo->pointer);
1441
1577
               pinfo = pinfo->next;
1442
1578
            }
1457
1593
   else
1458
1594
   {
1459
1595
      int i;
1460
 
      for (i=0; i<3; ++i)
 
1596
      for (i = 0; i<3; ++i)
1461
1597
      {
1462
1598
         int kerror;
1463
1599
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1464
1600
         int allocation_now = current_allocation;
1465
1601
#endif
1466
1602
         if (i == 1) status_dots_requested = 1;
1467
 
         else if(verbose == 0)status_dots_requested = 0;
 
1603
         else if (verbose == 0)status_dots_requested = 0;
1468
1604
         if (i == 0 || verbose == 1 || ierror != 0)
1469
 
            fprintf(STDERR, "Testing %s:",inname);
 
1605
            fprintf(STDERR, "\n Testing %s:", inname);
1470
1606
         kerror = test_one_file(inname, outname);
1471
 
         if(kerror == 0)
 
1607
         if (kerror == 0)
1472
1608
         {
1473
 
            if(verbose == 1 || i == 2)
 
1609
            if (verbose == 1 || i == 2)
1474
1610
            {
1475
 
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 
1611
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1476
1612
                int k;
1477
1613
#endif
1478
 
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 
1614
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1479
1615
                fprintf(STDERR, "\n PASS (%lu zero samples)\n",
1480
1616
                   (unsigned long)zero_samples);
1481
1617
#else
1482
1618
                fprintf(STDERR, " PASS\n");
1483
1619
#endif
1484
 
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1485
 
                for (k=0; k<256; k++)
1486
 
                   if(filters_used[k])
 
1620
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 
1621
                for (k = 0; k<256; k++)
 
1622
                   if (filters_used[k])
1487
1623
                      fprintf(STDERR, " Filter %d was used %lu times\n",
1488
 
                         k,(unsigned long)filters_used[k]);
 
1624
                         k,
 
1625
                         (unsigned long)filters_used[k]);
1489
1626
#endif
1490
 
#if defined(PNG_TIME_RFC1123_SUPPORTED)
1491
 
             if(tIME_chunk_present != 0)
1492
 
                fprintf(STDERR, " tIME = %s\n",tIME_string);
 
1627
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
1628
             if (tIME_chunk_present != 0)
 
1629
                fprintf(STDERR, " tIME = %s\n", tIME_string);
1493
1630
#endif /* PNG_TIME_RFC1123_SUPPORTED */
1494
1631
            }
1495
1632
         }
1496
1633
         else
1497
1634
         {
1498
 
            if(verbose == 0 && i != 2)
1499
 
               fprintf(STDERR, "Testing %s:",inname);
 
1635
            if (verbose == 0 && i != 2)
 
1636
               fprintf(STDERR, "\n Testing %s:", inname);
1500
1637
            fprintf(STDERR, " FAIL\n");
1501
1638
            ierror += kerror;
1502
1639
         }
1503
1640
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1504
1641
         if (allocation_now != current_allocation)
1505
1642
             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
1506
 
               current_allocation-allocation_now);
 
1643
               current_allocation - allocation_now);
1507
1644
         if (current_allocation != 0)
1508
1645
         {
1509
1646
             memory_infop pinfo = pinformation;
1512
1649
                current_allocation);
1513
1650
             while (pinfo != NULL)
1514
1651
             {
1515
 
                fprintf(STDERR," %lu bytes at %x\n",
 
1652
                fprintf(STDERR, " %lu bytes at %x\n",
1516
1653
                   (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);
1517
1654
                pinfo = pinfo->next;
1518
1655
             }
1535
1672
   t_stop = (float)clock();
1536
1673
   t_misc += (t_stop - t_start);
1537
1674
   t_start = t_stop;
1538
 
   fprintf(STDERR," CPU time used = %.3f seconds",
 
1675
   fprintf(STDERR, " CPU time used = %.3f seconds",
1539
1676
      (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);
1540
 
   fprintf(STDERR," (decoding %.3f,\n",
 
1677
   fprintf(STDERR, " (decoding %.3f,\n",
1541
1678
      t_decode/(float)CLOCKS_PER_SEC);
1542
 
   fprintf(STDERR,"        encoding %.3f ,",
 
1679
   fprintf(STDERR, "        encoding %.3f ,",
1543
1680
      t_encode/(float)CLOCKS_PER_SEC);
1544
 
   fprintf(STDERR," other %.3f seconds)\n\n",
 
1681
   fprintf(STDERR, " other %.3f seconds)\n\n",
1545
1682
      t_misc/(float)CLOCKS_PER_SEC);
1546
1683
#endif
1547
1684
 
1548
1685
   if (ierror == 0)
1549
 
      fprintf(STDERR, "libpng passes test\n");
 
1686
      fprintf(STDERR, " libpng passes test\n");
1550
1687
   else
1551
 
      fprintf(STDERR, "libpng FAILS test\n");
 
1688
      fprintf(STDERR, " libpng FAILS test\n");
1552
1689
   return (int)(ierror != 0);
1553
1690
}
1554
1691
 
1555
1692
/* Generate a compiler error if there is an old png.h in the search path. */
1556
 
typedef version_1_2_23 your_png_h_is_not_version_1_2_23;
 
1693
typedef version_1_2_41 your_png_h_is_not_version_1_2_41;