git.maemo.org Git - opencv/blob - 3rdparty/libpng/pngtest.c

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