pngtest.c

   1
   2 /* pngtest.c - a simple test program to test libpng
   3  *
   4  * Copyright (c) 2018-2019 Cosmin Truta
   5  * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
   6  * Copyright (c) 1996-1997 Andreas Dilger
   7  * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
   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  *
  13  * This program reads in a PNG image, writes it out again, and then
  14  * compares the two files.  If the files are identical, this shows that
  15  * the basic chunk handling, filtering, and (de)compression code is working
  16  * properly.  It does not currently test all of the transforms, although
  17  * it probably should.
  18  *
  19  * The program will report "FAIL" in certain legitimate cases:
  20  * 1) when the compression level or filter selection method is changed.
  21  * 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192.
  22  * 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks
  23  *    exist in the input file.
  24  * 4) others not listed here...
  25  * In these cases, it is best to check with another tool such as "pngcheck"
  26  * to see what the differences between the two files are.
  27  *
  28  * If a filename is given on the command-line, then this file is used
  29  * for the input, rather than the default "pngtest.png".  This allows
  30  * testing a wide variety of files easily.  You can also test a number
  31  * of files at once by typing "pngtest -m file1.png file2.png ..."
  32  */
  33
  34 #define _POSIX_SOURCE 1
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 /* Defined so I can write to a file on gui/windowing platforms */
  41 /*  #define STDERR stderr  */
  42 #define STDERR stdout   /* For DOS */
  43
  44 #include "png.h"
  45
  46 /* Known chunks that exist in pngtest.png must be supported or pngtest will fail
  47  * simply as a result of re-ordering them.  This may be fixed in 1.7
  48  *
  49  * pngtest allocates a single row buffer for each row and overwrites it,
  50  * therefore if the write side doesn't support the writing of interlaced images
  51  * nothing can be done for an interlaced image (and the code below will fail
  52  * horribly trying to write extra data after writing garbage).
  53  */
  54 #if defined PNG_READ_SUPPORTED && /* else nothing can be done */\
  55    defined PNG_READ_bKGD_SUPPORTED &&\
  56    defined PNG_READ_cHRM_SUPPORTED &&\
  57    defined PNG_READ_gAMA_SUPPORTED &&\
  58    defined PNG_READ_oFFs_SUPPORTED &&\
  59    defined PNG_READ_pCAL_SUPPORTED &&\
  60    defined PNG_READ_pHYs_SUPPORTED &&\
  61    defined PNG_READ_sBIT_SUPPORTED &&\
  62    defined PNG_READ_sCAL_SUPPORTED &&\
  63    defined PNG_READ_sRGB_SUPPORTED &&\
  64    defined PNG_READ_sPLT_SUPPORTED &&\
  65    defined PNG_READ_tEXt_SUPPORTED &&\
  66    defined PNG_READ_tIME_SUPPORTED &&\
  67    defined PNG_READ_zTXt_SUPPORTED &&\
  68    (defined PNG_WRITE_INTERLACING_SUPPORTED || PNG_LIBPNG_VER >= 10700)
  69
  70 #ifdef PNG_ZLIB_HEADER
  71 #  include PNG_ZLIB_HEADER /* defined by pnglibconf.h from 1.7 */
  72 #else
  73 #  include "zlib.h"
  74 #endif
  75
  76 /* Copied from pngpriv.h but only used in error messages below. */
  77 #ifndef PNG_ZBUF_SIZE
  78 #  define PNG_ZBUF_SIZE 8192
  79 #endif
  80 #define FCLOSE(file) fclose(file)
  81
  82 #ifndef PNG_STDIO_SUPPORTED
  83 typedef FILE                * png_FILE_p;
  84 #endif
  85
  86 /* Makes pngtest verbose so we can find problems. */
  87 #ifndef PNG_DEBUG
  88 #  define PNG_DEBUG 0
  89 #endif
  90
  91 #if PNG_DEBUG > 1
  92 #  define pngtest_debug(m)        ((void)fprintf(stderr, m "\n"))
  93 #  define pngtest_debug1(m,p1)    ((void)fprintf(stderr, m "\n", p1))
  94 #  define pngtest_debug2(m,p1,p2) ((void)fprintf(stderr, m "\n", p1, p2))
  95 #else
  96 #  define pngtest_debug(m)        ((void)0)
  97 #  define pngtest_debug1(m,p1)    ((void)0)
  98 #  define pngtest_debug2(m,p1,p2) ((void)0)
  99 #endif
 100
 101 #if !PNG_DEBUG
 102 #  define SINGLE_ROWBUF_ALLOC  /* Makes buffer overruns easier to nail */
 103 #endif
 104
 105 #ifndef PNG_UNUSED
 106 #  define PNG_UNUSED(param) (void)param;
 107 #endif
 108
 109 /* Turn on CPU timing
 110 #define PNGTEST_TIMING
 111 */
 112
 113 #ifndef PNG_FLOATING_POINT_SUPPORTED
 114 #undef PNGTEST_TIMING
 115 #endif
 116
 117 #ifdef PNGTEST_TIMING
 118 static float t_start, t_stop, t_decode, t_encode, t_misc;
 119 #include <time.h>
 120 #endif
 121
 122 #ifdef PNG_TIME_RFC1123_SUPPORTED
 123 #define PNG_tIME_STRING_LENGTH 29
 124 static int tIME_chunk_present = 0;
 125 static char tIME_string[PNG_tIME_STRING_LENGTH] = "tIME chunk is not present";
 126
 127 #if PNG_LIBPNG_VER < 10619
 128 #define png_convert_to_rfc1123_buffer(ts, t) tIME_to_str(read_ptr, ts, t)
 129
 130 static int
 131 tIME_to_str(png_structp png_ptr, png_charp ts, png_const_timep t)
 132 {
 133    png_const_charp str = png_convert_to_rfc1123(png_ptr, t);
 134
 135    if (str == NULL)
 136        return 0;
 137
 138    strcpy(ts, str);
 139    return 1;
 140 }
 141 #endif /* older libpng */
 142 #endif
 143
 144 static int verbose = 0;
 145 static int strict = 0;
 146 static int relaxed = 0;
 147 static int xfail = 0;
 148 static int unsupported_chunks = 0; /* chunk unsupported by libpng in input */
 149 static int error_count = 0; /* count calls to png_error */
 150 static int warning_count = 0; /* count calls to png_warning */
 151
 152 /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
 153 #ifndef png_jmpbuf
 154 #  define png_jmpbuf(png_ptr) png_ptr->jmpbuf
 155 #endif
 156
 157 /* Defines for unknown chunk handling if required. */
 158 #ifndef PNG_HANDLE_CHUNK_ALWAYS
 159 #  define PNG_HANDLE_CHUNK_ALWAYS       3
 160 #endif
 161 #ifndef PNG_HANDLE_CHUNK_IF_SAFE
 162 #  define PNG_HANDLE_CHUNK_IF_SAFE      2
 163 #endif
 164
 165 /* Utility to save typing/errors, the argument must be a name */
 166 #define MEMZERO(var) ((void)memset(&var, 0, sizeof var))
 167
 168 /* Example of using row callbacks to make a simple progress meter */
 169 static int status_pass = 1;
 170 static int status_dots_requested = 0;
 171 static int status_dots = 1;
 172
 173 static void PNGCBAPI
 174 read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
 175 {
 176    if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
 177       return;
 178
 179    if (status_pass != pass)
 180    {
 181       fprintf(stdout, "\n Pass %d: ", pass);
 182       status_pass = pass;
 183       status_dots = 31;
 184    }
 185
 186    status_dots--;
 187
 188    if (status_dots == 0)
 189    {
 190       fprintf(stdout, "\n         ");
 191       status_dots=30;
 192    }
 193
 194    fprintf(stdout, "r");
 195 }
 196
 197 #ifdef PNG_WRITE_SUPPORTED
 198 static void PNGCBAPI
 199 write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
 200 {
 201    if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
 202       return;
 203
 204    fprintf(stdout, "w");
 205 }
 206 #endif
 207
 208
 209 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 210 /* Example of using a user transform callback (doesn't do anything at present).
 211  */
 212 static void PNGCBAPI
 213 read_user_callback(png_structp png_ptr, png_row_infop row_info, png_bytep data)
 214 {
 215    PNG_UNUSED(png_ptr)
 216    PNG_UNUSED(row_info)
 217    PNG_UNUSED(data)
 218 }
 219 #endif
 220
 221 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
 222 /* Example of using user transform callback (we don't transform anything,
 223  * but merely count the zero samples)
 224  */
 225
 226 static png_uint_32 zero_samples;
 227
 228 static void PNGCBAPI
 229 count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
 230 {
 231    png_bytep dp = data;
 232    if (png_ptr == NULL)
 233       return;
 234
 235    /* Contents of row_info:
 236     *  png_uint_32 width      width of row
 237     *  png_uint_32 rowbytes   number of bytes in row
 238     *  png_byte color_type    color type of pixels
 239     *  png_byte bit_depth     bit depth of samples
 240     *  png_byte channels      number of channels (1-4)
 241     *  png_byte pixel_depth   bits per pixel (depth*channels)
 242     */
 243
 244    /* Counts the number of zero samples (or zero pixels if color_type is 3 */
 245
 246    if (row_info->color_type == 0 || row_info->color_type == 3)
 247    {
 248       int pos = 0;
 249       png_uint_32 n, nstop;
 250
 251       for (n = 0, nstop=row_info->width; n<nstop; n++)
 252       {
 253          if (row_info->bit_depth == 1)
 254          {
 255             if (((*dp << pos++ ) & 0x80) == 0)
 256                zero_samples++;
 257
 258             if (pos == 8)
 259             {
 260                pos = 0;
 261                dp++;
 262             }
 263          }
 264
 265          if (row_info->bit_depth == 2)
 266          {
 267             if (((*dp << (pos+=2)) & 0xc0) == 0)
 268                zero_samples++;
 269
 270             if (pos == 8)
 271             {
 272                pos = 0;
 273                dp++;
 274             }
 275          }
 276
 277          if (row_info->bit_depth == 4)
 278          {
 279             if (((*dp << (pos+=4)) & 0xf0) == 0)
 280                zero_samples++;
 281
 282             if (pos == 8)
 283             {
 284                pos = 0;
 285                dp++;
 286             }
 287          }
 288
 289          if (row_info->bit_depth == 8)
 290             if (*dp++ == 0)
 291                zero_samples++;
 292
 293          if (row_info->bit_depth == 16)
 294          {
 295             if ((*dp | *(dp+1)) == 0)
 296                zero_samples++;
 297             dp+=2;
 298          }
 299       }
 300    }
 301    else /* Other color types */
 302    {
 303       png_uint_32 n, nstop;
 304       int channel;
 305       int color_channels = row_info->channels;
 306       if (row_info->color_type > 3)
 307          color_channels--;
 308
 309       for (n = 0, nstop=row_info->width; n<nstop; n++)
 310       {
 311          for (channel = 0; channel < color_channels; channel++)
 312          {
 313             if (row_info->bit_depth == 8)
 314                if (*dp++ == 0)
 315                   zero_samples++;
 316
 317             if (row_info->bit_depth == 16)
 318             {
 319                if ((*dp | *(dp+1)) == 0)
 320                   zero_samples++;
 321
 322                dp+=2;
 323             }
 324          }
 325          if (row_info->color_type > 3)
 326          {
 327             dp++;
 328             if (row_info->bit_depth == 16)
 329                dp++;
 330          }
 331       }
 332    }
 333 }
 334 #endif /* WRITE_USER_TRANSFORM */
 335
 336 #ifndef PNG_STDIO_SUPPORTED
 337 /* START of code to validate stdio-free compilation */
 338 /* These copies of the default read/write functions come from pngrio.c and
 339  * pngwio.c.  They allow "don't include stdio" testing of the library.
 340  * This is the function that does the actual reading of data.  If you are
 341  * not reading from a standard C stream, you should create a replacement
 342  * read_data function and use it at run time with png_set_read_fn(), rather
 343  * than changing the library.
 344  */
 345
 346 #ifdef PNG_IO_STATE_SUPPORTED
 347 void
 348 pngtest_check_io_state(png_structp png_ptr, size_t data_length,
 349     png_uint_32 io_op);
 350 void
 351 pngtest_check_io_state(png_structp png_ptr, size_t data_length,
 352     png_uint_32 io_op)
 353 {
 354    png_uint_32 io_state = png_get_io_state(png_ptr);
 355    int err = 0;
 356
 357    /* Check if the current operation (reading / writing) is as expected. */
 358    if ((io_state & PNG_IO_MASK_OP) != io_op)
 359       png_error(png_ptr, "Incorrect operation in I/O state");
 360
 361    /* Check if the buffer size specific to the current location
 362     * (file signature / header / data / crc) is as expected.
 363     */
 364    switch (io_state & PNG_IO_MASK_LOC)
 365    {
 366    case PNG_IO_SIGNATURE:
 367       if (data_length > 8)
 368          err = 1;
 369       break;
 370    case PNG_IO_CHUNK_HDR:
 371       if (data_length != 8)
 372          err = 1;
 373       break;
 374    case PNG_IO_CHUNK_DATA:
 375       break;  /* no restrictions here */
 376    case PNG_IO_CHUNK_CRC:
 377       if (data_length != 4)
 378          err = 1;
 379       break;
 380    default:
 381       err = 1;  /* uninitialized */
 382    }
 383    if (err != 0)
 384       png_error(png_ptr, "Bad I/O state or buffer size");
 385 }
 386 #endif
 387
 388 static void PNGCBAPI
 389 pngtest_read_data(png_structp png_ptr, png_bytep data, size_t length)
 390 {
 391    size_t check = 0;
 392    png_voidp io_ptr;
 393
 394    /* fread() returns 0 on error, so it is OK to store this in a size_t
 395     * instead of an int, which is what fread() actually returns.
 396     */
 397    io_ptr = png_get_io_ptr(png_ptr);
 398    if (io_ptr != NULL)
 399    {
 400       check = fread(data, 1, length, (png_FILE_p)io_ptr);
 401    }
 402
 403    if (check != length)
 404    {
 405       png_error(png_ptr, "Read Error");
 406    }
 407
 408 #ifdef PNG_IO_STATE_SUPPORTED
 409    pngtest_check_io_state(png_ptr, length, PNG_IO_READING);
 410 #endif
 411 }
 412
 413 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 414 static void PNGCBAPI
 415 pngtest_flush(png_structp png_ptr)
 416 {
 417    /* Do nothing; fflush() is said to be just a waste of energy. */
 418    PNG_UNUSED(png_ptr)   /* Stifle compiler warning */
 419 }
 420 #endif
 421
 422 /* This is the function that does the actual writing of data.  If you are
 423  * not writing to a standard C stream, you should create a replacement
 424  * write_data function and use it at run time with png_set_write_fn(), rather
 425  * than changing the library.
 426  */
 427 static void PNGCBAPI
 428 pngtest_write_data(png_structp png_ptr, png_bytep data, size_t length)
 429 {
 430    size_t check;
 431
 432    check = fwrite(data, 1, length, (png_FILE_p)png_get_io_ptr(png_ptr));
 433
 434    if (check != length)
 435    {
 436       png_error(png_ptr, "Write Error");
 437    }
 438
 439 #ifdef PNG_IO_STATE_SUPPORTED
 440    pngtest_check_io_state(png_ptr, length, PNG_IO_WRITING);
 441 #endif
 442 }
 443 #endif /* !STDIO */
 444
 445 /* This function is called when there is a warning, but the library thinks
 446  * it can continue anyway.  Replacement functions don't have to do anything
 447  * here if you don't want to.  In the default configuration, png_ptr is
 448  * not used, but it is passed in case it may be useful.
 449  */
 450 typedef struct
 451 {
 452    const char *file_name;
 453 }  pngtest_error_parameters;
 454
 455 static void PNGCBAPI
 456 pngtest_warning(png_structp png_ptr, png_const_charp message)
 457 {
 458    const char *name = "UNKNOWN (ERROR!)";
 459    pngtest_error_parameters *test =
 460       (pngtest_error_parameters*)png_get_error_ptr(png_ptr);
 461
 462    ++warning_count;
 463
 464    if (test != NULL && test->file_name != NULL)
 465       name = test->file_name;
 466
 467    fprintf(STDERR, "\n%s: libpng warning: %s\n", name, message);
 468 }
 469
 470 /* This is the default error handling function.  Note that replacements for
 471  * this function MUST NOT RETURN, or the program will likely crash.  This
 472  * function is used by default, or if the program supplies NULL for the
 473  * error function pointer in png_set_error_fn().
 474  */
 475 static void PNGCBAPI
 476 pngtest_error(png_structp png_ptr, png_const_charp message)
 477 {
 478    ++error_count;
 479
 480    pngtest_warning(png_ptr, message);
 481    /* We can return because png_error calls the default handler, which is
 482     * actually OK in this case.
 483     */
 484 }
 485
 486 /* END of code to validate stdio-free compilation */
 487
 488 /* START of code to validate memory allocation and deallocation */
 489 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
 490
 491 /* Allocate memory.  For reasonable files, size should never exceed
 492  * 64K.  However, zlib may allocate more than 64K if you don't tell
 493  * it not to.  See zconf.h and png.h for more information.  zlib does
 494  * need to allocate exactly 64K, so whatever you call here must
 495  * have the ability to do that.
 496  *
 497  * This piece of code can be compiled to validate max 64K allocations
 498  * by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K.
 499  */
 500 typedef struct memory_information
 501 {
 502    png_alloc_size_t          size;
 503    png_voidp                 pointer;
 504    struct memory_information *next;
 505 } memory_information;
 506 typedef memory_information *memory_infop;
 507
 508 static memory_infop pinformation = NULL;
 509 static int current_allocation = 0;
 510 static int maximum_allocation = 0;
 511 static int total_allocation = 0;
 512 static int num_allocations = 0;
 513
 514 png_voidp PNGCBAPI png_debug_malloc PNGARG((png_structp png_ptr,
 515     png_alloc_size_t size));
 516 void PNGCBAPI png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));
 517
 518 png_voidp
 519 PNGCBAPI png_debug_malloc(png_structp png_ptr, png_alloc_size_t size)
 520 {
 521
 522    /* png_malloc has already tested for NULL; png_create_struct calls
 523     * png_debug_malloc directly, with png_ptr == NULL which is OK
 524     */
 525
 526    if (size == 0)
 527       return (NULL);
 528
 529    /* This calls the library allocator twice, once to get the requested
 530       buffer and once to get a new free list entry. */
 531    {
 532       /* Disable malloc_fn and free_fn */
 533       memory_infop pinfo;
 534       png_set_mem_fn(png_ptr, NULL, NULL, NULL);
 535       pinfo = (memory_infop)png_malloc(png_ptr,
 536           (sizeof *pinfo));
 537       pinfo->size = size;
 538       current_allocation += size;
 539       total_allocation += size;
 540       num_allocations ++;
 541
 542       if (current_allocation > maximum_allocation)
 543          maximum_allocation = current_allocation;
 544
 545       pinfo->pointer = png_malloc(png_ptr, size);
 546       /* Restore malloc_fn and free_fn */
 547
 548       png_set_mem_fn(png_ptr,
 549           NULL, png_debug_malloc, png_debug_free);
 550
 551       if (size != 0 && pinfo->pointer == NULL)
 552       {
 553          current_allocation -= size;
 554          total_allocation -= size;
 555          png_error(png_ptr,
 556            "out of memory in pngtest->png_debug_malloc");
 557       }
 558
 559       pinfo->next = pinformation;
 560       pinformation = pinfo;
 561       /* Make sure the caller isn't assuming zeroed memory. */
 562       memset(pinfo->pointer, 0xdd, pinfo->size);
 563
 564       if (verbose != 0)
 565          printf("png_malloc %lu bytes at %p\n", (unsigned long)size,
 566              pinfo->pointer);
 567
 568       return (png_voidp)(pinfo->pointer);
 569    }
 570 }
 571
 572 /* Free a pointer.  It is removed from the list at the same time. */
 573 void PNGCBAPI
 574 png_debug_free(png_structp png_ptr, png_voidp ptr)
 575 {
 576    if (png_ptr == NULL)
 577       fprintf(STDERR, "NULL pointer to png_debug_free.\n");
 578
 579    if (ptr == 0)
 580    {
 581 #if 0 /* This happens all the time. */
 582       fprintf(STDERR, "WARNING: freeing NULL pointer\n");
 583 #endif
 584       return;
 585    }
 586
 587    /* Unlink the element from the list. */
 588    if (pinformation != NULL)
 589    {
 590       memory_infop *ppinfo = &pinformation;
 591
 592       for (;;)
 593       {
 594          memory_infop pinfo = *ppinfo;
 595
 596          if (pinfo->pointer == ptr)
 597          {
 598             *ppinfo = pinfo->next;
 599             current_allocation -= pinfo->size;
 600             if (current_allocation < 0)
 601                fprintf(STDERR, "Duplicate free of memory\n");
 602             /* We must free the list element too, but first kill
 603                the memory that is to be freed. */
 604             memset(ptr, 0x55, pinfo->size);
 605             free(pinfo);
 606             pinfo = NULL;
 607             break;
 608          }
 609
 610          if (pinfo->next == NULL)
 611          {
 612             fprintf(STDERR, "Pointer %p not found\n", ptr);
 613             break;
 614          }
 615
 616          ppinfo = &pinfo->next;
 617       }
 618    }
 619
 620    /* Finally free the data. */
 621    if (verbose != 0)
 622       printf("Freeing %p\n", ptr);
 623
 624    if (ptr != NULL)
 625       free(ptr);
 626    ptr = NULL;
 627 }
 628 #endif /* USER_MEM && DEBUG */
 629 /* END of code to test memory allocation/deallocation */
 630
 631
 632 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
 633 /* Demonstration of user chunk support of the sTER and vpAg chunks */
 634
 635 /* (sTER is a public chunk not yet known by libpng.  vpAg is a private
 636 chunk used in ImageMagick to store "virtual page" size).  */
 637
 638 static struct user_chunk_data
 639 {
 640    png_const_infop info_ptr;
 641    png_uint_32     vpAg_width, vpAg_height;
 642    png_byte        vpAg_units;
 643    png_byte        sTER_mode;
 644    int             location[2];
 645 }
 646 user_chunk_data;
 647
 648 /* Used for location and order; zero means nothing. */
 649 #define have_sTER   0x01
 650 #define have_vpAg   0x02
 651 #define before_PLTE 0x10
 652 #define before_IDAT 0x20
 653 #define after_IDAT  0x40
 654
 655 static void
 656 init_callback_info(png_const_infop info_ptr)
 657 {
 658    MEMZERO(user_chunk_data);
 659    user_chunk_data.info_ptr = info_ptr;
 660 }
 661
 662 static int
 663 set_location(png_structp png_ptr, struct user_chunk_data *data, int what)
 664 {
 665    int location;
 666
 667    if ((data->location[0] & what) != 0 || (data->location[1] & what) != 0)
 668       return 0; /* already have one of these */
 669
 670    /* Find where we are (the code below zeroes info_ptr to indicate that the
 671     * chunks before the first IDAT have been read.)
 672     */
 673    if (data->info_ptr == NULL) /* after IDAT */
 674       location = what | after_IDAT;
 675
 676    else if (png_get_valid(png_ptr, data->info_ptr, PNG_INFO_PLTE) != 0)
 677       location = what | before_IDAT;
 678
 679    else
 680       location = what | before_PLTE;
 681
 682    if (data->location[0] == 0)
 683       data->location[0] = location;
 684
 685    else
 686       data->location[1] = location;
 687
 688    return 1; /* handled */
 689 }
 690
 691 static int PNGCBAPI
 692 read_user_chunk_callback(png_struct *png_ptr, png_unknown_chunkp chunk)
 693 {
 694    struct user_chunk_data *my_user_chunk_data =
 695       (struct user_chunk_data*)png_get_user_chunk_ptr(png_ptr);
 696
 697    if (my_user_chunk_data == NULL)
 698       png_error(png_ptr, "lost user chunk pointer");
 699
 700    /* Return one of the following:
 701     *    return (-n);  chunk had an error
 702     *    return (0);  did not recognize
 703     *    return (n);  success
 704     *
 705     * The unknown chunk structure contains the chunk data:
 706     * png_byte name[5];
 707     * png_byte *data;
 708     * size_t size;
 709     *
 710     * Note that libpng has already taken care of the CRC handling.
 711     */
 712
 713    if (chunk->name[0] == 115 && chunk->name[1] ==  84 &&     /* s  T */
 714        chunk->name[2] ==  69 && chunk->name[3] ==  82)       /* E  R */
 715       {
 716          /* Found sTER chunk */
 717          if (chunk->size != 1)
 718             return (-1); /* Error return */
 719
 720          if (chunk->data[0] != 0 && chunk->data[0] != 1)
 721             return (-1);  /* Invalid mode */
 722
 723          if (set_location(png_ptr, my_user_chunk_data, have_sTER) != 0)
 724          {
 725             my_user_chunk_data->sTER_mode=chunk->data[0];
 726             return (1);
 727          }
 728
 729          else
 730             return (0); /* duplicate sTER - give it to libpng */
 731       }
 732
 733    if (chunk->name[0] != 118 || chunk->name[1] != 112 ||    /* v  p */
 734        chunk->name[2] !=  65 || chunk->name[3] != 103)      /* A  g */
 735       return (0); /* Did not recognize */
 736
 737    /* Found ImageMagick vpAg chunk */
 738
 739    if (chunk->size != 9)
 740       return (-1); /* Error return */
 741
 742    if (set_location(png_ptr, my_user_chunk_data, have_vpAg) == 0)
 743       return (0);  /* duplicate vpAg */
 744
 745    my_user_chunk_data->vpAg_width = png_get_uint_31(png_ptr, chunk->data);
 746    my_user_chunk_data->vpAg_height = png_get_uint_31(png_ptr, chunk->data + 4);
 747    my_user_chunk_data->vpAg_units = chunk->data[8];
 748
 749    return (1);
 750 }
 751
 752 #ifdef PNG_WRITE_SUPPORTED
 753 static void
 754 write_sTER_chunk(png_structp write_ptr)
 755 {
 756    png_byte sTER[5] = {115,  84,  69,  82, '\0'};
 757
 758    if (verbose != 0)
 759       fprintf(STDERR, "\n stereo mode = %d\n", user_chunk_data.sTER_mode);
 760
 761    png_write_chunk(write_ptr, sTER, &user_chunk_data.sTER_mode, 1);
 762 }
 763
 764 static void
 765 write_vpAg_chunk(png_structp write_ptr)
 766 {
 767    png_byte vpAg[5] = {118, 112,  65, 103, '\0'};
 768
 769    png_byte vpag_chunk_data[9];
 770
 771    if (verbose != 0)
 772       fprintf(STDERR, " vpAg = %lu x %lu, units = %d\n",
 773           (unsigned long)user_chunk_data.vpAg_width,
 774           (unsigned long)user_chunk_data.vpAg_height,
 775           user_chunk_data.vpAg_units);
 776
 777    png_save_uint_32(vpag_chunk_data, user_chunk_data.vpAg_width);
 778    png_save_uint_32(vpag_chunk_data + 4, user_chunk_data.vpAg_height);
 779    vpag_chunk_data[8] = user_chunk_data.vpAg_units;
 780    png_write_chunk(write_ptr, vpAg, vpag_chunk_data, 9);
 781 }
 782
 783 static void
 784 write_chunks(png_structp write_ptr, int location)
 785 {
 786    int i;
 787
 788    /* Notice that this preserves the original chunk order, however chunks
 789     * intercepted by the callback will be written *after* chunks passed to
 790     * libpng.  This will actually reverse a pair of sTER chunks or a pair of
 791     * vpAg chunks, resulting in an error later.  This is not worth worrying
 792     * about - the chunks should not be duplicated!
 793     */
 794    for (i=0; i<2; ++i)
 795    {
 796       if (user_chunk_data.location[i] == (location | have_sTER))
 797          write_sTER_chunk(write_ptr);
 798
 799       else if (user_chunk_data.location[i] == (location | have_vpAg))
 800          write_vpAg_chunk(write_ptr);
 801    }
 802 }
 803 #endif /* WRITE */
 804 #else /* !READ_USER_CHUNKS */
 805 #  define write_chunks(pp,loc) ((void)0)
 806 #endif
 807 /* END of code to demonstrate user chunk support */
 808
 809 /* START of code to check that libpng has the required text support; this only
 810  * checks for the write support because if read support is missing the chunk
 811  * will simply not be reported back to pngtest.
 812  */
 813 #ifdef PNG_TEXT_SUPPORTED
 814 static void
 815 pngtest_check_text_support(png_structp png_ptr, png_textp text_ptr,
 816     int num_text)
 817 {
 818    while (num_text > 0)
 819    {
 820       switch (text_ptr[--num_text].compression)
 821       {
 822          case PNG_TEXT_COMPRESSION_NONE:
 823             break;
 824
 825          case PNG_TEXT_COMPRESSION_zTXt:
 826 #           ifndef PNG_WRITE_zTXt_SUPPORTED
 827                ++unsupported_chunks;
 828                /* In libpng 1.7 this now does an app-error, so stop it: */
 829                text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
 830 #           endif
 831             break;
 832
 833          case PNG_ITXT_COMPRESSION_NONE:
 834          case PNG_ITXT_COMPRESSION_zTXt:
 835 #           ifndef PNG_WRITE_iTXt_SUPPORTED
 836                ++unsupported_chunks;
 837                text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
 838 #           endif
 839             break;
 840
 841          default:
 842             /* This is an error */
 843             png_error(png_ptr, "invalid text chunk compression field");
 844             break;
 845       }
 846    }
 847 }
 848 #endif
 849 /* END of code to check that libpng has the required text support */
 850
 851 /* Test one file */
 852 static int
 853 test_one_file(const char *inname, const char *outname)
 854 {
 855    static png_FILE_p fpin;
 856    static png_FILE_p fpout;  /* "static" prevents setjmp corruption */
 857    pngtest_error_parameters error_parameters;
 858    png_structp read_ptr;
 859    png_infop read_info_ptr, end_info_ptr;
 860 #ifdef PNG_WRITE_SUPPORTED
 861    png_structp write_ptr;
 862    png_infop write_info_ptr;
 863    png_infop write_end_info_ptr;
 864 #ifdef PNG_WRITE_FILTER_SUPPORTED
 865    int interlace_preserved = 1;
 866 #endif /* WRITE_FILTER */
 867 #else /* !WRITE */
 868    png_structp write_ptr = NULL;
 869    png_infop write_info_ptr = NULL;
 870    png_infop write_end_info_ptr = NULL;
 871 #endif /* !WRITE */
 872    png_bytep row_buf;
 873    png_uint_32 y;
 874    png_uint_32 width, height;
 875    volatile int num_passes;
 876    int pass;
 877    int bit_depth, color_type;
 878 #ifdef PNG_APNG_SUPPORTED
 879    png_uint_32 num_frames;
 880    png_uint_32 num_plays;
 881 #endif
 882
 883    row_buf = NULL;
 884    error_parameters.file_name = inname;
 885
 886    if ((fpin = fopen(inname, "rb")) == NULL)
 887    {
 888       fprintf(STDERR, "Could not find input file %s\n", inname);
 889       return (1);
 890    }
 891
 892    if ((fpout = fopen(outname, "wb")) == NULL)
 893    {
 894       fprintf(STDERR, "Could not open output file %s\n", outname);
 895       FCLOSE(fpin);
 896       return (1);
 897    }
 898
 899    pngtest_debug("Allocating read and write structures");
 900 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
 901    read_ptr =
 902        png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL,
 903        NULL, NULL, NULL, png_debug_malloc, png_debug_free);
 904 #else
 905    read_ptr =
 906        png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 907 #endif
 908    png_set_error_fn(read_ptr, &error_parameters, pngtest_error,
 909        pngtest_warning);
 910
 911 #ifdef PNG_WRITE_SUPPORTED
 912 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
 913    write_ptr =
 914        png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL,
 915        NULL, NULL, NULL, png_debug_malloc, png_debug_free);
 916 #else
 917    write_ptr =
 918        png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 919 #endif
 920    png_set_error_fn(write_ptr, &error_parameters, pngtest_error,
 921        pngtest_warning);
 922 #endif
 923    pngtest_debug("Allocating read_info, write_info and end_info structures");
 924    read_info_ptr = png_create_info_struct(read_ptr);
 925    end_info_ptr = png_create_info_struct(read_ptr);
 926 #ifdef PNG_WRITE_SUPPORTED
 927    write_info_ptr = png_create_info_struct(write_ptr);
 928    write_end_info_ptr = png_create_info_struct(write_ptr);
 929 #endif
 930
 931 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
 932    init_callback_info(read_info_ptr);
 933    png_set_read_user_chunk_fn(read_ptr, &user_chunk_data,
 934        read_user_chunk_callback);
 935 #endif
 936
 937 #ifdef PNG_SETJMP_SUPPORTED
 938    pngtest_debug("Setting jmpbuf for read struct");
 939    if (setjmp(png_jmpbuf(read_ptr)))
 940    {
 941       fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
 942       png_free(read_ptr, row_buf);
 943       row_buf = NULL;
 944       if (verbose != 0)
 945         fprintf(STDERR, "   destroy read structs\n");
 946       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
 947 #ifdef PNG_WRITE_SUPPORTED
 948       if (verbose != 0)
 949         fprintf(STDERR, "   destroy write structs\n");
 950       png_destroy_info_struct(write_ptr, &write_end_info_ptr);
 951       png_destroy_write_struct(&write_ptr, &write_info_ptr);
 952 #endif
 953       FCLOSE(fpin);
 954       FCLOSE(fpout);
 955       return (1);
 956    }
 957
 958 #ifdef PNG_WRITE_SUPPORTED
 959    pngtest_debug("Setting jmpbuf for write struct");
 960
 961    if (setjmp(png_jmpbuf(write_ptr)))
 962    {
 963       fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
 964       png_free(read_ptr, row_buf);
 965       row_buf = NULL;
 966       if (verbose != 0)
 967         fprintf(STDERR, "   destroying read structs\n");
 968       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
 969       if (verbose != 0)
 970         fprintf(STDERR, "   destroying write structs\n");
 971       png_destroy_info_struct(write_ptr, &write_end_info_ptr);
 972       png_destroy_write_struct(&write_ptr, &write_info_ptr);
 973       FCLOSE(fpin);
 974       FCLOSE(fpout);
 975       return (1);
 976    }
 977 #endif
 978 #endif
 979
 980 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 981    if (strict != 0)
 982    {
 983       /* Treat png_benign_error() as errors on read */
 984       png_set_benign_errors(read_ptr, 0);
 985
 986 # ifdef PNG_WRITE_SUPPORTED
 987       /* Treat them as errors on write */
 988       png_set_benign_errors(write_ptr, 0);
 989 # endif
 990
 991       /* if strict is not set, then app warnings and errors are treated as
 992        * warnings in release builds, but not in unstable builds; this can be
 993        * changed with '--relaxed'.
 994        */
 995    }
 996
 997    else if (relaxed != 0)
 998    {
 999       /* Allow application (pngtest) errors and warnings to pass */
1000       png_set_benign_errors(read_ptr, 1);
1001
1002       /* Turn off CRC checking while reading */
1003       png_set_crc_action(read_ptr, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
1004
1005 #ifdef PNG_IGNORE_ADLER32
1006       /* Turn off ADLER32 checking while reading */
1007       png_set_option(read_ptr, PNG_IGNORE_ADLER32, PNG_OPTION_ON);
1008 #endif
1009
1010 # ifdef PNG_WRITE_SUPPORTED
1011       png_set_benign_errors(write_ptr, 1);
1012 # endif
1013
1014    }
1015 #endif /* BENIGN_ERRORS */
1016
1017    pngtest_debug("Initializing input and output streams");
1018 #ifdef PNG_STDIO_SUPPORTED
1019    png_init_io(read_ptr, fpin);
1020 #  ifdef PNG_WRITE_SUPPORTED
1021    png_init_io(write_ptr, fpout);
1022 #  endif
1023 #else
1024    png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);
1025 #  ifdef PNG_WRITE_SUPPORTED
1026    png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,
1027 #    ifdef PNG_WRITE_FLUSH_SUPPORTED
1028        pngtest_flush);
1029 #    else
1030        NULL);
1031 #    endif
1032 #  endif
1033 #endif
1034
1035    if (status_dots_requested == 1)
1036    {
1037 #ifdef PNG_WRITE_SUPPORTED
1038       png_set_write_status_fn(write_ptr, write_row_callback);
1039 #endif
1040       png_set_read_status_fn(read_ptr, read_row_callback);
1041    }
1042
1043    else
1044    {
1045 #ifdef PNG_WRITE_SUPPORTED
1046       png_set_write_status_fn(write_ptr, NULL);
1047 #endif
1048       png_set_read_status_fn(read_ptr, NULL);
1049    }
1050
1051 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1052    png_set_read_user_transform_fn(read_ptr, read_user_callback);
1053 #endif
1054 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1055    zero_samples = 0;
1056    png_set_write_user_transform_fn(write_ptr, count_zero_samples);
1057 #endif
1058
1059 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
1060    /* Preserve all the unknown chunks, if possible.  If this is disabled then,
1061     * even if the png_{get,set}_unknown_chunks stuff is enabled, we can't use
1062     * libpng to *save* the unknown chunks on read (because we can't switch the
1063     * save option on!)
1064     *
1065     * Notice that if SET_UNKNOWN_CHUNKS is *not* supported read will discard all
1066     * unknown chunks and write will write them all.
1067     */
1068 #ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
1069    png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,
1070        NULL, 0);
1071 #endif
1072 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1073    png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS,
1074        NULL, 0);
1075 #endif
1076 #endif
1077
1078    pngtest_debug("Reading info struct");
1079    png_read_info(read_ptr, read_info_ptr);
1080
1081 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1082    /* This is a bit of a hack; there is no obvious way in the callback function
1083     * to determine that the chunks before the first IDAT have been read, so
1084     * remove the info_ptr (which is only used to determine position relative to
1085     * PLTE) here to indicate that we are after the IDAT.
1086     */
1087    user_chunk_data.info_ptr = NULL;
1088 #endif
1089
1090    pngtest_debug("Transferring info struct");
1091    {
1092       int interlace_type, compression_type, filter_type;
1093
1094       if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
1095           &color_type, &interlace_type, &compression_type, &filter_type) != 0)
1096       {
1097          png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
1098              color_type, interlace_type, compression_type, filter_type);
1099          /* num_passes may not be available below if interlace support is not
1100           * provided by libpng for both read and write.
1101           */
1102          switch (interlace_type)
1103          {
1104             case PNG_INTERLACE_NONE:
1105                num_passes = 1;
1106                break;
1107
1108             case PNG_INTERLACE_ADAM7:
1109                num_passes = 7;
1110                break;
1111
1112             default:
1113                png_error(read_ptr, "invalid interlace type");
1114                /*NOT REACHED*/
1115          }
1116       }
1117
1118       else
1119          png_error(read_ptr, "png_get_IHDR failed");
1120    }
1121 #ifdef PNG_FIXED_POINT_SUPPORTED
1122 #ifdef PNG_cHRM_SUPPORTED
1123    {
1124       png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
1125           blue_y;
1126
1127       if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y,
1128           &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
1129       {
1130          png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,
1131              red_y, green_x, green_y, blue_x, blue_y);
1132       }
1133    }
1134 #endif
1135 #ifdef PNG_gAMA_SUPPORTED
1136    {
1137       png_fixed_point gamma;
1138
1139       if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma) != 0)
1140          png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
1141    }
1142 #endif
1143 #else /* Use floating point versions */
1144 #ifdef PNG_FLOATING_POINT_SUPPORTED
1145 #ifdef PNG_cHRM_SUPPORTED
1146    {
1147       double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
1148           blue_y;
1149
1150       if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
1151           &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
1152       {
1153          png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
1154              red_y, green_x, green_y, blue_x, blue_y);
1155       }
1156    }
1157 #endif
1158 #ifdef PNG_gAMA_SUPPORTED
1159    {
1160       double gamma;
1161
1162       if (png_get_gAMA(read_ptr, read_info_ptr, &gamma) != 0)
1163          png_set_gAMA(write_ptr, write_info_ptr, gamma);
1164    }
1165 #endif
1166 #endif /* Floating point */
1167 #endif /* Fixed point */
1168 #ifdef PNG_iCCP_SUPPORTED
1169    {
1170       png_charp name;
1171       png_bytep profile;
1172       png_uint_32 proflen;
1173       int compression_type;
1174
1175       if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,
1176           &profile, &proflen) != 0)
1177       {
1178          png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,
1179              profile, proflen);
1180       }
1181    }
1182 #endif
1183 #ifdef PNG_sRGB_SUPPORTED
1184    {
1185       int intent;
1186
1187       if (png_get_sRGB(read_ptr, read_info_ptr, &intent) != 0)
1188          png_set_sRGB(write_ptr, write_info_ptr, intent);
1189    }
1190 #endif
1191    {
1192       png_colorp palette;
1193       int num_palette;
1194
1195       if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette) != 0)
1196          png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
1197    }
1198 #ifdef PNG_bKGD_SUPPORTED
1199    {
1200       png_color_16p background;
1201
1202       if (png_get_bKGD(read_ptr, read_info_ptr, &background) != 0)
1203       {
1204          png_set_bKGD(write_ptr, write_info_ptr, background);
1205       }
1206    }
1207 #endif
1208 #ifdef PNG_READ_eXIf_SUPPORTED
1209    {
1210       png_bytep exif=NULL;
1211       png_uint_32 exif_length;
1212
1213       if (png_get_eXIf_1(read_ptr, read_info_ptr, &exif_length, &exif) != 0)
1214       {
1215          if (exif_length > 1)
1216             fprintf(STDERR," eXIf type %c%c, %lu bytes\n",exif[0],exif[1],
1217                (unsigned long)exif_length);
1218 # ifdef PNG_WRITE_eXIf_SUPPORTED
1219          png_set_eXIf_1(write_ptr, write_info_ptr, exif_length, exif);
1220 # endif
1221       }
1222    }
1223 #endif
1224 #ifdef PNG_hIST_SUPPORTED
1225    {
1226       png_uint_16p hist;
1227
1228       if (png_get_hIST(read_ptr, read_info_ptr, &hist) != 0)
1229          png_set_hIST(write_ptr, write_info_ptr, hist);
1230    }
1231 #endif
1232 #ifdef PNG_oFFs_SUPPORTED
1233    {
1234       png_int_32 offset_x, offset_y;
1235       int unit_type;
1236
1237       if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
1238           &unit_type) != 0)
1239       {
1240          png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
1241       }
1242    }
1243 #endif
1244 #ifdef PNG_pCAL_SUPPORTED
1245    {
1246       png_charp purpose, units;
1247       png_charpp params;
1248       png_int_32 X0, X1;
1249       int type, nparams;
1250
1251       if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
1252           &nparams, &units, &params) != 0)
1253       {
1254          png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
1255              nparams, units, params);
1256       }
1257    }
1258 #endif
1259 #ifdef PNG_pHYs_SUPPORTED
1260    {
1261       png_uint_32 res_x, res_y;
1262       int unit_type;
1263
1264       if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y,
1265           &unit_type) != 0)
1266          png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
1267    }
1268 #endif
1269 #ifdef PNG_sBIT_SUPPORTED
1270    {
1271       png_color_8p sig_bit;
1272
1273       if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit) != 0)
1274          png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
1275    }
1276 #endif
1277 #ifdef PNG_sCAL_SUPPORTED
1278 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
1279    defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
1280    {
1281       int unit;
1282       double scal_width, scal_height;
1283
1284       if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,
1285           &scal_height) != 0)
1286       {
1287          png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);
1288       }
1289    }
1290 #else
1291 #ifdef PNG_FIXED_POINT_SUPPORTED
1292    {
1293       int unit;
1294       png_charp scal_width, scal_height;
1295
1296       if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,
1297            &scal_height) != 0)
1298       {
1299          png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width,
1300              scal_height);
1301       }
1302    }
1303 #endif
1304 #endif
1305 #endif
1306
1307 #ifdef PNG_sPLT_SUPPORTED
1308    {
1309        png_sPLT_tp entries;
1310
1311        int num_entries = (int) png_get_sPLT(read_ptr, read_info_ptr, &entries);
1312        if (num_entries)
1313        {
1314            png_set_sPLT(write_ptr, write_info_ptr, entries, num_entries);
1315        }
1316    }
1317 #endif
1318
1319 #ifdef PNG_TEXT_SUPPORTED
1320    {
1321       png_textp text_ptr;
1322       int num_text;
1323
1324       if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
1325       {
1326          pngtest_debug1("Handling %d iTXt/tEXt/zTXt chunks", num_text);
1327
1328          pngtest_check_text_support(read_ptr, text_ptr, num_text);
1329
1330          if (verbose != 0)
1331          {
1332             int i;
1333
1334             fprintf(STDERR,"\n");
1335             for (i=0; i<num_text; i++)
1336             {
1337                fprintf(STDERR,"   Text compression[%d]=%d\n",
1338                    i, text_ptr[i].compression);
1339             }
1340          }
1341
1342          png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
1343       }
1344    }
1345 #endif
1346 #ifdef PNG_tIME_SUPPORTED
1347    {
1348       png_timep mod_time;
1349
1350       if (png_get_tIME(read_ptr, read_info_ptr, &mod_time) != 0)
1351       {
1352          png_set_tIME(write_ptr, write_info_ptr, mod_time);
1353 #ifdef PNG_TIME_RFC1123_SUPPORTED
1354          if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
1355             tIME_string[(sizeof tIME_string) - 1] = '\0';
1356
1357          else
1358          {
1359             strncpy(tIME_string, "*** invalid time ***", (sizeof tIME_string));
1360             tIME_string[(sizeof tIME_string) - 1] = '\0';
1361          }
1362
1363          tIME_chunk_present++;
1364 #endif /* TIME_RFC1123 */
1365       }
1366    }
1367 #endif
1368 #ifdef PNG_tRNS_SUPPORTED
1369    {
1370       png_bytep trans_alpha;
1371       int num_trans;
1372       png_color_16p trans_color;
1373
1374       if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,
1375           &trans_color) != 0)
1376       {
1377          int sample_max = (1 << bit_depth);
1378          /* libpng doesn't reject a tRNS chunk with out-of-range samples */
1379          if (!((color_type == PNG_COLOR_TYPE_GRAY &&
1380              (int)trans_color->gray > sample_max) ||
1381              (color_type == PNG_COLOR_TYPE_RGB &&
1382              ((int)trans_color->red > sample_max ||
1383              (int)trans_color->green > sample_max ||
1384              (int)trans_color->blue > sample_max))))
1385             png_set_tRNS(write_ptr, write_info_ptr, trans_alpha, num_trans,
1386                trans_color);
1387       }
1388    }
1389 #endif
1390
1391 #ifdef PNG_APNG_SUPPORTED
1392    if (png_get_valid(read_ptr, read_info_ptr, PNG_INFO_acTL))
1393    {
1394       if (png_get_acTL(read_ptr, read_info_ptr, &num_frames, &num_plays))
1395       {
1396          png_byte is_hidden;
1397          pngtest_debug2("Handling acTL chunks (frames %ld, plays %ld)",
1398                     num_frames, num_plays);
1399          png_set_acTL(write_ptr, write_info_ptr, num_frames, num_plays);
1400          is_hidden = png_get_first_frame_is_hidden(read_ptr, read_info_ptr);
1401          png_set_first_frame_is_hidden(write_ptr, write_info_ptr, is_hidden);
1402       }
1403    }
1404 #endif
1405
1406 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1407    {
1408       png_unknown_chunkp unknowns;
1409       int num_unknowns = png_get_unknown_chunks(read_ptr, read_info_ptr,
1410           &unknowns);
1411
1412       if (num_unknowns != 0)
1413       {
1414          png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
1415              num_unknowns);
1416 #if PNG_LIBPNG_VER < 10600
1417          /* Copy the locations from the read_info_ptr.  The automatically
1418           * generated locations in write_end_info_ptr are wrong prior to 1.6.0
1419           * because they are reset from the write pointer (removed in 1.6.0).
1420           */
1421          {
1422             int i;
1423             for (i = 0; i < num_unknowns; i++)
1424               png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
1425                   unknowns[i].location);
1426          }
1427 #endif
1428       }
1429    }
1430 #endif
1431
1432 #ifdef PNG_WRITE_SUPPORTED
1433    pngtest_debug("Writing info struct");
1434
1435    /* Write the info in two steps so that if we write the 'unknown' chunks here
1436     * they go to the correct place.
1437     */
1438    png_write_info_before_PLTE(write_ptr, write_info_ptr);
1439
1440    write_chunks(write_ptr, before_PLTE); /* before PLTE */
1441
1442    png_write_info(write_ptr, write_info_ptr);
1443
1444    write_chunks(write_ptr, before_IDAT); /* after PLTE */
1445
1446    png_write_info(write_ptr, write_end_info_ptr);
1447
1448    write_chunks(write_ptr, after_IDAT); /* after IDAT */
1449
1450 #ifdef PNG_COMPRESSION_COMPAT
1451    /* Test the 'compatibility' setting here, if it is available. */
1452    png_set_compression(write_ptr, PNG_COMPRESSION_COMPAT);
1453 #endif
1454 #endif
1455
1456 #ifdef SINGLE_ROWBUF_ALLOC
1457    pngtest_debug("Allocating row buffer...");
1458    row_buf = (png_bytep)png_malloc(read_ptr,
1459        png_get_rowbytes(read_ptr, read_info_ptr));
1460
1461    pngtest_debug1("\t%p", row_buf);
1462 #endif /* SINGLE_ROWBUF_ALLOC */
1463    pngtest_debug("Writing row data");
1464
1465 #if defined(PNG_READ_INTERLACING_SUPPORTED) &&\
1466    defined(PNG_WRITE_INTERLACING_SUPPORTED)
1467    /* Both must be defined for libpng to be able to handle the interlace,
1468     * otherwise it gets handled below by simply reading and writing the passes
1469     * directly.
1470     */
1471    if (png_set_interlace_handling(read_ptr) != num_passes)
1472       png_error(write_ptr,
1473           "png_set_interlace_handling(read): wrong pass count ");
1474    if (png_set_interlace_handling(write_ptr) != num_passes)
1475       png_error(write_ptr,
1476           "png_set_interlace_handling(write): wrong pass count ");
1477 #else /* png_set_interlace_handling not called on either read or write */
1478 #  define calc_pass_height
1479 #endif /* not using libpng interlace handling */
1480
1481 #ifdef PNGTEST_TIMING
1482    t_stop = (float)clock();
1483    t_misc += (t_stop - t_start);
1484    t_start = t_stop;
1485 #endif
1486 #ifdef PNG_APNG_SUPPORTED
1487    if (png_get_valid(read_ptr, read_info_ptr, PNG_INFO_acTL))
1488    {
1489       png_uint_32 frame;
1490       for (frame = 0; frame < num_frames; frame++)
1491       {
1492          png_uint_32 frame_width;
1493          png_uint_32 frame_height;
1494          png_uint_32 x_offset;
1495          png_uint_32 y_offset;
1496          png_uint_16 delay_num;
1497          png_uint_16 delay_den;
1498          png_byte dispose_op;
1499          png_byte blend_op;
1500          png_read_frame_head(read_ptr, read_info_ptr);
1501          if (png_get_valid(read_ptr, read_info_ptr, PNG_INFO_fcTL))
1502          {
1503             png_get_next_frame_fcTL(read_ptr, read_info_ptr,
1504                                     &frame_width, &frame_height,
1505                                     &x_offset, &y_offset,
1506                                     &delay_num, &delay_den,
1507                                     &dispose_op, &blend_op);
1508          }
1509          else
1510          {
1511             frame_width = width;
1512             frame_height = height;
1513             x_offset = 0;
1514             y_offset = 0;
1515             delay_num = 1;
1516             delay_den = 1;
1517             dispose_op = PNG_DISPOSE_OP_NONE;
1518             blend_op = PNG_BLEND_OP_SOURCE;
1519          }
1520 #ifdef PNG_WRITE_APNG_SUPPORTED
1521          png_write_frame_head(write_ptr, write_info_ptr, (png_bytepp)&row_buf,
1522                               frame_width, frame_height,
1523                               x_offset, y_offset,
1524                               delay_num, delay_den,
1525                               dispose_op, blend_op);
1526 #endif
1527          for (pass = 0; pass < num_passes; pass++)
1528          {
1529 #           ifdef calc_pass_height
1530                png_uint_32 pass_height;
1531
1532                if (num_passes == 7) /* interlaced */
1533                {
1534                   if (PNG_PASS_COLS(frame_width, pass) > 0)
1535                      pass_height = PNG_PASS_ROWS(frame_height, pass);
1536
1537                   else
1538                      pass_height = 0;
1539                }
1540
1541                else /* not interlaced */
1542                   pass_height = frame_height;
1543 #           else
1544 #              define pass_height frame_height
1545 #           endif
1546
1547             pngtest_debug1("Writing row data for pass %d", pass);
1548             for (y = 0; y < pass_height; y++)
1549             {
1550 #ifndef SINGLE_ROWBUF_ALLOC
1551                pngtest_debug2("Allocating row buffer (pass %d, y = %u)...", pass, y);
1552
1553                row_buf = (png_bytep)png_malloc(read_ptr,
1554                   png_get_rowbytes(read_ptr, read_info_ptr));
1555
1556                pngtest_debug2("\t0x%08lx (%lu bytes)", (unsigned long)row_buf,
1557                   (unsigned long)png_get_rowbytes(read_ptr, read_info_ptr));
1558
1559 #endif /* !SINGLE_ROWBUF_ALLOC */
1560                png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);
1561
1562 #ifdef PNG_WRITE_SUPPORTED
1563 #ifdef PNGTEST_TIMING
1564                t_stop = (float)clock();
1565                t_decode += (t_stop - t_start);
1566                t_start = t_stop;
1567 #endif
1568                png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
1569 #ifdef PNGTEST_TIMING
1570                t_stop = (float)clock();
1571                t_encode += (t_stop - t_start);
1572                t_start = t_stop;
1573 #endif
1574 #endif /* PNG_WRITE_SUPPORTED */
1575
1576 #ifndef SINGLE_ROWBUF_ALLOC
1577                pngtest_debug2("Freeing row buffer (pass %d, y = %u)", pass, y);
1578                png_free(read_ptr, row_buf);
1579                row_buf = NULL;
1580 #endif /* !SINGLE_ROWBUF_ALLOC */
1581             }
1582          }
1583 #ifdef PNG_WRITE_APNG_SUPPORTED
1584          png_write_frame_tail(write_ptr, write_info_ptr);
1585 #endif
1586       }
1587    }
1588    else
1589 #endif
1590    for (pass = 0; pass < num_passes; pass++)
1591    {
1592 #     ifdef calc_pass_height
1593          png_uint_32 pass_height;
1594
1595          if (num_passes == 7) /* interlaced */
1596          {
1597             if (PNG_PASS_COLS(width, pass) > 0)
1598                pass_height = PNG_PASS_ROWS(height, pass);
1599
1600             else
1601                pass_height = 0;
1602          }
1603
1604          else /* not interlaced */
1605             pass_height = height;
1606 #     else
1607 #        define pass_height height
1608 #     endif
1609
1610       pngtest_debug1("Writing row data for pass %d", pass);
1611       for (y = 0; y < pass_height; y++)
1612       {
1613 #ifndef SINGLE_ROWBUF_ALLOC
1614          pngtest_debug2("Allocating row buffer (pass %d, y = %u)...", pass, y);
1615
1616          row_buf = (png_bytep)png_malloc(read_ptr,
1617              png_get_rowbytes(read_ptr, read_info_ptr));
1618
1619          pngtest_debug2("\t%p (%lu bytes)", row_buf,
1620              (unsigned long)png_get_rowbytes(read_ptr, read_info_ptr));
1621
1622 #endif /* !SINGLE_ROWBUF_ALLOC */
1623          png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);
1624
1625 #ifdef PNG_WRITE_SUPPORTED
1626 #ifdef PNGTEST_TIMING
1627          t_stop = (float)clock();
1628          t_decode += (t_stop - t_start);
1629          t_start = t_stop;
1630 #endif
1631          png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
1632 #ifdef PNGTEST_TIMING
1633          t_stop = (float)clock();
1634          t_encode += (t_stop - t_start);
1635          t_start = t_stop;
1636 #endif
1637 #endif /* WRITE */
1638
1639 #ifndef SINGLE_ROWBUF_ALLOC
1640          pngtest_debug2("Freeing row buffer (pass %d, y = %u)", pass, y);
1641          png_free(read_ptr, row_buf);
1642          row_buf = NULL;
1643 #endif /* !SINGLE_ROWBUF_ALLOC */
1644       }
1645    }
1646
1647 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1648 #  ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
1649       png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
1650 #  endif
1651 #  ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1652       png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
1653 #  endif
1654 #endif
1655
1656    pngtest_debug("Reading and writing end_info data");
1657
1658    png_read_end(read_ptr, end_info_ptr);
1659 #ifdef PNG_TEXT_SUPPORTED
1660    {
1661       png_textp text_ptr;
1662       int num_text;
1663
1664       if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)
1665       {
1666          pngtest_debug1("Handling %d iTXt/tEXt/zTXt chunks", num_text);
1667
1668          pngtest_check_text_support(read_ptr, text_ptr, num_text);
1669
1670          if (verbose != 0)
1671          {
1672             int i;
1673
1674             fprintf(STDERR,"\n");
1675             for (i=0; i<num_text; i++)
1676             {
1677                fprintf(STDERR,"   Text compression[%d]=%d\n",
1678                    i, text_ptr[i].compression);
1679             }
1680          }
1681
1682          png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);
1683       }
1684    }
1685 #endif
1686 #ifdef PNG_READ_eXIf_SUPPORTED
1687    {
1688       png_bytep exif=NULL;
1689       png_uint_32 exif_length;
1690
1691       if (png_get_eXIf_1(read_ptr, end_info_ptr, &exif_length, &exif) != 0)
1692       {
1693          if (exif_length > 1)
1694             fprintf(STDERR," eXIf type %c%c, %lu bytes\n",exif[0],exif[1],
1695                (unsigned long)exif_length);
1696 # ifdef PNG_WRITE_eXIf_SUPPORTED
1697          png_set_eXIf_1(write_ptr, write_end_info_ptr, exif_length, exif);
1698 # endif
1699       }
1700    }
1701 #endif
1702 #ifdef PNG_tIME_SUPPORTED
1703    {
1704       png_timep mod_time;
1705
1706       if (png_get_tIME(read_ptr, end_info_ptr, &mod_time) != 0)
1707       {
1708          png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
1709 #ifdef PNG_TIME_RFC1123_SUPPORTED
1710          if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
1711             tIME_string[(sizeof tIME_string) - 1] = '\0';
1712
1713          else
1714          {
1715             strncpy(tIME_string, "*** invalid time ***", sizeof tIME_string);
1716             tIME_string[(sizeof tIME_string)-1] = '\0';
1717          }
1718
1719          tIME_chunk_present++;
1720 #endif /* TIME_RFC1123 */
1721       }
1722    }
1723 #endif
1724 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1725    {
1726       png_unknown_chunkp unknowns;
1727       int num_unknowns = png_get_unknown_chunks(read_ptr, end_info_ptr,
1728           &unknowns);
1729
1730       if (num_unknowns != 0)
1731       {
1732          png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
1733              num_unknowns);
1734 #if PNG_LIBPNG_VER < 10600
1735          /* Copy the locations from the read_info_ptr.  The automatically
1736           * generated locations in write_end_info_ptr are wrong prior to 1.6.0
1737           * because they are reset from the write pointer (removed in 1.6.0).
1738           */
1739          {
1740             int i;
1741             for (i = 0; i < num_unknowns; i++)
1742               png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
1743                   unknowns[i].location);
1744          }
1745 #endif
1746       }
1747    }
1748 #endif
1749
1750 #ifdef PNG_WRITE_SUPPORTED
1751 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1752    /* Normally one would use Z_DEFAULT_STRATEGY for text compression.
1753     * This is here just to make pngtest replicate the results from libpng
1754     * versions prior to 1.5.4, and to test this new API.
1755     */
1756    png_set_text_compression_strategy(write_ptr, Z_FILTERED);
1757 #endif
1758
1759    /* When the unknown vpAg/sTER chunks are written by pngtest the only way to
1760     * do it is to write them *before* calling png_write_end.  When unknown
1761     * chunks are written by libpng, however, they are written just before IEND.
1762     * There seems to be no way round this, however vpAg/sTER are not expected
1763     * after IDAT.
1764     */
1765    write_chunks(write_ptr, after_IDAT);
1766
1767    png_write_end(write_ptr, write_end_info_ptr);
1768 #endif
1769
1770 #ifdef PNG_EASY_ACCESS_SUPPORTED
1771    if (verbose != 0)
1772    {
1773       png_uint_32 iwidth, iheight;
1774       iwidth = png_get_image_width(write_ptr, write_info_ptr);
1775       iheight = png_get_image_height(write_ptr, write_info_ptr);
1776       fprintf(STDERR, "\n Image width = %lu, height = %lu\n",
1777           (unsigned long)iwidth, (unsigned long)iheight);
1778    }
1779 #endif
1780
1781    pngtest_debug("Destroying data structs");
1782 #ifdef SINGLE_ROWBUF_ALLOC
1783    pngtest_debug("destroying row_buf for read_ptr");
1784    png_free(read_ptr, row_buf);
1785    row_buf = NULL;
1786 #endif /* SINGLE_ROWBUF_ALLOC */
1787    pngtest_debug("destroying read_ptr, read_info_ptr, end_info_ptr");
1788    png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
1789 #ifdef PNG_WRITE_SUPPORTED
1790    pngtest_debug("destroying write_end_info_ptr");
1791    png_destroy_info_struct(write_ptr, &write_end_info_ptr);
1792    pngtest_debug("destroying write_ptr, write_info_ptr");
1793    png_destroy_write_struct(&write_ptr, &write_info_ptr);
1794 #endif
1795    pngtest_debug("Destruction complete.");
1796
1797    FCLOSE(fpin);
1798    FCLOSE(fpout);
1799
1800    /* Summarize any warnings or errors and in 'strict' mode fail the test.
1801     * Unsupported chunks can result in warnings, in that case ignore the strict
1802     * setting, otherwise fail the test on warnings as well as errors.
1803     */
1804    if (error_count > 0)
1805    {
1806       /* We don't really expect to get here because of the setjmp handling
1807        * above, but this is safe.
1808        */
1809       fprintf(STDERR, "\n  %s: %d libpng errors found (%d warnings)",
1810           inname, error_count, warning_count);
1811
1812       if (strict != 0)
1813          return (1);
1814    }
1815
1816 #  ifdef PNG_WRITE_SUPPORTED
1817       /* If there is no write support nothing was written! */
1818       else if (unsupported_chunks > 0)
1819       {
1820          fprintf(STDERR, "\n  %s: unsupported chunks (%d)%s",
1821              inname, unsupported_chunks, strict ? ": IGNORED --strict!" : "");
1822       }
1823 #  endif
1824
1825    else if (warning_count > 0)
1826    {
1827       fprintf(STDERR, "\n  %s: %d libpng warnings found",
1828           inname, warning_count);
1829
1830       if (strict != 0)
1831          return (1);
1832    }
1833
1834    pngtest_debug("Opening files for comparison");
1835    if ((fpin = fopen(inname, "rb")) == NULL)
1836    {
1837       fprintf(STDERR, "Could not find file %s\n", inname);
1838       return (1);
1839    }
1840
1841    if ((fpout = fopen(outname, "rb")) == NULL)
1842    {
1843       fprintf(STDERR, "Could not find file %s\n", outname);
1844       FCLOSE(fpin);
1845       return (1);
1846    }
1847
1848 #if defined (PNG_WRITE_SUPPORTED) /* else nothing was written */ &&\
1849     defined (PNG_WRITE_FILTER_SUPPORTED)
1850    if (interlace_preserved != 0) /* else the files will be changed */
1851    {
1852       for (;;)
1853       {
1854          static int wrote_question = 0;
1855          size_t num_in, num_out;
1856          char inbuf[256], outbuf[256];
1857
1858          num_in = fread(inbuf, 1, sizeof inbuf, fpin);
1859          num_out = fread(outbuf, 1, sizeof outbuf, fpout);
1860
1861          if (num_in != num_out)
1862          {
1863             fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
1864                 inname, outname);
1865
1866             if (wrote_question == 0 && unsupported_chunks == 0)
1867             {
1868                fprintf(STDERR,
1869                    "   Was %s written with the same maximum IDAT"
1870                    " chunk size (%d bytes),",
1871                    inname, PNG_ZBUF_SIZE);
1872                fprintf(STDERR,
1873                    "\n   filtering heuristic (libpng default), compression");
1874                fprintf(STDERR,
1875                    " level (zlib default),\n   and zlib version (%s)?\n\n",
1876                    ZLIB_VERSION);
1877                wrote_question = 1;
1878             }
1879
1880             FCLOSE(fpin);
1881             FCLOSE(fpout);
1882
1883             if (strict != 0 && unsupported_chunks == 0)
1884               return (1);
1885
1886             else
1887               return (0);
1888          }
1889
1890          if (num_in == 0)
1891             break;
1892
1893          if (memcmp(inbuf, outbuf, num_in))
1894          {
1895             fprintf(STDERR, "\nFiles %s and %s are different\n", inname,
1896                 outname);
1897
1898             if (wrote_question == 0 && unsupported_chunks == 0)
1899             {
1900                fprintf(STDERR,
1901                    "   Was %s written with the same maximum"
1902                    " IDAT chunk size (%d bytes),",
1903                     inname, PNG_ZBUF_SIZE);
1904                fprintf(STDERR,
1905                    "\n   filtering heuristic (libpng default), compression");
1906                fprintf(STDERR,
1907                    " level (zlib default),\n   and zlib version (%s)?\n\n",
1908                  ZLIB_VERSION);
1909                wrote_question = 1;
1910             }
1911
1912             FCLOSE(fpin);
1913             FCLOSE(fpout);
1914
1915             /* NOTE: the unsupported_chunks escape is permitted here because
1916              * unsupported text chunk compression will result in the compression
1917              * mode being changed (to NONE) yet, in the test case, the result
1918              * can be exactly the same size!
1919              */
1920             if (strict != 0 && unsupported_chunks == 0)
1921               return (1);
1922
1923             else
1924               return (0);
1925          }
1926       }
1927    }
1928 #endif /* WRITE && WRITE_FILTER */
1929
1930    FCLOSE(fpin);
1931    FCLOSE(fpout);
1932
1933    return (0);
1934 }
1935
1936 /* Input and output filenames */
1937 #ifdef RISCOS
1938 static const char *inname = "pngtest/png";
1939 static const char *outname = "pngout/png";
1940 #else
1941 static const char *inname = "pngtest.png";
1942 static const char *outname = "pngout.png";
1943 #endif
1944
1945 int
1946 main(int argc, char *argv[])
1947 {
1948    int multiple = 0;
1949    int ierror = 0;
1950
1951    png_structp dummy_ptr;
1952
1953    fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
1954    fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);
1955    fprintf(STDERR, "%s", png_get_copyright(NULL));
1956    /* Show the version of libpng used in building the library */
1957    fprintf(STDERR, " library (%lu):%s",
1958        (unsigned long)png_access_version_number(),
1959        png_get_header_version(NULL));
1960
1961    /* Show the version of libpng used in building the application */
1962    fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,
1963        PNG_HEADER_VERSION_STRING);
1964
1965    /* Do some consistency checking on the memory allocation settings, I'm
1966     * not sure this matters, but it is nice to know, the first of these
1967     * tests should be impossible because of the way the macros are set
1968     * in pngconf.h
1969     */
1970 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
1971       fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
1972 #endif
1973    /* I think the following can happen. */
1974 #if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
1975       fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");
1976 #endif
1977
1978    if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
1979    {
1980       fprintf(STDERR,
1981           "Warning: versions are different between png.h and png.c\n");
1982       fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);
1983       fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);
1984       ++ierror;
1985    }
1986
1987    if (argc > 1)
1988    {
1989       if (strcmp(argv[1], "-m") == 0)
1990       {
1991          multiple = 1;
1992          status_dots_requested = 0;
1993       }
1994
1995       else if (strcmp(argv[1], "-mv") == 0 ||
1996                strcmp(argv[1], "-vm") == 0 )
1997       {
1998          multiple = 1;
1999          verbose = 1;
2000          status_dots_requested = 1;
2001       }
2002
2003       else if (strcmp(argv[1], "-v") == 0)
2004       {
2005          verbose = 1;
2006          status_dots_requested = 1;
2007          inname = argv[2];
2008       }
2009
2010       else if (strcmp(argv[1], "--strict") == 0)
2011       {
2012          status_dots_requested = 0;
2013          verbose = 1;
2014          inname = argv[2];
2015          strict++;
2016          relaxed = 0;
2017          multiple=1;
2018       }
2019
2020       else if (strcmp(argv[1], "--relaxed") == 0)
2021       {
2022          status_dots_requested = 0;
2023          verbose = 1;
2024          inname = argv[2];
2025          strict = 0;
2026          relaxed++;
2027          multiple=1;
2028       }
2029       else if (strcmp(argv[1], "--xfail") == 0)
2030       {
2031          status_dots_requested = 0;
2032          verbose = 1;
2033          inname = argv[2];
2034          strict = 0;
2035          xfail++;
2036          relaxed++;
2037          multiple=1;
2038       }
2039
2040       else
2041       {
2042          inname = argv[1];
2043          status_dots_requested = 0;
2044       }
2045    }
2046
2047    if (multiple == 0 && argc == 3 + verbose)
2048       outname = argv[2 + verbose];
2049
2050    if ((multiple == 0 && argc > 3 + verbose) ||
2051        (multiple != 0 && argc < 2))
2052    {
2053       fprintf(STDERR,
2054           "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
2055           argv[0], argv[0]);
2056       fprintf(STDERR,
2057           "  reads/writes one PNG file (without -m) or multiple files (-m)\n");
2058       fprintf(STDERR,
2059           "  with -m %s is used as a temporary file\n", outname);
2060       exit(1);
2061    }
2062
2063    if (multiple != 0)
2064    {
2065       int i;
2066 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
2067       int allocation_now = current_allocation;
2068 #endif
2069       for (i=2; i<argc; ++i)
2070       {
2071          int kerror;
2072          fprintf(STDERR, "\n Testing %s:", argv[i]);
2073 #if PNG_DEBUG > 0
2074          fprintf(STDERR, "\n");
2075 #endif
2076          kerror = test_one_file(argv[i], outname);
2077          if (kerror == 0)
2078          {
2079 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
2080             fprintf(STDERR, "\n PASS (%lu zero samples)\n",
2081                 (unsigned long)zero_samples);
2082 #else
2083             fprintf(STDERR, " PASS\n");
2084 #endif
2085 #ifdef PNG_TIME_RFC1123_SUPPORTED
2086             if (tIME_chunk_present != 0)
2087                fprintf(STDERR, " tIME = %s\n", tIME_string);
2088
2089             tIME_chunk_present = 0;
2090 #endif /* TIME_RFC1123 */
2091          }
2092
2093          else
2094          {
2095             if (xfail)
2096               fprintf(STDERR, " XFAIL\n");
2097             else
2098             {
2099               fprintf(STDERR, " FAIL\n");
2100               ierror += kerror;
2101             }
2102          }
2103 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
2104          if (allocation_now != current_allocation)
2105             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
2106                 current_allocation - allocation_now);
2107
2108          if (current_allocation != 0)
2109          {
2110             memory_infop pinfo = pinformation;
2111
2112             fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
2113                 current_allocation);
2114
2115             while (pinfo != NULL)
2116             {
2117                fprintf(STDERR, " %lu bytes at %p\n",
2118                    (unsigned long)pinfo->size,
2119                    pinfo->pointer);
2120                pinfo = pinfo->next;
2121             }
2122          }
2123 #endif
2124       }
2125 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
2126          fprintf(STDERR, " Current memory allocation: %10d bytes\n",
2127              current_allocation);
2128          fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
2129              maximum_allocation);
2130          fprintf(STDERR, " Total   memory allocation: %10d bytes\n",
2131              total_allocation);
2132          fprintf(STDERR, "     Number of allocations: %10d\n",
2133              num_allocations);
2134 #endif
2135    }
2136
2137    else
2138    {
2139       int i;
2140       for (i = 0; i<3; ++i)
2141       {
2142          int kerror;
2143 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
2144          int allocation_now = current_allocation;
2145 #endif
2146          if (i == 1)
2147             status_dots_requested = 1;
2148
2149          else if (verbose == 0)
2150             status_dots_requested = 0;
2151
2152          if (i == 0 || verbose == 1 || ierror != 0)
2153          {
2154             fprintf(STDERR, "\n Testing %s:", inname);
2155 #if PNG_DEBUG > 0
2156             fprintf(STDERR, "\n");
2157 #endif
2158          }
2159
2160          kerror = test_one_file(inname, outname);
2161
2162          if (kerror == 0)
2163          {
2164             if (verbose == 1 || i == 2)
2165             {
2166 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
2167                 fprintf(STDERR, "\n PASS (%lu zero samples)\n",
2168                     (unsigned long)zero_samples);
2169 #else
2170                 fprintf(STDERR, " PASS\n");
2171 #endif
2172 #ifdef PNG_TIME_RFC1123_SUPPORTED
2173              if (tIME_chunk_present != 0)
2174                 fprintf(STDERR, " tIME = %s\n", tIME_string);
2175 #endif /* TIME_RFC1123 */
2176             }
2177          }
2178
2179          else
2180          {
2181             if (verbose == 0 && i != 2)
2182             {
2183                fprintf(STDERR, "\n Testing %s:", inname);
2184 #if PNG_DEBUG > 0
2185                fprintf(STDERR, "\n");
2186 #endif
2187             }
2188
2189             if (xfail)
2190               fprintf(STDERR, " XFAIL\n");
2191             else
2192             {
2193               fprintf(STDERR, " FAIL\n");
2194               ierror += kerror;
2195             }
2196          }
2197 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
2198          if (allocation_now != current_allocation)
2199              fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
2200                  current_allocation - allocation_now);
2201
2202          if (current_allocation != 0)
2203          {
2204              memory_infop pinfo = pinformation;
2205
2206              fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
2207                  current_allocation);
2208
2209              while (pinfo != NULL)
2210              {
2211                 fprintf(STDERR, " %lu bytes at %p\n",
2212                     (unsigned long)pinfo->size, pinfo->pointer);
2213                 pinfo = pinfo->next;
2214              }
2215           }
2216 #endif
2217        }
2218 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
2219        fprintf(STDERR, " Current memory allocation: %10d bytes\n",
2220            current_allocation);
2221        fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
2222            maximum_allocation);
2223        fprintf(STDERR, " Total   memory allocation: %10d bytes\n",
2224            total_allocation);
2225        fprintf(STDERR, "     Number of allocations: %10d\n",
2226            num_allocations);
2227 #endif
2228    }
2229
2230 #ifdef PNGTEST_TIMING
2231    t_stop = (float)clock();
2232    t_misc += (t_stop - t_start);
2233    t_start = t_stop;
2234    fprintf(STDERR, " CPU time used = %.3f seconds",
2235        (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);
2236    fprintf(STDERR, " (decoding %.3f,\n",
2237        t_decode/(float)CLOCKS_PER_SEC);
2238    fprintf(STDERR, "        encoding %.3f ,",
2239        t_encode/(float)CLOCKS_PER_SEC);
2240    fprintf(STDERR, " other %.3f seconds)\n\n",
2241        t_misc/(float)CLOCKS_PER_SEC);
2242 #endif
2243
2244    if (ierror == 0)
2245       fprintf(STDERR, " libpng passes test\n");
2246
2247    else
2248       fprintf(STDERR, " libpng FAILS test\n");
2249
2250    dummy_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
2251    fprintf(STDERR, " Default limits:\n");
2252    fprintf(STDERR, "  width_max  = %lu\n",
2253        (unsigned long) png_get_user_width_max(dummy_ptr));
2254    fprintf(STDERR, "  height_max = %lu\n",
2255        (unsigned long) png_get_user_height_max(dummy_ptr));
2256    if (png_get_chunk_cache_max(dummy_ptr) == 0)
2257       fprintf(STDERR, "  cache_max  = unlimited\n");
2258    else
2259       fprintf(STDERR, "  cache_max  = %lu\n",
2260           (unsigned long) png_get_chunk_cache_max(dummy_ptr));
2261    if (png_get_chunk_malloc_max(dummy_ptr) == 0)
2262       fprintf(STDERR, "  malloc_max = unlimited\n");
2263    else
2264       fprintf(STDERR, "  malloc_max = %lu\n",
2265           (unsigned long) png_get_chunk_malloc_max(dummy_ptr));
2266    png_destroy_read_struct(&dummy_ptr, NULL, NULL);
2267
2268    return (int)(ierror != 0);
2269 }
2270 #else
2271 int
2272 main(void)
2273 {
2274    fprintf(STDERR,
2275        " test ignored because libpng was not built with read support\n");
2276    /* And skip this test */
2277    return PNG_LIBPNG_VER < 10600 ? 0 : 77;
2278 }
2279 #endif
2280
2281 /* Generate a compiler error if there is an old png.h in the search path. */
2282 typedef png_libpng_version_1_6_40 Your_png_h_is_not_version_1_6_40;