1 

     2 /* pngtest.c - a simple test program to test libpng

     3  *

     4  * Last changed in libpng 1.2.32 [September 18, 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 29

    86 static int tIME_chunk_present = 0;

    87 static char tIME_string[PNG_tIME_STRING_LENGTH] = "tIME chunk is not present";

    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 /* In case a system header (e.g., on AIX) defined jmpbuf */

   103 #ifdef jmpbuf

   104 #  undef jmpbuf

   105 #endif

   106 

   107 /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */

   108 #ifndef png_jmpbuf

   109 #  define png_jmpbuf(png_ptr) png_ptr->jmpbuf

   110 #endif

   111 

   112 /* example of using row callbacks to make a simple progress meter */

   113 static int status_pass = 1;

   114 static int status_dots_requested = 0;

   115 static int status_dots = 1;

   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 

   440 /* This function is called when there is a warning, but the library thinks

   441  * it can continue anyway.  Replacement functions don't have to do anything

   442  * here if you don't want to.  In the default configuration, png_ptr is

   443  * not used, but it is passed in case it may be useful.

   444  */

   445 static void

   446 pngtest_warning(png_structp png_ptr, png_const_charp message)

   447 {

   448    PNG_CONST char *name = "UNKNOWN (ERROR!)";

   449    if (png_ptr != NULL && png_ptr->error_ptr != NULL)

   450       name = png_ptr->error_ptr;

   451    fprintf(STDERR, "%s: libpng warning: %s\n", name, message);

   452 }

   453 

   454 /* This is the default error handling function.  Note that replacements for

   455  * this function MUST NOT RETURN, or the program will likely crash.  This

   456  * function is used by default, or if the program supplies NULL for the

   457  * error function pointer in png_set_error_fn().

   458  */

   459 static void

   460 pngtest_error(png_structp png_ptr, png_const_charp message)

   461 {

   462    pngtest_warning(png_ptr, message);

   463    /* We can return because png_error calls the default handler, which is

   464     * actually OK in this case. */

   465 }

   466 #endif /* PNG_NO_STDIO */

   467 /* END of code to validate stdio-free compilation */

   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,

   524           png_voidp_NULL, (png_malloc_ptr)png_debug_malloc,

   525           (png_free_ptr)png_debug_free);

   526       if (size != 0 && pinfo->pointer == NULL)

   527       {

   528          current_allocation -= size;

   529          total_allocation -= size;

   530          png_error(png_ptr,

   531            "out of memory in pngtest->png_debug_malloc.");

   532       }

   533       pinfo->next = pinformation;

   534       pinformation = pinfo;

   535       /* Make sure the caller isn't assuming zeroed memory. */

   536       png_memset(pinfo->pointer, 0xdd, pinfo->size);

   537       if (verbose)

   538          printf("png_malloc %lu bytes at %x\n", (unsigned long)size,

   539             pinfo->pointer);

   540       return (png_voidp)(pinfo->pointer);

   541    }

   542 }

   543 

   544 /* Free a pointer.  It is removed from the list at the same time. */

   545 void

   546 png_debug_free(png_structp png_ptr, png_voidp ptr)

   547 {

   548    if (png_ptr == NULL)

   549       fprintf(STDERR, "NULL pointer to png_debug_free.\n");

   550    if (ptr == 0)

   551    {

   552 #if 0 /* This happens all the time. */

   553       fprintf(STDERR, "WARNING: freeing NULL pointer\n");

   554 #endif

   555       return;

   556    }

   557 

   558    /* Unlink the element from the list. */

   559    {

   560       memory_infop FAR *ppinfo = &pinformation;

   561       for (;;)

   562       {

   563          memory_infop pinfo = *ppinfo;

   564          if (pinfo->pointer == ptr)

   565          {

   566             *ppinfo = pinfo->next;

   567             current_allocation -= pinfo->size;

   568             if (current_allocation < 0)

   569                fprintf(STDERR, "Duplicate free of memory\n");

   570             /* We must free the list element too, but first kill

   571                the memory that is to be freed. */

   572             png_memset(ptr, 0x55, pinfo->size);

   573             png_free_default(png_ptr, pinfo);

   574             pinfo = NULL;

   575             break;

   576          }

   577          if (pinfo->next == NULL)

   578          {

   579             fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);

   580             break;

   581          }

   582          ppinfo = &pinfo->next;

   583       }

   584    }

   585 

   586    /* Finally free the data. */

   587    if (verbose)

   588       printf("Freeing %x\n", ptr);

   589    png_free_default(png_ptr, ptr);

   590    ptr = NULL;

   591 }

   592 #endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */

   593 /* END of code to test memory allocation/deallocation */

   594 

   595 

   596 /* Demonstration of user chunk support of the sTER and vpAg chunks */

   597 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

   598 

   599 /* (sTER is a public chunk not yet understood by libpng.  vpAg is a private

   600 chunk used in ImageMagick to store "virtual page" size).  */

   601 

   602 static png_uint_32 user_chunk_data[4];

   603 

   604     /* 0: sTER mode + 1

   605      * 1: vpAg width

   606      * 2: vpAg height

   607      * 3: vpAg units

   608      */

   609 

   610 static int read_user_chunk_callback(png_struct *png_ptr,

   611    png_unknown_chunkp chunk)

   612 {

   613   png_uint_32

   614     *user_chunk_data;

   615 

   616   /* Return one of the following: */

   617      /* return (-n);  chunk had an error */

   618      /* return (0);  did not recognize */

   619      /* return (n);  success */

   620 

   621   /* The unknown chunk structure contains the chunk data:

   622    * png_byte name[5];

   623    * png_byte *data;

   624    * png_size_t size;

   625    *

   626    *  Note that libpng has already taken care of the CRC handling.

   627    */

   628 

   629   if (chunk->name[0] == 115 && chunk->name[1] ==  84 &&     /* s  T */

   630       chunk->name[2] ==  69 && chunk->name[3] ==  82)       /* E  R */

   631      {

   632        /* Found sTER chunk */

   633        if (chunk->size != 1)

   634          return (-1); /* Error return */

   635        if (chunk->data[0] != 0 && chunk->data[0] != 1)

   636           return (-1);  /* Invalid mode */

   637        user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);

   638        user_chunk_data[0]=chunk->data[0]+1;

   639        return (1);

   640      }

   641   if (chunk->name[0] != 118 || chunk->name[1] != 112 ||    /* v  p */

   642       chunk->name[2] !=  65 || chunk->name[3] != 103)      /* A  g */

   643     return (0); /* Did not recognize */

   644 

   645   /* Found ImageMagick vpAg chunk */

   646 

   647   if (chunk->size != 9)

   648     return (-1); /* Error return */

   649 

   650   user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);

   651 

   652   user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);

   653   user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);

   654   user_chunk_data[3]=(png_uint_32)chunk->data[8];

   655 

   656   return (1);

   657 

   658 }

   659 #endif

   660 /* END of code to demonstrate user chunk support */

   661 

   662 /* Test one file */

   663 int

   664 test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)

   665 {

   666    static png_FILE_p fpin;

   667    static png_FILE_p fpout;  /* "static" prevents setjmp corruption */

   668    png_structp read_ptr;

   669    png_infop read_info_ptr, end_info_ptr;

   670 #ifdef PNG_WRITE_SUPPORTED

   671    png_structp write_ptr;

   672    png_infop write_info_ptr;

   673    png_infop write_end_info_ptr;

   674 #else

   675    png_structp write_ptr = NULL;

   676    png_infop write_info_ptr = NULL;

   677    png_infop write_end_info_ptr = NULL;

   678 #endif

   679    png_bytep row_buf;

   680    png_uint_32 y;

   681    png_uint_32 width, height;

   682    int num_pass, pass;

   683    int bit_depth, color_type;

   684 #ifdef PNG_SETJMP_SUPPORTED

   685 #ifdef USE_FAR_KEYWORD

   686    jmp_buf jmpbuf;

   687 #endif

   688 #endif

   689 

   690 #if defined(_WIN32_WCE)

   691    TCHAR path[MAX_PATH];

   692 #endif

   693    char inbuf[256], outbuf[256];

   694 

   695    row_buf = NULL;

   696 

   697 #if defined(_WIN32_WCE)

   698    MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);

   699    if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

   700 #else

   701    if ((fpin = fopen(inname, "rb")) == NULL)

   702 #endif

   703    {

   704       fprintf(STDERR, "Could not find input file %s\n", inname);

   705       return (1);

   706    }

   707 

   708 #if defined(_WIN32_WCE)

   709    MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);

   710    if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)

   711 #else

   712    if ((fpout = fopen(outname, "wb")) == NULL)

   713 #endif

   714    {

   715       fprintf(STDERR, "Could not open output file %s\n", outname);

   716       FCLOSE(fpin);

   717       return (1);

   718    }

   719 

   720    png_debug(0, "Allocating read and write structures\n");

   721 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

   722    read_ptr =

   723       png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

   724       png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,

   725       (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

   726 #else

   727    read_ptr =

   728       png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

   729       png_error_ptr_NULL, png_error_ptr_NULL);

   730 #endif

   731 #if defined(PNG_NO_STDIO)

   732    png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,

   733        pngtest_warning);

   734 #endif

   735 

   736 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

   737   user_chunk_data[0] = 0;

   738   user_chunk_data[1] = 0;

   739   user_chunk_data[2] = 0;

   740   user_chunk_data[3] = 0;

   741   png_set_read_user_chunk_fn(read_ptr, user_chunk_data,

   742     read_user_chunk_callback);

   743 

   744 #endif

   745 #ifdef PNG_WRITE_SUPPORTED

   746 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

   747    write_ptr =

   748       png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

   749       png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,

   750       (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

   751 #else

   752    write_ptr =

   753       png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

   754       png_error_ptr_NULL, png_error_ptr_NULL);

   755 #endif

   756 #if defined(PNG_NO_STDIO)

   757    png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,

   758        pngtest_warning);

   759 #endif

   760 #endif

   761    png_debug(0, "Allocating read_info, write_info and end_info structures\n");

   762    read_info_ptr = png_create_info_struct(read_ptr);

   763    end_info_ptr = png_create_info_struct(read_ptr);

   764 #ifdef PNG_WRITE_SUPPORTED

   765    write_info_ptr = png_create_info_struct(write_ptr);

   766    write_end_info_ptr = png_create_info_struct(write_ptr);

   767 #endif

   768 

   769 #ifdef PNG_SETJMP_SUPPORTED

   770    png_debug(0, "Setting jmpbuf for read struct\n");

   771 #ifdef USE_FAR_KEYWORD

   772    if (setjmp(jmpbuf))

   773 #else

   774    if (setjmp(png_jmpbuf(read_ptr)))

   775 #endif

   776    {

   777       fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);

   778       png_free(read_ptr, row_buf);

   779       row_buf = NULL;

   780       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

   781 #ifdef PNG_WRITE_SUPPORTED

   782       png_destroy_info_struct(write_ptr, &write_end_info_ptr);

   783       png_destroy_write_struct(&write_ptr, &write_info_ptr);

   784 #endif

   785       FCLOSE(fpin);

   786       FCLOSE(fpout);

   787       return (1);

   788    }

   789 #ifdef USE_FAR_KEYWORD

   790    png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf));

   791 #endif

   792 

   793 #ifdef PNG_WRITE_SUPPORTED

   794    png_debug(0, "Setting jmpbuf for write struct\n");

   795 #ifdef USE_FAR_KEYWORD

   796    if (setjmp(jmpbuf))

   797 #else

   798    if (setjmp(png_jmpbuf(write_ptr)))

   799 #endif

   800    {

   801       fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);

   802       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

   803       png_destroy_info_struct(write_ptr, &write_end_info_ptr);

   804 #ifdef PNG_WRITE_SUPPORTED

   805       png_destroy_write_struct(&write_ptr, &write_info_ptr);

   806 #endif

   807       FCLOSE(fpin);

   808       FCLOSE(fpout);

   809       return (1);

   810    }

   811 #ifdef USE_FAR_KEYWORD

   812    png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf));

   813 #endif

   814 #endif

   815 #endif

   816 

   817    png_debug(0, "Initializing input and output streams\n");

   818 #if !defined(PNG_NO_STDIO)

   819    png_init_io(read_ptr, fpin);

   820 #  ifdef PNG_WRITE_SUPPORTED

   821    png_init_io(write_ptr, fpout);

   822 #  endif

   823 #else

   824    png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);

   825 #  ifdef PNG_WRITE_SUPPORTED

   826    png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,

   827 #    if defined(PNG_WRITE_FLUSH_SUPPORTED)

   828       pngtest_flush);

   829 #    else

   830       NULL);

   831 #    endif

   832 #  endif

   833 #endif

   834    if (status_dots_requested == 1)

   835    {

   836 #ifdef PNG_WRITE_SUPPORTED

   837       png_set_write_status_fn(write_ptr, write_row_callback);

   838 #endif

   839       png_set_read_status_fn(read_ptr, read_row_callback);

   840    }

   841    else

   842    {

   843 #ifdef PNG_WRITE_SUPPORTED

   844       png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL);

   845 #endif

   846       png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL);

   847    }

   848 

   849 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

   850    {

   851      int i;

   852      for (i = 0; i<256; i++)

   853         filters_used[i] = 0;

   854      png_set_read_user_transform_fn(read_ptr, count_filters);

   855    }

   856 #endif

   857 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

   858    zero_samples = 0;

   859    png_set_write_user_transform_fn(write_ptr, count_zero_samples);

   860 #endif

   861 

   862 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

   863 #  ifndef PNG_HANDLE_CHUNK_ALWAYS

   864 #    define PNG_HANDLE_CHUNK_ALWAYS       3

   865 #  endif

   866    png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,

   867       png_bytep_NULL, 0);

   868 #endif

   869 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

   870 #  ifndef PNG_HANDLE_CHUNK_IF_SAFE

   871 #    define PNG_HANDLE_CHUNK_IF_SAFE      2

   872 #  endif

   873    png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,

   874       png_bytep_NULL, 0);

   875 #endif

   876 

   877    png_debug(0, "Reading info struct\n");

   878    png_read_info(read_ptr, read_info_ptr);

   879 

   880    png_debug(0, "Transferring info struct\n");

   881    {

   882       int interlace_type, compression_type, filter_type;

   883 

   884       if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,

   885           &color_type, &interlace_type, &compression_type, &filter_type))

   886       {

   887          png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,

   888 #if defined(PNG_WRITE_INTERLACING_SUPPORTED)

   889             color_type, interlace_type, compression_type, filter_type);

   890 #else

   891             color_type, PNG_INTERLACE_NONE, compression_type, filter_type);

   892 #endif

   893       }

   894    }

   895 #if defined(PNG_FIXED_POINT_SUPPORTED)

   896 #if defined(PNG_cHRM_SUPPORTED)

   897    {

   898       png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

   899          blue_y;

   900       if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

   901          &red_y, &green_x, &green_y, &blue_x, &blue_y))

   902       {

   903          png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,

   904             red_y, green_x, green_y, blue_x, blue_y);

   905       }

   906    }

   907 #endif

   908 #if defined(PNG_gAMA_SUPPORTED)

   909    {

   910       png_fixed_point gamma;

   911 

   912       if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))

   913       {

   914          png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);

   915       }

   916    }

   917 #endif

   918 #else /* Use floating point versions */

   919 #if defined(PNG_FLOATING_POINT_SUPPORTED)

   920 #if defined(PNG_cHRM_SUPPORTED)

   921    {

   922       double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

   923          blue_y;

   924       if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

   925          &red_y, &green_x, &green_y, &blue_x, &blue_y))

   926       {

   927          png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,

   928             red_y, green_x, green_y, blue_x, blue_y);

   929       }

   930    }

   931 #endif

   932 #if defined(PNG_gAMA_SUPPORTED)

   933    {

   934       double gamma;

   935 

   936       if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))

   937       {

   938          png_set_gAMA(write_ptr, write_info_ptr, gamma);

   939       }

   940    }

   941 #endif

   942 #endif /* floating point */

   943 #endif /* fixed point */

   944 #if defined(PNG_iCCP_SUPPORTED)

   945    {

   946       png_charp name;

   947       png_charp profile;

   948       png_uint_32 proflen;

   949       int compression_type;

   950 

   951       if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,

   952                       &profile, &proflen))

   953       {

   954          png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,

   955                       profile, proflen);

   956       }

   957    }

   958 #endif

   959 #if defined(PNG_sRGB_SUPPORTED)

   960    {

   961       int intent;

   962 

   963       if (png_get_sRGB(read_ptr, read_info_ptr, &intent))

   964       {

   965          png_set_sRGB(write_ptr, write_info_ptr, intent);

   966       }

   967    }

   968 #endif

   969    {

   970       png_colorp palette;

   971       int num_palette;

   972 

   973       if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))

   974       {

   975          png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);

   976       }

   977    }

   978 #if defined(PNG_bKGD_SUPPORTED)

   979    {

   980       png_color_16p background;

   981 

   982       if (png_get_bKGD(read_ptr, read_info_ptr, &background))

   983       {

   984          png_set_bKGD(write_ptr, write_info_ptr, background);

   985       }

   986    }

   987 #endif

   988 #if defined(PNG_hIST_SUPPORTED)

   989    {

   990       png_uint_16p hist;

   991 

   992       if (png_get_hIST(read_ptr, read_info_ptr, &hist))

   993       {

   994          png_set_hIST(write_ptr, write_info_ptr, hist);

   995       }

   996    }

   997 #endif

   998 #if defined(PNG_oFFs_SUPPORTED)

   999    {

  1000       png_int_32 offset_x, offset_y;

  1001       int unit_type;

  1002 

  1003       if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,

  1004          &unit_type))

  1005       {

  1006          png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);

  1007       }

  1008    }

  1009 #endif

  1010 #if defined(PNG_pCAL_SUPPORTED)

  1011    {

  1012       png_charp purpose, units;

  1013       png_charpp params;

  1014       png_int_32 X0, X1;

  1015       int type, nparams;

  1016 

  1017       if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,

  1018          &nparams, &units, &params))

  1019       {

  1020          png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,

  1021             nparams, units, params);

  1022       }

  1023    }

  1024 #endif

  1025 #if defined(PNG_pHYs_SUPPORTED)

  1026    {

  1027       png_uint_32 res_x, res_y;

  1028       int unit_type;

  1029 

  1030       if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))

  1031       {

  1032          png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);

  1033       }

  1034    }

  1035 #endif

  1036 #if defined(PNG_sBIT_SUPPORTED)

  1037    {

  1038       png_color_8p sig_bit;

  1039 

  1040       if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))

  1041       {

  1042          png_set_sBIT(write_ptr, write_info_ptr, sig_bit);

  1043       }

  1044    }

  1045 #endif

  1046 #if defined(PNG_sCAL_SUPPORTED)

  1047 #ifdef PNG_FLOATING_POINT_SUPPORTED

  1048    {

  1049       int unit;

  1050       double scal_width, scal_height;

  1051 

  1052       if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,

  1053          &scal_height))

  1054       {

  1055          png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);

  1056       }

  1057    }

  1058 #else

  1059 #ifdef PNG_FIXED_POINT_SUPPORTED

  1060    {

  1061       int unit;

  1062       png_charp scal_width, scal_height;

  1063 

  1064       if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,

  1065           &scal_height))

  1066       {

  1067          png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height);

  1068       }

  1069    }

  1070 #endif

  1071 #endif

  1072 #endif

  1073 #if defined(PNG_TEXT_SUPPORTED)

  1074    {

  1075       png_textp text_ptr;

  1076       int num_text;

  1077 

  1078       if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)

  1079       {

  1080          png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);

  1081          png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);

  1082       }

  1083    }

  1084 #endif

  1085 #if defined(PNG_tIME_SUPPORTED)

  1086    {

  1087       png_timep mod_time;

  1088 

  1089       if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))

  1090       {

  1091          png_set_tIME(write_ptr, write_info_ptr, mod_time);

  1092 #if defined(PNG_TIME_RFC1123_SUPPORTED)

  1093          /* we have to use png_memcpy instead of "=" because the string

  1094             pointed to by png_convert_to_rfc1123() gets free'ed before

  1095             we use it */

  1096          png_memcpy(tIME_string,

  1097                     png_convert_to_rfc1123(read_ptr, mod_time),

  1098                     png_sizeof(tIME_string));

  1099          tIME_string[png_sizeof(tIME_string) - 1] = '\0';

  1100          tIME_chunk_present++;

  1101 #endif /* PNG_TIME_RFC1123_SUPPORTED */

  1102       }

  1103    }

  1104 #endif

  1105 #if defined(PNG_tRNS_SUPPORTED)

  1106    {

  1107       png_bytep trans;

  1108       int num_trans;

  1109       png_color_16p trans_values;

  1110 

  1111       if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,

  1112          &trans_values))

  1113       {

  1114          int sample_max = (1 << read_info_ptr->bit_depth);

  1115          /* libpng doesn't reject a tRNS chunk with out-of-range samples */

  1116          if (!((read_info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&

  1117             (int)trans_values->gray > sample_max) ||

  1118             (read_info_ptr->color_type == PNG_COLOR_TYPE_RGB &&

  1119             ((int)trans_values->red > sample_max ||

  1120             (int)trans_values->green > sample_max ||

  1121             (int)trans_values->blue > sample_max))))

  1122            png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,

  1123               trans_values);

  1124       }

  1125    }

  1126 #endif

  1127 #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

  1128    {

  1129       png_unknown_chunkp unknowns;

  1130       int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,

  1131          &unknowns);

  1132       if (num_unknowns)

  1133       {

  1134          png_size_t i;

  1135          png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,