Imported from libpng-1.0.2.tar

ANNOUNCE

@@ -0,0 +1,67 @@
+
+Libpng 1.0.2 - June 14, 1998
+
+This is a public release of libpng, intended for use in production codes.
+
+Changes since the previous public release (1.0.1):
+
+  Optimized Paeth calculations by replacing abs() function calls with intrinsics
+  plus other loop optimizations. Improves avg decoding speed by about 20%.
+  Commented out i386istic "align" compiler flags in makefile.lnx.
+  Reduced the default warning level in some makefiles, to make them consistent.
+  Removed references to IJG and JPEG in the ansi2knr.c copyright statement.
+  Fixed a bug in png_do_strip_filler with XXRRGGBB => RRGGBB transformation.
+  Added grayscale and 16-bit capability to png_do_read_filler().
+  Fixed a bug in pngset.c, introduced in version 0.99c, that sets rowbytes
+    too large when writing an image with bit_depth < 8 (Bob Dellaca).
+  Corrected some bugs in the experimental weighted filtering heuristics.
+  Moved a misplaced pngrutil code block that truncates tRNS if it has more
+    than num_palette entries -- test was done before num_palette was defined.
+  Fixed a png_convert_to_rfc1123() bug that converts day 31 to 0 (Steve Eddins).
+  Changed compiler flags in makefile.wat for better optimization (Pawel Mrochen).
+  Relocated png_do_gray_to_rgb() within png_do_read_transformations() (Greg).
+  Relocated the png_composite macros from pngrtran.c to png.h (Greg).
+  Added makefile.sco (contributed by Mike Hopkirk).
+  Fixed a bug in pngrtran.c that would set channels=5 under some circumstances.
+  Added warnings when people try to use transforms they've defined out.
+  Collapsed 4 "i" and "c" loops into single "i" loops in pngrtran and pngwtran.
+  Revised paragraph about png_set_expand() in libpng.txt and libpng.3 (Greg)
+  Added max_pixel_depth=32 in pngrutil.c when using FILLER with palette images.
+  Moved PNG_WRITE_WEIGHTED_FILTER_SUPPORTED and PNG_WRITE_FLUSH_SUPPORTED
+    out of the PNG_WRITE_TRANSFORMS_NOT_SUPPORTED block of pngconf.h
+  Added "PNG_NO_WRITE_TRANSFORMS" etc., as alternatives for *_NOT_SUPPORTED,
+    for consistency, in pngconf.h
+  Added individual "ifndef PNG_NO_CAPABILITY" for the capabilities in pngconf.h
+    to make it easier to remove unwanted capabilities via the compile line
+  Made some corrections to grammar (which, it's) in documentation (Greg).
+  Corrected example.c, use of row_pointers in png_write_image().
+  Revised png_read_rows() to avoid repeated if-testing for NULL (A Kleinert)
+  More corrections to example.c, use of row_pointers in png_write_image()
+    and png_read_rows().
+  Added pngdll.mak and pngdef.pas to scripts directory, contributed by
+    Bob Dellaca, to make a png32bd.dll with Borland C++ 4.5
+  Fixed error in example.c with png_set_text: num_text is 3, not 2 (Guido V.)
+  Changed several loops from count-down to count-up, for consistency.
+  Revised libpng.txt and libpng.3 description of png_set_read|write_fn(), and
+    added warnings when people try to set png_read_fn and png_write_fn in
+    the same structure.
+  Added a test such that png_do_gamma will be done when num_trans==0
+    for truecolor images that have defined a background.  This corrects an
+    error that was introduced in libpng-0.90 that can cause gamma processing
+    to be skipped.
+  Added tests in png.h to include "trans" and "trans_values" in structures
+    when PNG_READ_BACKGROUND_SUPPORTED or PNG_READ_EXPAND_SUPPORTED is defined.
+  Add png_free(png_ptr->time_buffer) in png_destroy_read_struct()
+  Moved png_convert_to_rfc_1123() from pngwrite.c to png.c
+  Added capability for user-provided malloc_fn() and free_fn() functions,
+    and revised pngtest.c to demonstrate their use, replacing the
+    PNGTEST_DEBUG_MEM feature.
+  Added makefile.w32, for Microsoft C++ 4.0 and later (Tim Wegner).
+  Fixed two bugs in makefile.bor
+
+Send comments/corrections/commendations to
+png-implement@dworkin.wustl.edu or to randeg@alumni.rpi.edu
+
+Glenn Randers-Pehrson
+libpng maintainer
+PNG Development Group

CHANGES

@@ -1,273 +1,353 @@
 CHANGES - changes for libpng
 
 version 0.2
-   added reader into png.h
-   fixed small problems in stub file
+  added reader into png.h
+  fixed small problems in stub file
 version 0.3
-   added pull reader
-   split up pngwrite.c to several files
-   added pnglib.txt
-   added example.c
-   cleaned up writer, adding a few new tranformations
-   fixed some bugs in writer
-   interfaced with zlib 0.5
-   added K&R support
-   added check for 64 KB blocks for 16 bit machines
+  added pull reader
+  split up pngwrite.c to several files
+  added pnglib.txt
+  added example.c
+  cleaned up writer, adding a few new tranformations
+  fixed some bugs in writer
+  interfaced with zlib 0.5
+  added K&R support
+  added check for 64 KB blocks for 16 bit machines
 version 0.4
-   cleaned up code and commented code
-   simplified time handling into png_time
-   created png_color_16 and png_color_8 to handle color needs
-   cleaned up color type defines
-   fixed various bugs
-   made various names more consistant
-   interfaced with zlib 0.71
-   cleaned up zTXt reader and writer (using zlib's Reset functions)
-   split transformations into pngrtran.c and pngwtran.c
+  cleaned up code and commented code
+  simplified time handling into png_time
+  created png_color_16 and png_color_8 to handle color needs
+  cleaned up color type defines
+  fixed various bugs
+  made various names more consistant
+  interfaced with zlib 0.71
+  cleaned up zTXt reader and writer (using zlib's Reset functions)
+  split transformations into pngrtran.c and pngwtran.c
 version 0.5
-   interfaced with zlib 0.8
-   fixed many reading and writing bugs
-   saved using 3 spaces instead of tabs
+  interfaced with zlib 0.8
+  fixed many reading and writing bugs
+  saved using 3 spaces instead of tabs
 version 0.6
-   added png_large_malloc() and png_large_free()
-   added png_size_t
-   cleaned up some compiler warnings
-   added png_start_read_image()
+  added png_large_malloc() and png_large_free()
+  added png_size_t
+  cleaned up some compiler warnings
+  added png_start_read_image()
 version 0.7
-   cleaned up lots of bugs
-   finished dithering and other stuff
-   added test program
-   changed name from pnglib to libpng
+  cleaned up lots of bugs
+  finished dithering and other stuff
+  added test program
+  changed name from pnglib to libpng
 version 0.71 [June, 1995]
-   changed pngtest.png for zlib 0.93
-   fixed error in libpng.txt and example.c
+  changed pngtest.png for zlib 0.93
+  fixed error in libpng.txt and example.c
 version 0.8
-   cleaned up some bugs
-   added png_set_filler()
-   split up pngstub.c into pngmem.c, pngio.c, and pngerror.c
-   added #define's to remove unwanted code
-   moved png_info_init() to png.c
-   added old_size into png_realloc()
-   added functions to manually set filtering and compression info
-   changed compression parameters based on image type
-   optimized filter selection code
-   added version info
-   changed external functions passing floats to doubles (k&r problems?)
-   put all the configurable stuff in pngconf.h
-   enabled png_set_shift to work with paletted images on read
-   added png_read_update_info() - updates info structure with
-      transformations
+  cleaned up some bugs
+  added png_set_filler()
+  split up pngstub.c into pngmem.c, pngio.c, and pngerror.c
+  added #define's to remove unwanted code
+  moved png_info_init() to png.c
+  added old_size into png_realloc()
+  added functions to manually set filtering and compression info
+  changed compression parameters based on image type
+  optimized filter selection code
+  added version info
+  changed external functions passing floats to doubles (k&r problems?)
+  put all the configurable stuff in pngconf.h
+  enabled png_set_shift to work with paletted images on read
+  added png_read_update_info() - updates info structure with
+     transformations
 version 0.81 [August, 1995]
-   incorporated Tim Wegner's medium model code (thanks, Tim)
+  incorporated Tim Wegner's medium model code (thanks, Tim)
 version 0.82 [September, 1995]
-   [unspecified changes]
+  [unspecified changes]
 version 0.85 [December, 1995]
-   added more medium model code (almost everything's a far)
-   added i/o, error, and memory callback functions
-   fixed some bugs (16 bit, 4 bit interlaced, etc.)
-   added first run progressive reader (barely tested)
+  added more medium model code (almost everything's a far)
+  added i/o, error, and memory callback functions
+  fixed some bugs (16 bit, 4 bit interlaced, etc.)
+  added first run progressive reader (barely tested)
 version 0.86 [January, 1996]
-   fixed bugs
-   improved documentation
+  fixed bugs
+  improved documentation
 version 0.87 [January, 1996]
-   fixed medium model bugs
-   fixed other bugs introduced in 0.85 and 0.86
-   added some minor documentation
+  fixed medium model bugs
+  fixed other bugs introduced in 0.85 and 0.86
+  added some minor documentation
 version 0.88 [January, 1996]
-   fixed progressive bugs
-   replaced tabs with spaces
-   cleaned up documentation
-   added callbacks for read/write and warning/error functions
+  fixed progressive bugs
+  replaced tabs with spaces
+  cleaned up documentation
+  added callbacks for read/write and warning/error functions
 version 0.89 [July, 1996]
-   added new initialization API to make libpng work better with shared libs
-      we now have png_create_read_struct(), png_create_write_struct(),
-      png_create_info_struct(), png_destroy_read_struct(), and
-      png_destroy_write_struct() instead of the separate calls to
-      malloc and png_read_init(), png_info_init(), and png_write_init()
-   changed warning/error callback functions to fix bug - this means you
-      should use the new initialization API if you were using the old
-      png_set_message_fn() calls, and that the old API no longer exists
-      so that people are aware that they need to change their code
-   changed filter selection API to allow selection of multiple filters
-      since it didn't work in previous versions of libpng anyways
-   optimized filter selection code    
-   fixed png_set_background() to allow using an arbitrary RGB color for
-      paletted images
-   fixed gamma and background correction for paletted images, so
-      png_correct_palette is not needed unless you are correcting an
-      external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED
-      in pngconf.h) - if nobody uses this, it may disappear in the future.
-   fixed bug with Borland 64K memory allocation (Alexander Lehmann)
-   fixed bug in interlace handling (Smarasderagd, I think)
-   added more error checking for writing and image to reduce invalid files
-   separated read and write functions so that they won't both be linked
-      into a binary when only reading or writing functionality is used
-   new pngtest image also has interlacing and zTXt
-   updated documentation to reflect new API
+  added new initialization API to make libpng work better with shared libs
+     we now have png_create_read_struct(), png_create_write_struct(),
+     png_create_info_struct(), png_destroy_read_struct(), and
+     png_destroy_write_struct() instead of the separate calls to
+     malloc and png_read_init(), png_info_init(), and png_write_init()
+  changed warning/error callback functions to fix bug - this means you
+     should use the new initialization API if you were using the old
+     png_set_message_fn() calls, and that the old API no longer exists
+     so that people are aware that they need to change their code
+  changed filter selection API to allow selection of multiple filters
+     since it didn't work in previous versions of libpng anyways
+  optimized filter selection code    
+  fixed png_set_background() to allow using an arbitrary RGB color for
+     paletted images
+  fixed gamma and background correction for paletted images, so
+     png_correct_palette is not needed unless you are correcting an
+     external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED
+     in pngconf.h) - if nobody uses this, it may disappear in the future.
+  fixed bug with Borland 64K memory allocation (Alexander Lehmann)
+  fixed bug in interlace handling (Smarasderagd, I think)
+  added more error checking for writing and image to reduce invalid files
+  separated read and write functions so that they won't both be linked
+     into a binary when only reading or writing functionality is used
+  new pngtest image also has interlacing and zTXt
+  updated documentation to reflect new API
 version 0.90 [January, 1997]
-   made CRC errors/warnings on critical and ancillary chunks configurable
-   libpng will use the zlib CRC routines by (compile-time) default
-   changed DOS small/medium model memory support - needs zlib 1.04 (Tim Wegner)
-   added external C++ wrapper statements to png.h (Gilles Dauphin)
-   allow PNG file to be read when some or all of file signature has already
-      been read from the beginning of the stream.  ****This affects the size
-      of info_struct and invalidates all programs that use a shared libpng****
-   fixed png_filler() declarations
-   fixed? background color conversions
-   fixed order of error function pointers to match documentation
-   current chunk name is now available in png_struct to reduce the number
-      of nearly identical error messages (will simplify multi-lingual
-      support when available)
-   try to get ready for unknown-chunk callback functions:
-      - previously read critical chunks are flagged, so the chunk handling
-        routines can determine if the chunk is in the right place
-      - all chunk handling routines have the same prototypes, so we will
-        be able to handle all chunks via a callback mechanism
-   try to fix Linux "setjmp" buffer size problems
+  made CRC errors/warnings on critical and ancillary chunks configurable
+  libpng will use the zlib CRC routines by (compile-time) default
+  changed DOS small/medium model memory support - needs zlib 1.04 (Tim Wegner)
+  added external C++ wrapper statements to png.h (Gilles Dauphin)
+  allow PNG file to be read when some or all of file signature has already
+     been read from the beginning of the stream.  ****This affects the size
+     of info_struct and invalidates all programs that use a shared libpng****
+  fixed png_filler() declarations
+  fixed? background color conversions
+  fixed order of error function pointers to match documentation
+  current chunk name is now available in png_struct to reduce the number
+     of nearly identical error messages (will simplify multi-lingual
+     support when available)
+  try to get ready for unknown-chunk callback functions:
+     - previously read critical chunks are flagged, so the chunk handling
+       routines can determine if the chunk is in the right place
+     - all chunk handling routines have the same prototypes, so we will
+       be able to handle all chunks via a callback mechanism
+  try to fix Linux "setjmp" buffer size problems
 version 0.95 [March, 1997]
-   fixed bug in pngwutil.c allocating "up_row" twice and "avg_row" never
-   fixed bug in PNG file signature compares when start != 0
-   changed parameter type of png_set_filler(...filler...) from png_byte
-      to png_uint_32
-   added test for MACOS to ensure that both math.h and fp.h are not #included
-   added macros for libpng to be compiled as a Windows DLL (Andreas Kupries)
-   added "packswap" transformation, which changes the endianness of
-      packed-pixel bytes (Kevin Bracey)
-   added "strip_alpha" transformation, which removes the alpha channel of
-      input images without using it (not neccesarily a good idea)
-   added "swap_alpha" transformation, which puts the alpha channel in front
-      of the color bytes instead of after
-   removed all implicit variable tests which assume NULL == 0 (I think)
-   changed several variables to "png_size_t" to show 16/32-bit limitations
-   added new pCAL chunk read/write support
-   added experimental filter selection weighting (Greg Roelofs)
-   removed old png_set_rgbx() and png_set_xrgb() functions that have been
-      obsolete for about 2 years now (use png_set_filler() instead)
-   added macros to read 16- and 32-bit ints directly from buffer, to be
-      used only on those systems that support it (namely PowerPC and 680x0)
-      With some testing, this may become the default for MACOS/PPC systems.
-   only calculate CRC on data if we are going to use it
-   added macros for zTXt compression type PNG_zTXt_COMPRESSION_???
-   added macros for simple libpng debugging output selectable at compile time
-   removed PNG_READ_END_MODE in progressive reader (Smarasderagd)
-   more description of info_struct in libpng.txt and png.h
-   more instructions in example.c
-   more chunk types tested in pngtest.c
-   renamed pngrcb.c to pngset.c, and all png_read_<chunk> functions to be
-      png_set_<chunk>.  We now have corresponding png_get_<chunk>
-      functions in pngget.c to get infomation in info_ptr.  This isolates
-      the application from the internal organization of png_info_struct
-      (good for shared library implementations).
+  fixed bug in pngwutil.c allocating "up_row" twice and "avg_row" never
+  fixed bug in PNG file signature compares when start != 0
+  changed parameter type of png_set_filler(...filler...) from png_byte
+     to png_uint_32
+  added test for MACOS to ensure that both math.h and fp.h are not #included
+  added macros for libpng to be compiled as a Windows DLL (Andreas Kupries)
+  added "packswap" transformation, which changes the endianness of
+     packed-pixel bytes (Kevin Bracey)
+  added "strip_alpha" transformation, which removes the alpha channel of
+     input images without using it (not neccesarily a good idea)
+  added "swap_alpha" transformation, which puts the alpha channel in front
+     of the color bytes instead of after
+  removed all implicit variable tests which assume NULL == 0 (I think)
+  changed several variables to "png_size_t" to show 16/32-bit limitations
+  added new pCAL chunk read/write support
+  added experimental filter selection weighting (Greg Roelofs)
+  removed old png_set_rgbx() and png_set_xrgb() functions that have been
+     obsolete for about 2 years now (use png_set_filler() instead)
+  added macros to read 16- and 32-bit ints directly from buffer, to be
+     used only on those systems that support it (namely PowerPC and 680x0)
+     With some testing, this may become the default for MACOS/PPC systems.
+  only calculate CRC on data if we are going to use it
+  added macros for zTXt compression type PNG_zTXt_COMPRESSION_???
+  added macros for simple libpng debugging output selectable at compile time
+  removed PNG_READ_END_MODE in progressive reader (Smarasderagd)
+  more description of info_struct in libpng.txt and png.h
+  more instructions in example.c
+  more chunk types tested in pngtest.c
+  renamed pngrcb.c to pngset.c, and all png_read_<chunk> functions to be
+     png_set_<chunk>.  We now have corresponding png_get_<chunk>
+     functions in pngget.c to get infomation in info_ptr.  This isolates
+     the application from the internal organization of png_info_struct
+     (good for shared library implementations).
 version 0.96 [May, 1997]
-   fixed serious bug with < 8bpp images introduced in 0.95
-   fixed 256-color transparency bug (Greg Roelofs)
-   fixed up documentation (Greg Roelofs, Laszlo Nyul)
-   fixed "error" in pngconf.h for Linux setjmp() behaviour
-   fixed DOS medium model support (Tim Wegner)
-   fixed png_check_keyword() for case with error in static string text
-   added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)
-   added typecasts to quiet compiler errors
-   added more debugging info
+  fixed serious bug with < 8bpp images introduced in 0.95
+  fixed 256-color transparency bug (Greg Roelofs)
+  fixed up documentation (Greg Roelofs, Laszlo Nyul)
+  fixed "error" in pngconf.h for Linux setjmp() behaviour
+  fixed DOS medium model support (Tim Wegner)
+  fixed png_check_keyword() for case with error in static string text
+  added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)
+  added typecasts to quiet compiler errors
+  added more debugging info
 version 0.97 [January, 1998]
-   removed PNG_USE_OWN_CRC capability
-   relocated png_set_crc_action from pngrutil.c to pngrtran.c
-   fixed typecasts of "new_key", etc. (Andreas Dilger)
-   added RFC 1152 [sic] date support
-   fixed bug in gamma handling of 4-bit grayscale
-   added 2-bit grayscale gamma handling (Glenn R-P)
-   added more typecasts. 65536L becomes (png_uint_32)65536L, etc. (Glenn R-P)
-   minor corrections in libpng.txt
-   added simple sRGB support (Glenn R-P)
-   easier conditional compiling, e.g. define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;
-      all configurable options can be selected from command-line instead
-      of having to edit pngconf.h (Glenn R-P)
-   fixed memory leak in pngwrite.c (free info_ptr->text) (Glenn R-P)
-   added more conditions for png_do_background, to avoid changing
-      black pixels to background when a background is supplied and
-      no pixels are transparent
-   repaired PNG_NO_STDIO behaviour
-   tested NODIV support and made it default behaviour (Greg Roelofs)
-   added "-m" option and PNGTEST_DEBUG_MEMORY to pngtest (John Bowler)
-   regularized version numbering scheme and bumped shared-library major
-      version number to 2 to avoid problems with libpng 0.89 apps (Greg Roelofs)
+  removed PNG_USE_OWN_CRC capability
+  relocated png_set_crc_action from pngrutil.c to pngrtran.c
+  fixed typecasts of "new_key", etc. (Andreas Dilger)
+  added RFC 1152 [sic] date support
+  fixed bug in gamma handling of 4-bit grayscale
+  added 2-bit grayscale gamma handling (Glenn R-P)
+  added more typecasts. 65536L becomes (png_uint_32)65536L, etc. (Glenn R-P)
+  minor corrections in libpng.txt
+  added simple sRGB support (Glenn R-P)
+  easier conditional compiling, e.g. define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;
+     all configurable options can be selected from command-line instead
+     of having to edit pngconf.h (Glenn R-P)
+  fixed memory leak in pngwrite.c (free info_ptr->text) (Glenn R-P)
+  added more conditions for png_do_background, to avoid changing
+     black pixels to background when a background is supplied and
+     no pixels are transparent
+  repaired PNG_NO_STDIO behaviour
+  tested NODIV support and made it default behaviour (Greg Roelofs)
+  added "-m" option and PNGTEST_DEBUG_MEMORY to pngtest (John Bowler)
+  regularized version numbering scheme and bumped shared-library major
+     version number to 2 to avoid problems with libpng 0.89 apps (Greg Roelofs)
 version 0.98 [January, 1998]
-   cleaned up some typos in libpng.txt and in code documentation
-   fixed memory leaks in pCAL chunk processing (Glenn R-P and John Bowler)
-   cosmetic change "display_gamma" to "screen_gamma" in pngrtran.c
-   changed recommendation about file_gamma for PC images to .51 from .45,
-      in example.c and libpng.txt, added comments to distinguish between
-      screen_gamma, viewing_gamma, and display_gamma.
-   changed all references to RFC1152 to read RFC1123 and changed the
-      PNG_TIME_RFC1152_SUPPORTED macro to PNG_TIME_RFC1123_SUPPORTED
-   added png_invert_alpha capability (Glenn R-P -- suggestion by Jon Vincent)
-   changed srgb_intent from png_byte to int to avoid compiler bugs
+  cleaned up some typos in libpng.txt and in code documentation
+  fixed memory leaks in pCAL chunk processing (Glenn R-P and John Bowler)
+  cosmetic change "display_gamma" to "screen_gamma" in pngrtran.c
+  changed recommendation about file_gamma for PC images to .51 from .45,
+     in example.c and libpng.txt, added comments to distinguish between
+     screen_gamma, viewing_gamma, and display_gamma.
+  changed all references to RFC1152 to read RFC1123 and changed the
+     PNG_TIME_RFC1152_SUPPORTED macro to PNG_TIME_RFC1123_SUPPORTED
+  added png_invert_alpha capability (Glenn R-P -- suggestion by Jon Vincent)
+  changed srgb_intent from png_byte to int to avoid compiler bugs
 version 0.99 [January 30, 1998]
-   free info_ptr->text instead of end_info_ptr->text in pngread.c (John Bowler)
-   fixed a longstanding "packswap" bug in pngtrans.c
-   fixed some inconsistencies in pngconf.h that prevented compiling with
-      PNG_READ_GAMMA_SUPPORTED and PNG_READ_hIST_SUPPORTED undefined
-   fixed some typos and made other minor rearrangement of libpng.txt (Andreas)
-   changed recommendation about file_gamma for PC images to .50 from .51 in
-      example.c and libpng.txt, and changed file_gamma for sRGB images to .45
-   added a number of functions to access information from the png structure
-      png_get_image_height(), etc. (Glenn R-P, suggestion by Brad Pettit)
-   added TARGET_MACOS similar to zlib-1.0.8
-   define PNG_ALWAYS_EXTERN when __MWERKS__ && WIN32 are defined
-   added type casting to all png_malloc() function calls
+  free info_ptr->text instead of end_info_ptr->text in pngread.c (John Bowler)
+  fixed a longstanding "packswap" bug in pngtrans.c
+  fixed some inconsistencies in pngconf.h that prevented compiling with
+     PNG_READ_GAMMA_SUPPORTED and PNG_READ_hIST_SUPPORTED undefined
+  fixed some typos and made other minor rearrangement of libpng.txt (Andreas)
+  changed recommendation about file_gamma for PC images to .50 from .51 in
+     example.c and libpng.txt, and changed file_gamma for sRGB images to .45
+  added a number of functions to access information from the png structure
+     png_get_image_height(), etc. (Glenn R-P, suggestion by Brad Pettit)
+  added TARGET_MACOS similar to zlib-1.0.8
+  define PNG_ALWAYS_EXTERN when __MWERKS__ && WIN32 are defined
+  added type casting to all png_malloc() function calls
 version 0.99a [January 31, 1998]
-   Added type casts and parentheses to all returns that return a value.(Tim W.)
+  Added type casts and parentheses to all returns that return a value.(Tim W.)
 version 0.99b [February 4, 1998]
-   Added type cast png_uint_32 on malloc function calls where needed.
-   Changed type of num_hist from png_uint_32 to int (same as num_palette).
-   Added checks for rowbytes overflow, in case png_size_t is less than 32 bits.
-   Renamed makefile.elf to makefile.lnx.
+  Added type cast png_uint_32 on malloc function calls where needed.
+  Changed type of num_hist from png_uint_32 to int (same as num_palette).
+  Added checks for rowbytes overflow, in case png_size_t is less than 32 bits.
+  Renamed makefile.elf to makefile.lnx.
 version 0.99c [February 7, 1998]
-   More type casting.  Removed erroneous overflow test in pngmem.c.
-   Added png_buffered_memcpy() and png_buffered_memset(), apply them to rowbytes.
-   Added UNIX manual pages libpng.3 (incorporating libpng.txt) and  png.5.
+  More type casting.  Removed erroneous overflow test in pngmem.c.
+  Added png_buffered_memcpy() and png_buffered_memset(), apply them to rowbytes.
+  Added UNIX manual pages libpng.3 (incorporating libpng.txt) and  png.5.
 version 0.99d [February 11, 1998]
-   Renamed "far_to_near()" "png_far_to_near()"
-   Revised libpng.3
-   Version 99c "buffered" operations didn't work as intended.  Replaced them
-     with png_memcpy_check() and png_memset_check().
-   Added many "if (png_ptr == NULL) return" to quell compiler warnings about
-     unused png_ptr, mostly in pngget.c and pngset.c.
-   Check for overlength tRNS chunk present when indexed-color PLTE is read.
-   Cleaned up spelling errors in libpng.3/libpng.txt
-   Corrected a problem with png_get_tRNS() which returned undefined trans array
+  Renamed "far_to_near()" "png_far_to_near()"
+  Revised libpng.3
+  Version 99c "buffered" operations didn't work as intended.  Replaced them
+    with png_memcpy_check() and png_memset_check().
+  Added many "if (png_ptr == NULL) return" to quell compiler warnings about
+    unused png_ptr, mostly in pngget.c and pngset.c.
+  Check for overlength tRNS chunk present when indexed-color PLTE is read.
+  Cleaned up spelling errors in libpng.3/libpng.txt
+  Corrected a problem with png_get_tRNS() which returned undefined trans array
 version 0.99e [February 28, 1998]
-   Corrected png_get_tRNS() again.
-   Add parentheses for easier reading of pngget.c, fixed "||" should be "&&".
-   Touched up example.c to make more of it compileable, although the entire
-     file still can't be compiled (Willem van Schaik)
-   Fixed a bug in png_do_shift() (Bryan Tsai)
-   Added a space in png.h prototype for png_write_chunk_start()
-   Replaced pngtest.png with one created with zlib 1.1.1
-   Changed pngtest to report PASS even when file size is different (Jean-loup G.)
-   Corrected some logic errors in png_do_invert_alpha() (Chris Patterson)
+  Corrected png_get_tRNS() again.
+  Add parentheses for easier reading of pngget.c, fixed "||" should be "&&".
+  Touched up example.c to make more of it compileable, although the entire
+    file still can't be compiled (Willem van Schaik)
+  Fixed a bug in png_do_shift() (Bryan Tsai)
+  Added a space in png.h prototype for png_write_chunk_start()
+  Replaced pngtest.png with one created with zlib 1.1.1
+  Changed pngtest to report PASS even when file size is different (Jean-loup G.)
+  Corrected some logic errors in png_do_invert_alpha() (Chris Patterson)
 version 0.99f [March 5, 1998]
-   Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey)
-   Moved makefiles into a "scripts" directory, and added INSTALL instruction file
-   Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok)
-   Added pointers to "note on libpng versions" in makefile.lnx and README
-   Added row callback feature when reading and writing nonprogressive rows
-      and added a test of this feature in pngtest.c
-   Added user transform callbacks, with test of the feature in pngtest.c
+  Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey)
+  Moved makefiles into a "scripts" directory, and added INSTALL instruction file
+  Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok)
+  Added pointers to "note on libpng versions" in makefile.lnx and README
+  Added row callback feature when reading and writing nonprogressive rows
+     and added a test of this feature in pngtest.c
+  Added user transform callbacks, with test of the feature in pngtest.c
 version 0.99g [March 6, 1998, morning]
-   Minor changes to pngtest.c to suppress compiler warnings.
-   Removed "beta" language from documentation.
+  Minor changes to pngtest.c to suppress compiler warnings.
+  Removed "beta" language from documentation.
 version 0.99h [March 6, 1998, evening]
-   Minor changes to previous minor changes to pngtest.c 
-   Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED
-   and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro
+  Minor changes to previous minor changes to pngtest.c 
+  Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED
+  and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro
 version 1.00 [March 7, 1998]
-   Changed several typedefs in pngrutil.c
-   Added makefile.wat (Pawel Mrochen), updated makefile.tc3 (Willem van Schaik)
-   replaced "while(1)" with "for(;;)"
-   added PNGARG() to prototypes in pngtest.c and removed some prototypes
-   updated some of the makefiles (Tom Lane)
-   changed some typedefs (s_start, etc.) in pngrutil.c
-   fixed dimensions of "short_months" array in pngwrite.c
-   Replaced ansi2knr.c with the one from jpeg-v6
+  Changed several typedefs in pngrutil.c
+  Added makefile.wat (Pawel Mrochen), updated makefile.tc3 (Willem van Schaik)
+  replaced "while(1)" with "for(;;)"
+  added PNGARG() to prototypes in pngtest.c and removed some prototypes
+  updated some of the makefiles (Tom Lane)
+  changed some typedefs (s_start, etc.) in pngrutil.c
+  fixed dimensions of "short_months" array in pngwrite.c
+  Replaced ansi2knr.c with the one from jpeg-v6
 version 1.0.0 [March 8, 1998]
-   Changed name from 1.00 to 1.0.0 (Adam Costello)
-   Added smakefile.ppc (with SCOPTIONS.ppc) for Amiga PPC (Andreas Kleinert)
+  Changed name from 1.00 to 1.0.0 (Adam Costello)
+  Added smakefile.ppc (with SCOPTIONS.ppc) for Amiga PPC (Andreas Kleinert)
+version 1.0.0a [March 9, 1998]
+  Fixed three bugs in pngrtran.c to make gamma+background handling consistent
+  (Greg Roelofs)
+  Changed format of the PNG_LIBPNG_VER integer to xyyzz instead of xyz
+  for major, minor, and bugfix releases.  This is 10001. (Adam Costello,
+  Tom Lane)
+  Make months range from 1-12 in png_convert_to_rfc1123
+version 1.0.0b [March 13, 1998]
+  Quieted compiler complaints about two empty "for" loops in pngrutil.c
+  Minor changes to makefile.s2x
+  Removed #ifdef/#endif around a png_free() in pngread.c
+version 1.0.1 [March 14, 1998]
+  Changed makefile.s2x to reduce security risk of using a relative pathname
+  Fixed some typos in the documentation (Greg).
+  Fixed a problem with value of "channels" returned by png_read_update_info()
+version 1.0.1a [April 21, 1998]
+  Optimized Paeth calculations by replacing abs() function calls with intrinsics
+  plus other loop optimizations. Improves avg decoding speed by about 20%.
+  Commented out i386istic "align" compiler flags in makefile.lnx.
+  Reduced the default warning level in some makefiles, to make them consistent.
+  Removed references to IJG and JPEG in the ansi2knr.c copyright statement.
+  Fixed a bug in png_do_strip_filler with XXRRGGBB => RRGGBB transformation.
+  Added grayscale and 16-bit capability to png_do_read_filler().
+  Fixed a bug in pngset.c, introduced in version 0.99c, that sets rowbytes
+    too large when writing an image with bit_depth < 8 (Bob Dellaca).
+  Corrected some bugs in the experimental weighted filtering heuristics.
+  Moved a misplaced pngrutil code block that truncates tRNS if it has more
+    than num_palette entries -- test was done before num_palette was defined.
+  Fixed a png_convert_to_rfc1123() bug that converts day 31 to 0 (Steve Eddins).
+  Changed compiler flags in makefile.wat for better optimization (Pawel Mrochen).
+version 1.0.1b [May 2, 1998]
+  Relocated png_do_gray_to_rgb() within png_do_read_transformations() (Greg).
+  Relocated the png_composite macros from pngrtran.c to png.h (Greg).
+  Added makefile.sco (contributed by Mike Hopkirk).
+  Fixed two bugs (missing definitions of "istop") introduced in libpng-1.0.1a.
+  Fixed a bug in pngrtran.c that would set channels=5 under some circumstances.
+  More work on the Paeth-filtering, achieving imperceptible speedup (A Kleinert).
+  More work on loop optimization which may help when compiled with C++ compilers.
+  Added warnings when people try to use transforms they've defined out.
+  Collapsed 4 "i" and "c" loops into single "i" loops in pngrtran and pngwtran.
+  Revised paragraph about png_set_expand() in libpng.txt and libpng.3 (Greg)
+version 1.0.1c [May 11, 1998]
+  Fixed a bug in pngrtran.c (introduced in libpng-1.0.1a) where the masks for
+    filler bytes should have been 0xff instead of 0xf.
+  Added max_pixel_depth=32 in pngrutil.c when using FILLER with palette images.
+  Moved PNG_WRITE_WEIGHTED_FILTER_SUPPORTED and PNG_WRITE_FLUSH_SUPPORTED
+    out of the PNG_WRITE_TRANSFORMS_NOT_SUPPORTED block of pngconf.h
+  Added "PNG_NO_WRITE_TRANSFORMS" etc., as alternatives for *_NOT_SUPPORTED,
+    for consistency, in pngconf.h
+  Added individual "ifndef PNG_NO_[CAPABILITY]" in pngconf.h to make it easier
+    to remove unwanted capabilities via the compile line
+  Made some corrections to grammar (which, it's) in documentation (Greg).
+  Corrected example.c, use of row_pointers in png_write_image().
+version 1.0.1d [May 24, 1998]
+  Corrected several statements that used side effects illegally in pngrutil.c
+    and pngtrans.c, that were introduced in version 1.0.1b
+  Revised png_read_rows() to avoid repeated if-testing for NULL (A Kleinert)
+  More corrections to example.c, use of row_pointers in png_write_image()
+    and png_read_rows().
+  Added pngdll.mak and pngdef.pas to scripts directory, contributed by
+    Bob Dellaca, to make a png32bd.dll with Borland C++ 4.5
+  Fixed error in example.c with png_set_text: num_text is 3, not 2 (Guido V.)
+  Changed several loops from count-down to count-up, for consistency.
+version 1.0.2 [June 14, 1998]
+  Revised libpng.txt and libpng.3 description of png_set_read|write_fn(), and
+    added warnings when people try to set png_read_fn and png_write_fn in
+    the same structure.
+  Added a test such that png_do_gamma will be done when num_trans==0
+    for truecolor images that have defined a background.  This corrects an
+    error that was introduced in libpng-0.90 that can cause gamma processing
+    to be skipped.
+  Added tests in png.h to include "trans" and "trans_values" in structures
+    when PNG_READ_BACKGROUND_SUPPORTED or PNG_READ_EXPAND_SUPPORTED is defined.
+  Add png_free(png_ptr->time_buffer) in png_destroy_read_struct()
+  Moved png_convert_to_rfc_1123() from pngwrite.c to png.c
+  Added capability for user-provided malloc_fn() and free_fn() functions,
+    and revised pngtest.c to demonstrate their use, replacing the
+    PNGTEST_DEBUG_MEM feature.
+  Added makefile.w32, for Microsoft C++ 4.0 and later (Tim Wegner).
+  Fixed two bugs in makefile.bor

INSTALL

@@ -1,5 +1,5 @@
 
-Installing libpng version 1.0.0 March 8, 1998
+Installing libpng version 1.0.2 - June 14, 1998
 
 Before installing libpng, you must first install zlib.  zlib
 can usually be found wherever you got libpng.  zlib can be
@@ -10,8 +10,8 @@ zlib.h and zconf.h include files that correspond to the
 version of zlib that's installed.
 
 You can rename the directories that you downloaded (they
-might be called "libpng-1.0.0 or "lpng100" and "zlib-1.1.1"
-or "zlib111") so that you have directories called "zlib" and "libpng".
+might be called "libpng-1.0.2" or "lpng102" and "zlib-1.1.2"
+or "zlib112") so that you have directories called "zlib" and "libpng".
 
 Your directory structure should look like this:
 
@@ -56,11 +56,14 @@ include
       build.bat     =>  MS-DOS batch file for Borland compiler
       makefile.dj2  =>  DJGPP 2 makefile
       makefile.msc  =>  Microsoft C makefile
+      makefile.w32  =>  makefile for Microsoft Visual C++ 4.0 and later
       makefile.tc3  =>  Turbo C 3.0 makefile
       makefile.os2  =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
       pngos2.def    =>  OS/2 module definition file used by makefile.os2
       makefile.wat  =>  Watcom 10a+ Makefile, 32-bit flat memory model
       makevms.com   =>  VMS build script
+      pngdll.mak    =>  To make a png32bd.dll with Borland C++ 4.5
+      pngdef.pas    =>  Defines for a png32bd.dll with Borland C++ 4.5
 
 Copy the file (or files) that you need from the
 scripts directory into this directory, for example

KNOWNBUG

@@ -0,0 +1,19 @@
+
+Known bugs and suggested enhancements in libpng-1.0.2
+
+
+1. March 15, 1998 -- OPTIMIZATION -- Kevin Bracey
+
+   Loops need to be optimized everywhere
+
+   Make them count down instead of up -- Kevin Bracey
+   
+   Optimizing compilers don't need this, and making
+   the change would be error prone -- Tom Lane, Glenn R-P
+
+   Question whether i-- or --i is better.
+
+   STATUS: Under investigation, postponed until after
+   libpng-1.0.2.  About 160 loops turned around
+   in libpng-1.0.2a, for testing.
+

README

@@ -1,4 +1,4 @@
-README for libpng 1.0.0 (shared library 2.1)
+README for libpng 1.0.2 - June 14, 1998 (shared library 2.1)
 See the note about version numbers near the top of png.h
 
 See INSTALL for instructions on how to install libpng.
@@ -173,11 +173,14 @@ Files in this distribution:
         build.bat     =>  MS-DOS batch file for Borland compiler
         makefile.dj2  =>  DJGPP 2 makefile
         makefile.msc  =>  Microsoft C makefile
+        makefile.w32  =>  makefile for Microsoft Visual C++ 4.0 and later
         makefile.tc3  =>  Turbo C 3.0 makefile
         makefile.os2  =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
         makefile.wat  =>  Watcom 10a+ Makefile, 32-bit flat memory model
         pngos2.def    =>  OS/2 module definition file used by makefile.os2
         makevms.com   =>  VMS build script
+        pngdll.mak    =>  To make a png32bd.dll with Borland C++ 4.5
+        pngdef.pas    =>  Defines for a png32bd.dll with Borland C++ 4.5
 
 Good luck, and happy coding.
 

TODO

@@ -2,6 +2,7 @@ TODO - list of things to do for libpng
 
 fix problem with C++ and EXTERN "C"
 add "grayscale->palette" transformation and "palette->grayscale" detection
+color to gray transformation
 improved dithering
 multi-lingual error and warning message support
 sPLT chunk handling
@@ -19,3 +20,4 @@ support for application-defined chunk handlers
 keep up with public chunks
 better C++ wrapper/full C++ implementation?
 text conversion between different code pages (Latin-1 -> Mac and DOS)
+improve API by hiding the info_ptr

ansi2knr.c

@@ -1,7 +1,9 @@
 /* ansi2knr.c */
-/* Convert ANSI C function definitions to K&R ("traditional C") syntax */
 
-/*
+/* Convert ANSI C function definitions to K&R ("traditional C") syntax
+Copyright (C) 1989 Aladdin Enterprises.  All rights reserved.
+Copyright (C) 1988 Richard M. Stallman
+
 ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY.  No author or distributor accepts responsibility to anyone for the
 consequences of using it or for whether it serves any particular purpose or
@@ -12,12 +14,12 @@ Everyone is granted permission to copy, modify and redistribute ansi2knr,
 but only under the conditions described in the GPL.  A copy of this license
 is supposed to have been given to you along with ansi2knr so you can know
 your rights and responsibilities.  It should be in a file named COPYLEFT.
-[In the IJG distribution, the GPL appears below, not in a separate file.]
+[In the LIBPNG distribution, the GPL appears below, not in a separate file.]
 Among other things, the copyright notice and this notice must be preserved
 on all copies.
 
 We explicitly state here what we believe is already implied by the GPL: if
-the ansi2knr program is distributed as a separate set of sources and a
+the ansi2knr program is distributed as a separate source file and a
 separate executable file which are aggregated on a storage medium together
 with another program, this in itself does not bring the other program under
 the GPL, nor does the mere fact that such a program or the procedures for
@@ -27,7 +29,7 @@ program under the GPL.
 
 /*
 ---------- Here is the GNU GPL file COPYLEFT, referred to above ----------
------ These terms do NOT apply to the JPEG software itself; see README ------
+----- These terms do NOT apply to the LIBPNG software itself; see README ------
 
 		    GHOSTSCRIPT GENERAL PUBLIC LICENSE
 		    (Clarified 11 Feb 1988)

example.c

@@ -83,7 +83,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
     * was compiled with a compatible version of the library.  REQUIRED
     */
    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
-      (void *)user_error_ptr, user_error_fn, user_warning_fn);
+      png_voidp user_error_ptr, user_error_fn, user_warning_fn);
 
    if (png_ptr == NULL)
    {
@@ -316,18 +316,18 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
 #ifdef single /* Read the image a single row at a time */
       for (y = 0; y < height; y++)
       {
-         png_bytep row_pointers = row[y];
-         png_read_rows(png_ptr, &row_pointers, NULL, 1);
+         png_read_rows(png_ptr, &row_pointers[y], NULL, 1);
       }
 
 #else no_single /* Read the image several rows at a time */
       for (y = 0; y < height; y += number_of_rows)
       {
 #ifdef sparkle /* Read the image using the "sparkle" effect. */
-         png_read_rows(png_ptr, row_pointers, NULL, number_of_rows);
+         png_read_rows(png_ptr, &row_pointers[y], NULL, number_of_rows);
         
+         png_read_rows(png_ptr, NULL, row_pointers[y], number_of_rows);
 #else no_sparkle /* Read the image using the "rectangle" effect */
-         png_read_rows(png_ptr, NULL, row_pointers, number_of_rows);
+         png_read_rows(png_ptr, NULL, &row_pointers[y], number_of_rows);
 #endif no_sparkle /* use only one of these two methods */
       }
      
@@ -362,7 +362,7 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
     * linked libraries.
     */
    *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
-       (void *)user_error_ptr, user_error_fn, user_warning_fn);
+       png_voidp user_error_ptr, user_error_fn, user_warning_fn);
 
    if (*png_ptr == NULL)
    {
@@ -498,7 +498,7 @@ void write_png(char *file_name /* , ... other image information ... */)
     * in case we are using dynamically linked libraries.  REQUIRED.
     */
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
-      (void *)user_error_ptr, user_error_fn, user_warning_fn);
+      png_voidp user_error_ptr, user_error_fn, user_warning_fn);
 
    if (png_ptr == NULL)
    {
@@ -581,7 +581,7 @@ void write_png(char *file_name /* , ... other image information ... */)
    text_ptr[2].key = "Description";
    text_ptr[2].text = "<long text>";
    text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
-   png_set_text(png_ptr, info_ptr, text_ptr, 2);
+   png_set_text(png_ptr, info_ptr, text_ptr, 3);
 
    /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
    /* note that if sRGB is present the cHRM chunk must be ignored
@@ -638,7 +638,11 @@ void write_png(char *file_name /* , ... other image information ... */)
     * layout, however, so choose what fits your needs best).  You need to
     * use the first method if you aren't handling interlacing yourself.
     */
-   png_byte row_pointers[height][width];
+   png_uint_32 k, height, width;
+   png_byte image[height][width];
+   png_bytep row_pointers[height];
+   for (k = 0; k < height; k++)
+     row_pointers[k] = image + k*width;
 
    /* One of the following output methods is REQUIRED */
 #ifdef entire /* write out the entire image data in one call */
@@ -653,13 +657,12 @@ void write_png(char *file_name /* , ... other image information ... */)
    for (pass = 0; pass < number_passes; pass++)
    {
       /* Write a few rows at a time. */
-      png_write_rows(png_ptr, row_pointers, number_of_rows);
+      png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);
 
       /* If you are only writing one row at a time, this works */
       for (y = 0; y < height; y++)
       {
-         png_bytep row_pointers = row[y];
-         png_write_rows(png_ptr, &row_pointers, 1);
+         png_write_rows(png_ptr, &row_pointers[y], 1);
       }
    }
 #endif no_entire /* use only one output method */

libpng.3

@@ -1,6 +1,6 @@
-.TH LIBPNG 3 "March 8, 1998"
+.TH LIBPNG 3 "June 14, 1998"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library
+libpng \- Portable Network Graphics (PNG) Reference Library 1.0.2 - June 14, 1998
 .SH SYNOPSIS
 
 #include <png.h>
@@ -27,11 +27,19 @@ png_structp png_create_read_struct (png_const_charp
 user_png_ver, voidp error_ptr, png_error_ptr error_fn,
 png_error_ptr warn_fn);
 
+png_create_read_struct_2(png_const_charp user_png_ver,
+png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr
+warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn,
+png_free_ptr free_fn)
+
 png_structp png_create_write_struct (png_const_charp
 user_png_ver, voidp error_ptr, png_error_ptr error_fn,
 png_error_ptr warn_fn);
 
-void png_debug_free (png_structp png_ptr, png_voidp ptr);
+png_structp png_create_write_struct_2(png_const_charp
+user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
+png_error_ptr warn_fn, png_voidp mem_ptr,
+png_malloc_ptr malloc_fn, png_free_ptr free_fn)
 
 png_voidp png_debug_malloc (png_structp png_ptr, png_uint_32
 size);
@@ -49,6 +57,8 @@ void png_error (png_structp png_ptr, png_const_charp error);
 
 void png_free (png_structp png_ptr, png_voidp ptr);
 
+void png_free_default(png_structp png_ptr, png_voidp ptr)
+
 png_byte png_get_bit_depth (png_structp png_ptr, png_infop
 info_ptr);
 
@@ -80,6 +90,11 @@ info_ptr, double *file_gamma);
 png_uint_32 png_get_hIST (png_structp png_ptr, png_infop
 info_ptr, png_uint_16p *hist);
 
+png_uint_32 png_get_IHDR (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 *width, png_uint_32 *height, int
+*bit_depth, int *color_type, int *interlace_type, int
+*compression_type, int *filter_type);
+
 png_uint_32 png_get_image_height (png_structp png_ptr,
 png_infop info_ptr);
 
@@ -91,10 +106,7 @@ info_ptr);
 
 png_voidp png_get_io_ptr (png_structp png_ptr);
 
-png_uint_32 png_get_IHDR (png_structp png_ptr, png_infop
-info_ptr, png_uint_32 *width, png_uint_32 *height, int
-*bit_depth, int *color_type, int *interlace_type, int
-*compression_type, int *filter_type);
+png_voidp png_get_mem_ptr(png_structp png_ptr)
 
 png_uint_32 png_get_oFFs (png_structp png_ptr, png_infop
 info_ptr, png_uint_32 *offset_x, png_uint_32 *offset_y, int
@@ -168,6 +180,9 @@ void png_init_io (png_structp png_ptr, FILE *fp);
 
 png_voidp png_malloc (png_structp png_ptr, png_uint_32 size);
 
+png_voidp png_malloc_default(png_structp png_ptr,
+png_uint_32 size)
+
 voidp png_memcpy (png_voidp s1, png_voidp s2, png_size_t size);
 
 png_voidp png_memcpy_check (png_structp png_ptr, png_voidp s1,
@@ -276,6 +291,9 @@ png_uint_32 width, png_uint_32 height, int bit_depth, int
 color_type, int interlace_type, int compression_type, int
 filter_type);
 
+void png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr,
+png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+
 void png_set_oFFs (png_structp png_ptr, png_infop info_ptr,
 png_uint_32 offset_x, png_uint_32 offset_y, int unit_type);
 
@@ -302,10 +320,10 @@ void png_set_read_fn (png_structp png_ptr, png_voidp io_ptr,
 png_rw_ptr read_data_fn);
 
 void png_set_read_status_fn (png_structp png_ptr, png_read_status_ptr
-   read_row_fn);
+read_row_fn);
 
 void png_set_read_user_transform_fn (png_structp png_ptr,
-   png_user_transform_ptr read_user_transform_fn);
+png_user_transform_ptr read_user_transform_fn);
 
 void png_set_rgb_to_gray (png_structp png_ptr);
 
@@ -344,10 +362,10 @@ void png_set_write_fn (png_structp png_ptr, png_voidp io_ptr,
 png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn);
 
 void png_set_write_status_fn (png_structp png_ptr, png_write_status_ptr
-   write_row_fn);
+write_row_fn);
 
 void png_set_write_user_transform_fn (png_structp png_ptr,
-   png_user_transform_ptr write_user_transform_fn);
+png_user_transform_ptr write_user_transform_fn);
 
 int png_sig_cmp (png_bytep sig, png_size_t start, png_size_t
 num_to_check);
@@ -375,7 +393,7 @@ void png_write_destroy_info (png_infop info_ptr);
 void png_write_end (png_structp png_ptr, png_infop info_ptr);
 
 void png_write_flush (png_structp png_ptr);
- 
+
 void png_write_image (png_structp png_ptr, png_bytepp image);
 
 void png_write_info (png_structp png_ptr, png_infop info_ptr);
@@ -396,7 +414,7 @@ Following is a copy of the libpng.txt file that accompanies libpng.
 .SH LIBPNG.TXT
 libpng.txt - A description on how to use and modify libpng
 
- libpng version 1.0.0 March 8, 1998
+ libpng version 1.0.2 - June 14, 1998
  Updated and distributed by Glenn Randers-Pehrson
  <randeg@alumni.rpi.edu>
  Copyright (c) 1998, Glenn Randers-Pehrson
@@ -539,7 +557,7 @@ be NULL if the default error handlers are to be used).  See the section
 on Changes to Libpng below regarding the old initialization functions.
 
     png_structp png_ptr = png_create_read_struct
-       (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
         user_error_fn, user_warning_fn);
     if (!png_ptr)
         return;
@@ -560,10 +578,21 @@ on Changes to Libpng below regarding the old initialization functions.
         return;
     }
 
+If you want to use your own memory allocation routines,
+define PNG_USER_MEM_SUPPORTED and use
+png_create_read_struct_2() instead of png_create_read_struct():
 
-The error handling routines passed to png_create_read_struct() are only
-necessary if you are not using the libpng supplied error handling
-functions.  When libpng encounters an error, it expects to longjmp back
+    png_structp png_ptr = png_create_read_struct_2
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
+        user_error_fn, user_warning_fn, (png_voidp)
+        user_mem_ptr, user_malloc_fn, user_free_fn);
+
+The error handling routines passed to png_create_read_struct()
+and the memory alloc/free routines passed to png_create_struct_2()
+are only necessary if you are not using the libpng supplied error
+handling and memory alloc/free functions.
+
+When libpng encounters an error, it expects to longjmp back
 to your routine.  Therefore, you will need to call setjmp and pass the
 jmpbuf field of your png_struct.  If you read the file from different
 routines, you will need to update the jmpbuf field every time you enter
@@ -872,11 +901,14 @@ unless the library has been told to transform it into another format.
 For example, 4 bit/pixel paletted or grayscale data will be returned
 2 pixels/byte with the leftmost pixel in the high-order bits of the
 byte, unless png_set_packing() is called.  8-bit RGB data will be stored
-in RGBRGBRGB format unless png_set_filler() is called to insert filler
+in RGB RGB RGB format unless png_set_filler() is called to insert filler
 bytes, either before or after each RGB triplet.  16-bit RGB data will
-be returned RRGGBBRRGGBB, with the most significant byte of the color
+be returned RRGGBB RRGGBB, with the most significant byte of the color
 value first, unless png_set_strip_16() is called to transform it to
-regular RGBRGB triplets.
+regular RGB RGB triplets, or png_set_filler() is called to insert
+filler bytes, either before or after each RRGGBB triplet.  Similarly,
+8-bit or 16-bit grayscale data can be modified with png_set_filler()
+or png_set_strip_16().
 
 The following code transforms grayscale images of less than 8 to 8 bits,
 changes paletted images to RGB, and adds a full alpha channel if there is
@@ -952,7 +984,7 @@ into 4 bytes for windowing systems that need them in this format:
         PNG_COLOR_TYPE_RGB) png_set_filler(png_ptr,
         filler, PNG_FILLER_BEFORE);
 
-where "filler" is the number to fill with, and the location is
+where "filler" is the 8 or 16-bit number to fill with, and the location is
 either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether
 you want the filler before the RGB or after.  This transformation
 does not affect images that already have full alpha channels.
@@ -971,21 +1003,19 @@ RGB.  This code will do that conversion:
           png_set_gray_to_rgb(png_ptr);
 
 If you have a grayscale and you are using png_set_expand() to change to
-a higher bit-depth you must indicate if the supplied background gray
-is supplied in the original file bit depth (need_expand = 1) or in the
-expanded bit depth (need_expand = 0).  Similarly, if you are reading
-a paletted image, you must indicate if you have supplied the background
-as a palette index that needs to be expanded (need_expand = 1).  You can
-also specify an RGB triplet that isn't in the palette when setting your
-background for a paletted image.
+a higher bit-depth, you must either supply the background color as a gray
+value at the original file bit-depth (need_expand = 1) or else supply the
+background color as an RGB triplet at the final, expanded bit depth
+(need_expand = 0).  Similarly, if you are reading a paletted image, you
+must either supply the background color as a palette index (need_expand = 1)
+or as an RGB triplet that may or may not be in the palette (need_expand = 0).
 
     png_color_16 my_background;
     png_color_16p image_background;
 
-    if (png_get_bKGD(png_ptr, info_ptr,
-        &image_background))
-        png_set_background(png_ptr, image_background),
-        PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+    if (png_get_bKGD(png_ptr, info_ptr, &image_background))
+        png_set_background(png_ptr, image_background,
+          PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
     else
         png_set_background(png_ptr, &my_background,
           PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
@@ -1268,7 +1298,7 @@ png_infop info_ptr;
  initialize_png_reader()
  {
     png_ptr = png_create_read_struct
-        (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
+        (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
          user_error_fn, user_warning_fn);
     if (!png_ptr)
         return -1;
@@ -1387,8 +1417,8 @@ png_infop info_ptr;
           new_row);
 
     /* where old_row is what was displayed for
-       previous rows.  Note that the first pass
-       (pass == 0, really) will completely cover
+       previously for the row.  Note that the first
+       pass (pass == 0, really) will completely cover
        the old row, so the rows do not have to be
        initialized.  After the first pass (and only
        for interlaced images), you will have to pass
@@ -1412,6 +1442,8 @@ png_infop info_ptr;
      */
  }
 
+
+
 .SH IV. Writing
 
 Much of this is very similar to reading.  However, everything of
@@ -1438,7 +1470,7 @@ both "png_ptr"; you can call them anything you like, such as
 "read_ptr" and "write_ptr".  Look at pngtest.c, for example.
 
     png_structp png_ptr = png_create_write_struct
-       (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
         user_error_fn, user_warning_fn);
     if (!png_ptr)
        return;
@@ -1451,6 +1483,15 @@ both "png_ptr"; you can call them anything you like, such as
        return;
     }
 
+If you want to use your own memory allocation routines,
+define PNG_USER_MEM_SUPPORTED and use
+png_create_write_struct_2() instead of png_create_read_struct():
+
+    png_structp png_ptr = png_create_write_struct_2
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
+        user_error_fn, user_warning_fn, (png_voidp)
+        user_mem_ptr, user_malloc_fn, user_free_fn);
+
 After you have these structures, you will need to set up the
 error handling.  When libpng encounters an error, it expects to
 longjmp() back to your routine.  Therefore, you will need to call
@@ -1504,9 +1545,9 @@ not calling this function at all, as it has been tuned to deliver a good
 speed/compression ratio. The second parameter to png_set_filter() is
 the filter method, for which the only valid value is '0' (as of the
 October 1996 PNG specification, version 1.0).  The third parameter is a
-flag that indicates
-which filter type(s) are to be tested for each scanline.  See the
-Compression Library for details on the specific filter types.
+flag that indicates which filter type(s) are to be tested for each
+scanline.  See the Compression Library for details on the specific filter
+types.
 
     
     /* turn on or off filtering, and/or choose
@@ -1780,8 +1821,9 @@ checks to see if it has data that it can do something with, you should
 make sure to only enable a transformation if it will be valid for the
 data.  For example, don't swap red and blue on grayscale data.
 
-PNG files store RGB pixels packed into 3 bytes.  This code tells
-the library to expect input data with 4 bytes per pixel
+PNG files store RGB pixels packed into 3 or 6 bytes.  This code tells
+the library to expand the input data to 4 or 8 bytes per pixel
+(or expand 1 or 2-byte grayscale data to 2 or 4 bytes per pixel).
 
     png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
 
@@ -1899,11 +1941,11 @@ times, or any of that other stuff necessary with png_write_rows().
 
 where row_pointers is:
 
-    png_bytef *row_pointers[height];
+    png_byte *row_pointers[height];
 
 You can point to void or char or whatever you use for pixels.
 
-If you can't want to write the whole image at once, you can
+If you don't want to write the whole image at once, you can
 use png_write_rows() instead.  If the file is not interlaced,
 this is simple:
 
@@ -1997,14 +2039,15 @@ time, instead of calling the png_init_io() function.  These functions
 also provide a void pointer that can be retrieved via the function
 png_get_io_ptr().  For example:
 
-    png_set_read_fn(png_structp png_ptr,
-        voidp io_ptr, png_rw_ptr read_data_fn)
+    png_set_read_fn(png_structp read_ptr,
+        voidp read_io_ptr, png_rw_ptr read_data_fn)
 
-    png_set_write_fn(png_structp png_ptr,
-        voidp io_ptr, png_rw_ptr write_data_fn,
+    png_set_write_fn(png_structp write_ptr,
+        voidp write_io_ptr, png_rw_ptr write_data_fn,
         png_flush_ptr output_flush_fn);
 
-    voidp io_ptr = png_get_io_ptr(png_ptr);
+    voidp read_io_ptr = png_get_io_ptr(read_ptr);
+    voidp write_io_ptr = png_get_io_ptr(write_ptr);
 
 The replacement I/O functions should have prototypes as follows:
 
@@ -2016,7 +2059,7 @@ The replacement I/O functions should have prototypes as follows:
 
 Supplying NULL for the read, write, or flush functions sets them back
 to using the default C stream functions.  It is an error to read from
-a write stream, and vice versa.
+a write stream, and vice versa. 
 
 Error handling in libpng is done through png_error() and png_warning().
 Errors handled through png_error() are fatal, meaning that png_error()
@@ -2217,19 +2260,23 @@ Removing unwanted object code:
 
 There are a bunch of #define's in pngconf.h that control what parts of
 libpng are compiled.  All the defines end in _SUPPORTED.  If you are
-never going to use an ability, you can change the #define to #undef
-before recompiling libpng and save yourself code and data space.
-You can also turn a number of them off en masse with a compiler directive
-that defines PNG_READ[or WRITE]_TRANSFORMS_NOT_SUPPORTED, or
-PNG_READ[or WRITE]_ANCILLARY_CHUNKS_NOT_SUPPORTED, or all four,
+never going to use a capability, you can change the #define to #undef
+before recompiling libpng and save yourself code and data space, or
+you can turn off individual capabilities with defines that begin with
+PNG_NO_.
+
+You can also turn all of the transforms and ancillary chunk capabilities
+off en masse with  compiler directives that define
+PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS,
+or all four,
 along with directives to turn on any of the capabilities that you do
-want.  The PNG_READ[or WRITE]_TRANSFORMS_NOT_SUPPORTED directives disable
+want.  The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable
 the extra transformations but still leave the library fully capable of reading
 and writing PNG files with all known public chunks [except for sPLT].
-Use of the PNG_READ[or WRITE]_ANCILLARY_CHUNKS_NOT_SUPPORTED directive
+Use of the PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive
 produces a library that is incapable of reading or writing ancillary chunks.
 If you are not using the progressive reading capability, you can
-turn that off with PNG_PROGRESSIVE_READ_NOT_SUPPORTED (don't confuse
+turn that off with PNG_NO_PROGRESSIVE_READ (don't confuse
 this with the INTERLACING capability, which you'll still have).
 
 All the reading and writing specific code are in separate files, so the
@@ -2291,28 +2338,29 @@ on the library has not always been consistent and straightforward.
 The following table summarizes matters since version 0.89c, which was
 the first widely used release:
 
- source                    png.h     shared-lib
- version                   string    version
- -------                   ------    ----------
- 0.89c ("1.0 beta 3")      0.89      1.0.89
- 0.90  ("1.0 beta 4")      0.90      0.90
-                        [should have been 2.0.90]
- 0.95  ("1.0 beta 5")      0.95      0.95
-                        [should have been 2.0.95]
- 0.96  ("1.0 beta 6")      0.96      0.96
-                        [should have been 2.0.96]
- 0.97b ("1.00.97 beta 7")  1.00.97   1.0.0
-                         [should have been 2.0.97]
- 0.97c                     0.97      2.0.97
- 0.98                      0.98      2.0.98
- 0.99                      0.99      2.0.99
- 0.99a-m                   0.99      2.0.99
- 1.0.0                     1.00      2.1.0
+   source     png.h   png.h   shared-lib
+   version    string    int   version
+   -------    ------  ------  ----------
+   0.89c      0.89        89  1.0.89
+   0.90       0.90        90  0.90  [should be 2.0.90]
+   0.95       0.95        95  0.95  [should be 2.0.95]
+   0.96       0.96        96  0.96  [should be 2.0.96]
+   0.97b      1.00.97     97  1.0.1 [should be 2.0.97]
+   0.97c      0.97        97  2.0.97
+   0.98       0.98        98  2.0.98
+   0.99       0.99        98  2.0.99
+   0.99a-m    0.99        99  2.0.99
+   1.00       1.00       100  2.1.0 [int should be 10000]
+   1.0.0      1.0.0      100  2.1.0 [int should be 10000]
+   1.0.1      1.0.1    10001  2.1.0
 
-Henceforth the source version will match the shared-library minor
-and patch numbers; the shared-library major version number will be
+Henceforth the source version will match the shared-library
+minor and patch numbers; the shared-library major version number will be
 used for changes in backward compatibility, as it is intended.
-
+The PNG_PNGLIB_VER macro, which is not used within libpng but
+is available for applications, is an unsigned integer of the form
+xyyzz corresponding to the source version x.y.z (leading zeros in y and z).
+ 
 .SH "SEE ALSO"
 libpngpf(3), png(5)
 .LP
@@ -2365,7 +2413,7 @@ possible without all of you.
 
 Thanks to Frank J. T. Wojcik for helping with the documentation.
   
-Libpng version 1.0.0 (March 8, 1998):
+Libpng version 1.0.2 - June 14, 1998:
 Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.
 Currently maintained by Glenn Randers-Pehrson (randeg@alumni.rpi.edu).
 

libpng.txt

@@ -1,6 +1,6 @@
 libpng.txt - A description on how to use and modify libpng
 
- libpng version 1.0.0 March 8, 1998
+ libpng version 1.0.2 - June 14, 1998
  Updated and distributed by Glenn Randers-Pehrson
  <randeg@alumni.rpi.edu>
  Copyright (c) 1998, Glenn Randers-Pehrson
@@ -22,7 +22,7 @@ libpng.txt - A description on how to use and modify libpng
  Copyright (c) 1995 Frank J. T. Wojcik
  December 18, 1995 && January 20, 1996
 
-Introduction
+I. Introduction
 
 This file describes how to use and modify the PNG reference library
 (known as libpng) for your own use.  There are five sections to this
@@ -143,7 +143,7 @@ be NULL if the default error handlers are to be used).  See the section
 on Changes to Libpng below regarding the old initialization functions.
 
     png_structp png_ptr = png_create_read_struct
-       (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
         user_error_fn, user_warning_fn);
     if (!png_ptr)
         return;
@@ -164,10 +164,21 @@ on Changes to Libpng below regarding the old initialization functions.
         return;
     }
 
+If you want to use your own memory allocation routines,
+define PNG_USER_MEM_SUPPORTED and use
+png_create_read_struct_2() instead of png_create_read_struct():
 
-The error handling routines passed to png_create_read_struct() are only
-necessary if you are not using the libpng supplied error handling
-functions.  When libpng encounters an error, it expects to longjmp back
+    png_structp png_ptr = png_create_read_struct_2
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
+        user_error_fn, user_warning_fn, (png_voidp)
+        user_mem_ptr, user_malloc_fn, user_free_fn);
+
+The error handling routines passed to png_create_read_struct()
+and the memory alloc/free routines passed to png_create_struct_2()
+are only necessary if you are not using the libpng supplied error
+handling and memory alloc/free functions.
+
+When libpng encounters an error, it expects to longjmp back
 to your routine.  Therefore, you will need to call setjmp and pass the
 jmpbuf field of your png_struct.  If you read the file from different
 routines, you will need to update the jmpbuf field every time you enter
@@ -476,11 +487,14 @@ unless the library has been told to transform it into another format.
 For example, 4 bit/pixel paletted or grayscale data will be returned
 2 pixels/byte with the leftmost pixel in the high-order bits of the
 byte, unless png_set_packing() is called.  8-bit RGB data will be stored
-in RGBRGBRGB format unless png_set_filler() is called to insert filler
+in RGB RGB RGB format unless png_set_filler() is called to insert filler
 bytes, either before or after each RGB triplet.  16-bit RGB data will
-be returned RRGGBBRRGGBB, with the most significant byte of the color
+be returned RRGGBB RRGGBB, with the most significant byte of the color
 value first, unless png_set_strip_16() is called to transform it to
-regular RGBRGB triplets.
+regular RGB RGB triplets, or png_set_filler() is called to insert
+filler bytes, either before or after each RRGGBB triplet.  Similarly,
+8-bit or 16-bit grayscale data can be modified with png_set_filler()
+or png_set_strip_16().
 
 The following code transforms grayscale images of less than 8 to 8 bits,
 changes paletted images to RGB, and adds a full alpha channel if there is
@@ -556,7 +570,7 @@ into 4 bytes for windowing systems that need them in this format:
         PNG_COLOR_TYPE_RGB) png_set_filler(png_ptr,
         filler, PNG_FILLER_BEFORE);
 
-where "filler" is the number to fill with, and the location is
+where "filler" is the 8 or 16-bit number to fill with, and the location is
 either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether
 you want the filler before the RGB or after.  This transformation
 does not affect images that already have full alpha channels.
@@ -575,21 +589,19 @@ RGB.  This code will do that conversion:
           png_set_gray_to_rgb(png_ptr);
 
 If you have a grayscale and you are using png_set_expand() to change to
-a higher bit-depth you must indicate if the supplied background gray
-is supplied in the original file bit depth (need_expand = 1) or in the
-expanded bit depth (need_expand = 0).  Similarly, if you are reading
-a paletted image, you must indicate if you have supplied the background
-as a palette index that needs to be expanded (need_expand = 1).  You can
-also specify an RGB triplet that isn't in the palette when setting your
-background for a paletted image.
+a higher bit-depth, you must either supply the background color as a gray
+value at the original file bit-depth (need_expand = 1) or else supply the
+background color as an RGB triplet at the final, expanded bit depth
+(need_expand = 0).  Similarly, if you are reading a paletted image, you
+must either supply the background color as a palette index (need_expand = 1)
+or as an RGB triplet that may or may not be in the palette (need_expand = 0).
 
     png_color_16 my_background;
     png_color_16p image_background;
 
-    if (png_get_bKGD(png_ptr, info_ptr,
-        &image_background))
-        png_set_background(png_ptr, image_background),
-        PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+    if (png_get_bKGD(png_ptr, info_ptr, &image_background))
+        png_set_background(png_ptr, image_background,
+          PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
     else
         png_set_background(png_ptr, &my_background,
           PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
@@ -872,7 +884,7 @@ png_infop info_ptr;
  initialize_png_reader()
  {
     png_ptr = png_create_read_struct
-        (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
+        (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
          user_error_fn, user_warning_fn);
     if (!png_ptr)
         return -1;
@@ -991,8 +1003,8 @@ png_infop info_ptr;
           new_row);
 
     /* where old_row is what was displayed for
-       previous rows.  Note that the first pass
-       (pass == 0, really) will completely cover
+       previously for the row.  Note that the first
+       pass (pass == 0, really) will completely cover
        the old row, so the rows do not have to be
        initialized.  After the first pass (and only
        for interlaced images), you will have to pass
@@ -1044,7 +1056,7 @@ both "png_ptr"; you can call them anything you like, such as
 "read_ptr" and "write_ptr".  Look at pngtest.c, for example.
 
     png_structp png_ptr = png_create_write_struct
-       (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
         user_error_fn, user_warning_fn);
     if (!png_ptr)
        return;
@@ -1057,6 +1069,15 @@ both "png_ptr"; you can call them anything you like, such as
        return;
     }
 
+If you want to use your own memory allocation routines,
+define PNG_USER_MEM_SUPPORTED and use
+png_create_write_struct_2() instead of png_create_read_struct():
+
+    png_structp png_ptr = png_create_write_struct_2
+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
+        user_error_fn, user_warning_fn, (png_voidp)
+        user_mem_ptr, user_malloc_fn, user_free_fn);
+
 After you have these structures, you will need to set up the
 error handling.  When libpng encounters an error, it expects to
 longjmp() back to your routine.  Therefore, you will need to call
@@ -1110,9 +1131,9 @@ not calling this function at all, as it has been tuned to deliver a good
 speed/compression ratio. The second parameter to png_set_filter() is
 the filter method, for which the only valid value is '0' (as of the
 October 1996 PNG specification, version 1.0).  The third parameter is a
-flag that indicates
-which filter type(s) are to be tested for each scanline.  See the
-Compression Library for details on the specific filter types.
+flag that indicates which filter type(s) are to be tested for each
+scanline.  See the Compression Library for details on the specific filter
+types.
 
     
     /* turn on or off filtering, and/or choose
@@ -1386,8 +1407,9 @@ checks to see if it has data that it can do something with, you should
 make sure to only enable a transformation if it will be valid for the
 data.  For example, don't swap red and blue on grayscale data.
 
-PNG files store RGB pixels packed into 3 bytes.  This code tells
-the library to expect input data with 4 bytes per pixel
+PNG files store RGB pixels packed into 3 or 6 bytes.  This code tells
+the library to expand the input data to 4 or 8 bytes per pixel
+(or expand 1 or 2-byte grayscale data to 2 or 4 bytes per pixel).
 
     png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
 
@@ -1505,11 +1527,11 @@ times, or any of that other stuff necessary with png_write_rows().
 
 where row_pointers is:
 
-    png_bytef *row_pointers[height];
+    png_byte *row_pointers[height];
 
 You can point to void or char or whatever you use for pixels.
 
-If you can't want to write the whole image at once, you can
+If you don't want to write the whole image at once, you can
 use png_write_rows() instead.  If the file is not interlaced,
 this is simple:
 
@@ -1603,14 +1625,15 @@ time, instead of calling the png_init_io() function.  These functions
 also provide a void pointer that can be retrieved via the function
 png_get_io_ptr().  For example:
 
-    png_set_read_fn(png_structp png_ptr,
-        voidp io_ptr, png_rw_ptr read_data_fn)
+    png_set_read_fn(png_structp read_ptr,
+        voidp read_io_ptr, png_rw_ptr read_data_fn)
 
-    png_set_write_fn(png_structp png_ptr,
-        voidp io_ptr, png_rw_ptr write_data_fn,
+    png_set_write_fn(png_structp write_ptr,
+        voidp write_io_ptr, png_rw_ptr write_data_fn,
         png_flush_ptr output_flush_fn);
 
-    voidp io_ptr = png_get_io_ptr(png_ptr);
+    voidp read_io_ptr = png_get_io_ptr(read_ptr);
+    voidp write_io_ptr = png_get_io_ptr(write_ptr);
 
 The replacement I/O functions should have prototypes as follows:
 
@@ -1622,7 +1645,7 @@ The replacement I/O functions should have prototypes as follows:
 
 Supplying NULL for the read, write, or flush functions sets them back
 to using the default C stream functions.  It is an error to read from
-a write stream, and vice versa.
+a write stream, and vice versa. 
 
 Error handling in libpng is done through png_error() and png_warning().
 Errors handled through png_error() are fatal, meaning that png_error()
@@ -1823,19 +1846,23 @@ Removing unwanted object code:
 
 There are a bunch of #define's in pngconf.h that control what parts of
 libpng are compiled.  All the defines end in _SUPPORTED.  If you are
-never going to use an ability, you can change the #define to #undef
-before recompiling libpng and save yourself code and data space.
-You can also turn a number of them off en masse with a compiler directive
-that defines PNG_READ[or WRITE]_TRANSFORMS_NOT_SUPPORTED, or
-PNG_READ[or WRITE]_ANCILLARY_CHUNKS_NOT_SUPPORTED, or all four,
+never going to use a capability, you can change the #define to #undef
+before recompiling libpng and save yourself code and data space, or
+you can turn off individual capabilities with defines that begin with
+PNG_NO_.
+
+You can also turn all of the transforms and ancillary chunk capabilities
+off en masse with  compiler directives that define
+PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS,
+or all four,
 along with directives to turn on any of the capabilities that you do
-want.  The PNG_READ[or WRITE]_TRANSFORMS_NOT_SUPPORTED directives disable
+want.  The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable
 the extra transformations but still leave the library fully capable of reading
 and writing PNG files with all known public chunks [except for sPLT].
-Use of the PNG_READ[or WRITE]_ANCILLARY_CHUNKS_NOT_SUPPORTED directive
+Use of the PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive
 produces a library that is incapable of reading or writing ancillary chunks.
 If you are not using the progressive reading capability, you can
-turn that off with PNG_PROGRESSIVE_READ_NOT_SUPPORTED (don't confuse
+turn that off with PNG_NO_PROGRESSIVE_READ (don't confuse
 this with the INTERLACING capability, which you'll still have).
 
 All the reading and writing specific code are in separate files, so the
@@ -1886,4 +1913,3 @@ to set the error callbacks AFTER png_read_init(), or to change them with
 png_set_error_fn(), which is essentially the same function, but with a
 new name to force compilation errors with applications that try to use
 the old method.
-

libpngpf.3

@@ -1,6 +1,6 @@
-.TH LIBPNGPF 3 "March 8, 1998"
+.TH LIBPNGPF 3 "June 14, 1998"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library
+libpng \- Portable Network Graphics (PNG) Reference Library 1.0.2 - June 14, 1998
 (private functions)
 .SH SYNOPSIS
 #include <png.h>
@@ -31,10 +31,15 @@ int png_crc_finish (png_structp png_ptr, png_uint_32 skip);
 void png_crc_read (png_structp png_ptr, png_bytep buf,
 png_size_t length);
 
-png_voidp png_create_struct (int type);
+png_voidp png_create_struct (int type, png_malloc_ptr malloc_fn);
+
+png_voidp png_create_struct_2 (int type);
 
 void png_destroy_struct (png_voidp struct_ptr);
 
+void png_destroy_struct_2 (png_voidp struct_ptr, png_free_ptr
+free_fn);
+
 void png_do_background (png_row_infop row_info, png_bytep row,
 png_color_16p trans_values, png_color_16p background,
 png_color_16p background_1, png_bytep gamma_table, png_bytep

png.5

@@ -1,4 +1,4 @@
-.TH PNG 5 "March 8, 1998"
+.TH PNG 5 "June 14, 1998"
 .SH NAME
 png \- Portable Network Graphics (PNG) format
 .SH DESCRIPTION

png.c

@@ -1,12 +1,11 @@
 
 /* png.c - location for general purpose libpng functions
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 #define PNG_INTERNAL
@@ -16,7 +15,7 @@
 /* Version information for C files.  This had better match the version
  * string defined in png.h.
  */
-char png_libpng_ver[6] = "1.0.0";
+char png_libpng_ver[12] = "1.0.2";
 
 /* Place to hold the signature string for a PNG file. */
 png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
@@ -128,12 +127,10 @@ png_check_sig(png_bytep sig, int num)
 voidpf
 png_zalloc(voidpf png_ptr, uInt items, uInt size)
 {
-   png_voidp ptr;
-   png_uint_32 num_bytes;
+   png_uint_32 num_bytes = (png_uint_32)items * size;
+   png_voidp ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
 
-   num_bytes = (png_uint_32)items * size;
-   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
-   if (num_bytes > (png_uint_32)0x8000)
+   if (num_bytes > (png_uint_32)0x8000L)
    {
       png_memset(ptr, 0, (png_size_t)0x8000L);
       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
@@ -201,7 +198,12 @@ png_create_info_struct(png_structp png_ptr)
 
    png_debug(1, "in png_create_info_struct\n");
    if(png_ptr == NULL) return (NULL);
+#ifdef PNG_USER_MEM_SUPPORTED
+   if ((info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
+      png_ptr->malloc_fn)) != NULL)
+#else
    if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)
+#endif
    {
       png_info_init(info_ptr);
    }
@@ -227,7 +229,11 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
    {
       png_info_destroy(png_ptr, info_ptr);
 
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn);
+#else
       png_destroy_struct((png_voidp)info_ptr);
+#endif
       *info_ptr_ptr = (png_infop)NULL;
    }
 }
@@ -252,11 +258,10 @@ void
 png_info_destroy(png_structp png_ptr, png_infop info_ptr)
 {
 #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
-   int i;
-
    png_debug(1, "in png_info_destroy\n");
    if (info_ptr->text != NULL)
    {
+      int i;
       for (i = 0; i < info_ptr->num_text; i++)
       {
          png_free(png_ptr, info_ptr->text[i].key);
@@ -269,6 +274,7 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
    png_free(png_ptr, info_ptr->pcal_units);
    if (info_ptr->pcal_params != NULL)
    {
+      int i;
       for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
       {
          png_free(png_ptr, info_ptr->pcal_params[i]);
@@ -302,3 +308,40 @@ png_init_io(png_structp png_ptr, FILE *fp)
    png_ptr->io_ptr = (png_voidp)fp;
 }
 #endif
+
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+/* Convert the supplied time into an RFC 1123 string suitable for use in
+ * a "Creation Time" or other text-based time string.
+ */
+png_charp
+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
+{
+   static PNG_CONST char short_months[12][4] =
+	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+	 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+   if (png_ptr->time_buffer == NULL)
+   {
+      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
+         sizeof(char)));
+   }
+
+#ifdef USE_FAR_KEYWORD
+   {
+      char near_time_buf[29];
+      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
+               ptime->day % 32, short_months[(ptime->month - 1) % 12],
+               ptime->year, ptime->hour % 24, ptime->minute % 60,
+               ptime->second % 61);
+      png_memcpy(png_ptr->time_buffer, near_time_buf,
+      29*sizeof(char));
+   }
+#else
+   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
+               ptime->day % 32, short_months[(ptime->month - 1) % 12],
+               ptime->year, ptime->hour % 24, ptime->minute % 60,
+               ptime->second % 61);
+#endif
+   return ((png_charp)png_ptr->time_buffer);
+}
+#endif /* PNG_TIME_RFC1123_SUPPORTED */

png.h

@@ -1,12 +1,11 @@
 
 /* png.h - header file for PNG reference library
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see the COPYRIGHT NOTICE below.
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998 Glenn Randers-Pehrson
- * March 8, 1998
  *
  * Note about libpng version numbers:
  *
@@ -16,26 +15,32 @@
  *    The following table summarizes matters since version 0.89c, which was
  *    the first widely used release:
  *
- *      source                    png.h     shared-lib
- *      version                   string    version
- *      -------                   ------    ----------
- *      0.89c ("1.0 beta 3")      0.89      1.0.89
- *      0.90  ("1.0 beta 4")      0.90      0.90  [should have been 2.0.90]
- *      0.95  ("1.0 beta 5")      0.95      0.95  [should have been 2.0.95]
- *      0.96  ("1.0 beta 6")      0.96      0.96  [should have been 2.0.96]
- *      0.97b ("1.00.97 beta 7")  1.00.97   1.0.0 [should have been 2.0.97]
- *      0.97c                     0.97      2.0.97
- *      0.98                      0.98      2.0.98
- *      0.99                      0.99      2.0.99
- *      0.99a-m                   0.99      2.0.99
- *      1.0.0                     1.00      2.1.0
+ *    source                    png.h    png.h   shared-lib
+ *    version                   string     int   version
+ *    -------                   ------   -----  ----------
+ *    0.89c ("1.0 beta 3")      0.89        89  1.0.89
+ *    0.90  ("1.0 beta 4")      0.90        90  0.90  [should have been 2.0.90]
+ *    0.95  ("1.0 beta 5")      0.95        95  0.95  [should have been 2.0.95]
+ *    0.96  ("1.0 beta 6")      0.96        96  0.96  [should have been 2.0.96]
+ *    0.97b ("1.00.97 beta 7")  1.00.97     97  1.0.1 [should have been 2.0.97]
+ *    0.97c                     0.97        97  2.0.97
+ *    0.98                      0.98        98  2.0.98
+ *    0.99                      0.99        98  2.0.99
+ *    0.99a-m                   0.99        99  2.0.99
+ *    1.00                      1.00       100  2.1.0 [int should be 10000]
+ *    1.0.0                     1.0.0      100  2.1.0 [int should be 10000]
+ *    1.0.1                     1.0.1    10001  2.1.0
+ *    1.0.1a-e                  1.0.1a-e 10002  2.1.0.1a-e
  *
  *    Henceforth the source version will match the shared-library minor
  *    and patch numbers; the shared-library major version number will be
- *    used for changes in backward compatibility, as it is intended.
+ *    used for changes in backward compatibility, as it is intended.  The
+ *    PNG_PNGLIB_VER macro, which is not used within libpng but is available
+ *    for applications, is an unsigned integer of the form xyyzz corresponding
+ *    to the source version x.y.z (leading zeros in y and z).
  *
- * See libpng.txt for more information.  The PNG specification is available
- * as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/>
+ * See libpng.txt or libpng.3 for more information.  The PNG specification
+ * is available as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/>
  * and as a W3C Recommendation <http://www.w3.org/TR/REC.png.html>
  *
  * Contributing Authors:
@@ -112,19 +117,21 @@ extern "C" {
  */
 
 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "1.0.0"
+#define PNG_LIBPNG_VER_STRING "1.0.2"
 
-/* careful here.  At one time, I wanted to use 082, but that would be octal.
- * Version 1.0.0 will be 100 here, etc.
- */
-#define PNG_LIBPNG_VER  100
+/* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
+ * We must not include leading zeros.
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
+ * version 1.0.0 was mis-numbered 100 instead of 10000).  From
+ * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=bugfix */
+#define PNG_LIBPNG_VER    10002  /* 1.0.2 */
 
 /* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
 #if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
 /* Version information for C files, stored in png.c.  This had better match
  * the version above.
  */
-extern char png_libpng_ver[6];
+extern char png_libpng_ver[12];   /* need room for 99.99.99aa */
 
 /* Structures to facilitate easy interlacing.  See png.c for more details */
 extern int FARDATA png_pass_start[7];
@@ -223,7 +230,7 @@ typedef png_time FAR * FAR * png_timepp;
  * With libpng < 0.95, it was only possible to directly set and read the
  * the values in the png_info_struct, which meant that the contents and
  * order of the values had to remain fixed.  With libpng 0.95 and later,
- * however, * there are now functions which abstract the contents of
+ * however, there are now functions that abstract the contents of
  * png_info_struct from the application, so this makes it easier to use
  * libpng with dynamic libraries, and even makes it possible to use
  * libraries that don't have all of the libpng ancillary chunk-handing
@@ -281,14 +288,14 @@ typedef struct png_info_struct
    /* The tEXt and zTXt chunks contain human-readable textual data in
     * uncompressed and compressed forms, respectively.  The data in "text"
     * is an array of pointers to uncompressed, null-terminated C strings.
-    * Each chunk has a keyword which describes the textual data contained
+    * Each chunk has a keyword that describes the textual data contained
     * in that chunk.  Keywords are not required to be unique, and the text
     * string may be empty.  Any number of text chunks may be in an image.
     */
    int num_text; /* number of comments read/to write */
    int max_text; /* current size of text array */
    png_textp text; /* array of comments read/to write */
-#endif /* PNG_READ_tEXt/zTXt_SUPPORTED || PNG_WRITE_tEXt/zTXt_SUPPORTED */
+#endif /* PNG_READ_OR_WRITE_tEXt_OR_zTXt_SUPPORTED */
 #if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
    /* The tIME chunk holds the last time the displayed image data was
     * modified.  See the png_time struct for the contents of this struct.
@@ -304,14 +311,15 @@ typedef struct png_info_struct
     */
    png_color_8 sig_bit; /* significant bits in color channels */
 #endif /* PNG_READ_sBIT_SUPPORTED || PNG_WRITE_sBIT_SUPPORTED */
-#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED)
+#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED) || \
+    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
    /* The tRNS chunk supplies transparency data for paletted images and
     * other image types that don't need a full alpha channel.  There are
     * "num_trans" transparency values for a paletted image, stored in the
     * same order as the palette colors, starting from index 0.  Values
     * for the data are in the range [0, 255], ranging from fully transparent
     * to fully opaque, respectively.  For non-paletted images, there is a
-    * single color specified which should be treated as fully transparent.
+    * single color specified that should be treated as fully transparent.
     * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.
     */
    png_bytep trans; /* transparent values for paletted image */
@@ -483,10 +491,11 @@ typedef struct png_row_info_struct
 typedef png_row_info FAR * png_row_infop;
 typedef png_row_info FAR * FAR * png_row_infopp;
 
-/* These are the function types for the I/O functions, and the functions which
- * modify the default I/O functions to user I/O functions.  The png_error_ptr
- * type should match that of user supplied warning and error functions, while
- * the png_rw_ptr type should match that of the user read/write data functions.
+/* These are the function types for the I/O functions and for the functions
+ * that allow the user to override the default I/O functions with his or her
+ * own.  The png_error_ptr type should match that of user-supplied warning
+ * and error functions, while the png_rw_ptr type should match that of the
+ * user read/write data functions.
  */
 typedef struct png_struct_def png_struct;
 typedef png_struct FAR * png_structp;
@@ -509,6 +518,9 @@ typedef void (*png_user_transform_ptr) PNGARG((png_structp,
     png_row_infop, png_bytep));
 #endif /* PNG_READ|WRITE_USER_TRANSFORM_SUPPORTED */
 
+typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t));
+typedef void (*png_free_ptr) PNGARG((png_structp, png_structp));
+
 /* The structure that holds the information to read and write PNG files.
  * The only people who need to care about what is inside of this are the
  * people who will be modifying the library for their own special needs.
@@ -581,7 +593,7 @@ struct png_struct_def
    png_byte sig_bytes;        /* magic bytes read/written from start of file */
 
 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
-   png_byte filler;           /* filler byte for 24->32-bit pixel expansion */
+   png_uint_16 filler;           /* filler bytes for pixel expansion */
 #endif /* PNG_READ_FILLER_SUPPORTED */
 #if defined(PNG_READ_bKGD_SUPPORTED)
    png_byte background_gamma_type;
@@ -596,7 +608,7 @@ struct png_struct_def
    png_uint_32 flush_dist;    /* how many rows apart to flush, 0 - no flush */
    png_uint_32 flush_rows;    /* number of rows written since last flush */
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
    int gamma_shift;      /* number of "insignificant" bits 16-bit gamma */
    float gamma;          /* file gamma value */
    float screen_gamma;   /* screen gamma value (display_gamma/viewing_gamma */
@@ -615,10 +627,11 @@ struct png_struct_def
 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
    png_color_8 shift;         /* shift for significant bit tranformation */
 #endif /* PNG_READ_SHIFT_SUPPORTED || PNG_WRITE_SHIFT_SUPPORTED */
-#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
+ || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
    png_bytep trans;           /* transparency values for paletted files */
    png_color_16 trans_values; /* transparency values for non-paletted files */
-#endif /* PNG_READ_tRNS_SUPPORTED || PNG_READ_BACKGROUND_SUPPORTED */
+#endif /* PNG_READ|WRITE_tRNS_SUPPORTED||PNG_READ_EXPAND|BACKGROUND_SUPPORTED */
    png_read_status_ptr read_row_fn;   /* called after each row is decoded */
    png_write_status_ptr write_row_fn; /* called after each row is encoded */
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
@@ -671,6 +684,11 @@ struct png_struct_def
 #if defined(PNG_TIME_RFC1123_SUPPORTED)
    png_charp time_buffer;            /* String to hold RFC 1123 time text */
 #endif /* PNG_TIME_RFC1123_SUPPORTED */
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_voidp mem_ptr;                /* user supplied struct for mem functions */
+   png_malloc_ptr malloc_fn;         /* function for allocating memory */
+   png_free_ptr free_fn;             /* function for freeing memory */
+#endif /* PNG_USER_MEM_SUPPORTED */
 };
 
 typedef png_struct FAR * FAR * png_structpp;
@@ -702,14 +720,25 @@ extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num));
 
 /* Allocate and initialize png_ptr struct for reading, and any other memory. */
 extern PNG_EXPORT(png_structp,png_create_read_struct)
-   PNGARG((png_const_charp user_png_ver, voidp error_ptr,
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
    png_error_ptr error_fn, png_error_ptr warn_fn));
 
-/* Allocate and initialize png_ptr struct for reading, and any other memory */
+/* Allocate and initialize png_ptr struct for writing, and any other memory */
 extern PNG_EXPORT(png_structp,png_create_write_struct)
-   PNGARG((png_const_charp user_png_ver, voidp error_ptr,
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
    png_error_ptr error_fn, png_error_ptr warn_fn));
 
+#ifdef PNG_USER_MEM_SUPPORTED
+extern PNG_EXPORT(png_structp,png_create_read_struct_2)
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+extern PNG_EXPORT(png_structp,png_create_write_struct_2)
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, 
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+#endif
+
 /* Write a PNG chunk - size, type, (optional) data, CRC. */
 extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,
    png_bytep chunk_name, png_bytep data, png_size_t length));
@@ -1103,6 +1132,15 @@ extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,
 extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,
    png_write_status_ptr write_row_fn));
 
+#ifdef PNG_USER_MEM_SUPPORTED
+/* Replace the default memory allocation functions with user supplied one(s). */
+extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,
+   png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+
+/* Return the user pointer associated with the memory functions */
+extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));
+#endif /* PNG_USER_MEM_SUPPORTED */
+
 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp
    png_ptr, png_user_transform_ptr read_user_transform_fn));
@@ -1130,7 +1168,7 @@ extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)
 extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,
    png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));
 
-/* function which combines rows.  Not very much different than the
+/* function that combines rows.  Not very much different than the
  * png_combine_row() call.  Is this even used?????
  */
 extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,
@@ -1143,19 +1181,19 @@ extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,
 /* frees a pointer allocated by png_malloc() */
 extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));
 
+#ifdef PNG_USER_MEM_SUPPORTED
+extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,
+   png_uint_32 size));
+extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,
+   png_voidp ptr));
+#endif /* PNG_USER_MEM_SUPPORTED */
+
 extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,
    png_voidp s1, png_voidp s2, png_uint_32 size));
 
 extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,
    png_voidp s1, int value, png_uint_32 size));
 
-#ifdef PNGTEST_MEMORY_DEBUG
-/* debugging versions of png_malloc() and png_free() */
-extern PNG_EXPORT(png_voidp,png_debug_malloc) PNGARG((png_structp png_ptr,
-   png_uint_32 size));
-extern PNG_EXPORT(void,png_debug_free) PNGARG((png_structp png_ptr,
-   png_voidp ptr));
-#endif
 #if defined(USE_FAR_KEYWORD)  /* memory model conversion function */
 extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
    int check));
@@ -1382,8 +1420,7 @@ extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,
     defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
 extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,
    png_infop info_ptr, png_textp text_ptr, int num_text));
-#endif /* PNG_READ_tEXt_SUPPORTED || PNG_WRITE_tEXt_SUPPORTED ||
-          PNG_READ_zTXt_SUPPORTED || PNG_WRITE_zTXt_SUPPORTED */
+#endif /* PNG_READ_OR_WRITE_tEXt_OR_zTXt_SUPPORTED */
 
 #if defined(PNG_READ_tIME_SUPPORTED)
 extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,
@@ -1435,6 +1472,45 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 #define png_debug2(l, m, p1, p2)
 #endif /* (PNG_DEBUG > 0) */
 
+#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
+/* With these routines we avoid an integer divide, which will be slower on
+ * most machines.  However, it does take more operations than the corresponding
+ * divide method, so it may be slower on a few RISC systems.  There are two
+ * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
+ *
+ * Note that the rounding factors are NOT supposed to be the same!  128 and
+ * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
+ * standard method.
+ *
+ * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
+ */
+
+   /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
+#  define png_composite(composite, fg, alpha, bg) \
+     { png_uint_16 temp = ((png_uint_16)(fg) * (png_uint_16)(alpha) + \
+                        (png_uint_16)(bg)*(png_uint_16)(255 - \
+                        (png_uint_16)(alpha)) + (png_uint_16)128); \
+       (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
+#  define png_composite_16(composite, fg, alpha, bg) \
+     { png_uint_32 temp = ((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+                        (png_uint_32)(bg)*(png_uint_32)(65535L - \
+                        (png_uint_32)(alpha)) + (png_uint_32)32768L); \
+       (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
+
+#else  /* standard method using integer division */
+
+   /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
+#  define png_composite(composite, fg, alpha, bg) \
+     (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \
+       (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
+       (png_uint_16)127) / 255)
+#  define png_composite_16(composite, fg, alpha, bg) \
+     (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+       (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \
+       (png_uint_32)32767) / (png_uint_32)65535L)
+
+#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
+
 /* These next functions are used internally in the code.  They generally
  * shouldn't be used unless you are writing code to add or replace some
  * functionality in libpng.  More information about most functions can
@@ -1517,6 +1593,7 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 #define PNG_FLAG_FREE_HIST                0x4000
 #define PNG_FLAG_HAVE_CHUNK_HEADER        0x8000L
 #define PNG_FLAG_WROTE_tIME              0x10000L
+#define PNG_FLAG_BACKGROUND_IS_GRAY      0x20000L
 
 #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
                                      PNG_FLAG_CRC_ANCILLARY_NOWARN)
@@ -1582,7 +1659,7 @@ PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf));
 #endif /* PNG_READ_pCAL_SUPPORTED */
 PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf));
 PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf));
-#endif /* PNG_BIG_ENDIAN_GET_SUPPORTED */
+#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */
 
 /* Initialize png_ptr struct for reading, and allocate any other memory.
  * (old interface - NOT DLL EXPORTED).
@@ -1600,6 +1677,11 @@ PNG_EXTERN png_voidp png_create_struct PNGARG((int type));
 /* free memory from internal libpng struct */
 PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
 
+PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr
+  malloc_fn));
+PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
+   png_free_ptr free_fn));
+
 /* free any memory that info_ptr points to and reset struct. */
 PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
    png_infop info_ptr));
@@ -1715,7 +1797,8 @@ PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
    int num_hist));
 #endif
 
-#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
+#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) || \
+    defined(PNG_WRITE_pCAL_SUPPORTED)
 PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
    png_charp key, png_charpp new_key));
 #endif
@@ -1834,7 +1917,7 @@ PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
 PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));
 #endif
 
-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPOR)
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));
 #endif
 

pngconf.h

@@ -1,12 +1,11 @@
 
 /* pngconf.h - machine configurable file for libpng
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 /* Any machine specific code is near the front of this file, so if you
@@ -47,7 +46,7 @@
 #define PNG_MAX_MALLOC_64K
 #endif
 
-/* This protects us against compilers which run on a windowing system
+/* This protects us against compilers that run on a windowing system
  * and thus don't have or would rather us not use the stdio types:
  * stdin, stdout, and stderr.  The only one currently used is stderr
  * in png_error() and png_warning().  #defining PNG_NO_STDIO will
@@ -237,72 +236,141 @@ __dont__ include it again
 /* Any transformations you will not be using can be undef'ed here */
 
 /* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
-   to turn it off with "*TRANSFORMS_NOT_SUPPORTED" on the compile line,
-   then pick and choose which ones to define without having to edit
-   this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED if you
-   only want to have a png-compliant reader/writer but don't need
+   to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS
+   on the compile line, then pick and choose which ones to define without
+   having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED
+   if you only want to have a png-compliant reader/writer but don't need
    any of the extra transformations.  This saves about 80 kbytes in a
-   typical installation of the library.
+   typical installation of the library. (PNG_NO_* form added in version
+   1.0.1c, for consistency)
  */
 
 
-#ifndef PNG_READ_TRANSFORMS_NOT_SUPPORTED
+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_TRANSFORMS)
 #define PNG_READ_TRANSFORMS_SUPPORTED
 #endif
-#ifndef PNG_WRITE_TRANSFORMS_NOT_SUPPORTED
+#if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_TRANSFORMS)
 #define PNG_WRITE_TRANSFORMS_SUPPORTED
 #endif
 
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+#ifndef PNG_NO_READ_EXPAND
 #define PNG_READ_EXPAND_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_SHIFT
 #define PNG_READ_SHIFT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_PACK
 #define PNG_READ_PACK_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_BGR
 #define PNG_READ_BGR_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_SWAP
 #define PNG_READ_SWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_PACKSWAP
 #define PNG_READ_PACKSWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_INVERT
 #define PNG_READ_INVERT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_DITHER
 #define PNG_READ_DITHER_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_BACKGROUND
 #define PNG_READ_BACKGROUND_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_16_TO_8
 #define PNG_READ_16_TO_8_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_FILLER
 #define PNG_READ_FILLER_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_GAMMA
 #define PNG_READ_GAMMA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_GRAY_TO_RGB
 #define PNG_READ_GRAY_TO_RGB_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_SWAP_ALPHA
 #define PNG_READ_SWAP_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_INVERT_ALPHA
 #define PNG_READ_INVERT_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_STRIP_ALPHA
 #define PNG_READ_STRIP_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_USER_TRANSFORM
 #define PNG_READ_USER_TRANSFORM_SUPPORTED
+#endif
 /* the following aren't implemented yet
+#ifndef PNG_NO_READ_RGB_TO_GRAY
 #define PNG_READ_RGB_TO_GRAY_SUPPORTED
+#endif
  */
 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
 
-#ifndef PNG_PROGRESSIVE_READ_NOT_SUPPORTED   /* if you don't do progressive   */
+#if !defined(PNG_NO_PROGRESSIVE_READ) && \
+ !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive   */
 #define PNG_PROGRESSIVE_READ_SUPPORTED       /* reading.  This is not talking */
 #endif                               /* about interlacing capability!  You'll */
               /* still have interlacing unless you change the following line: */
 #define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */
+
+#ifndef PNG_NO_READ_COMPOSITED_NODIV
 #define PNG_READ_COMPOSITE_NODIV_SUPPORTED    /* well tested on Intel and SGI */
+#endif
 
 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+#ifndef PNG_NO_WRITE_SHIFT
 #define PNG_WRITE_SHIFT_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_PACK
 #define PNG_WRITE_PACK_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_BGR
 #define PNG_WRITE_BGR_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_SWAP
 #define PNG_WRITE_SWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_PACKSWAP
 #define PNG_WRITE_PACKSWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_INVERT
 #define PNG_WRITE_INVERT_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_FILLER
 #define PNG_WRITE_FILLER_SUPPORTED  /* This is the same as WRITE_STRIP_ALPHA */
-#define PNG_WRITE_FLUSH_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_SWAP_ALPHA
 #define PNG_WRITE_SWAP_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_INVERT_ALPHA
 #define PNG_WRITE_INVERT_ALPHA_SUPPORTED
-#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_USER_TRANSFORM
 #define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#endif
 #endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
 
 #define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant
                                             encoders, but can cause trouble
                                             if left undefined */
 
-#if !defined(PNG_NO_STDIO)
+#ifndef PNG_NO_WRITE_WEIGHTED_FILTER
+#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#endif
+
+#ifndef PNG_NO_WRITE_FLUSH
+#define PNG_WRITE_FLUSH_SUPPORTED
+#endif
+
+#ifndef PNG_NO_STDIO
 #define PNG_TIME_RFC1123_SUPPORTED
 #endif
 
@@ -322,7 +390,7 @@ __dont__ include it again
  * png_get_x_offset_microns()
  * png_get_y_offset_microns()
  */
-#if !defined(PNG_NO_EASY_ACCESS)
+#ifndef PNG_NO_EASY_ACCESS
 #define PNG_EASY_ACCESS_SUPPORTED
 #endif
 
@@ -331,6 +399,7 @@ __dont__ include it again
 /* very little testing */
 /*
 #define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+#define PNG_USER_MEM_SUPPORTED
 */
 
 /* This is only for PowerPC big-endian and 680x0 systems */
@@ -351,45 +420,100 @@ __dont__ include it again
  * a bit smaller.
  */
 
-#ifndef PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED
+#if !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_ANCILLARY_CHUNKS)
 #define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
 #endif
-#ifndef PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED
+#if !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)
 #define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
 #endif
 
 #ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#ifndef PNG_NO_READ_bKGD
 #define PNG_READ_bKGD_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_cHRM
 #define PNG_READ_cHRM_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_gAMA
 #define PNG_READ_gAMA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_hIST
 #define PNG_READ_hIST_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_oFFs
 #define PNG_READ_oFFs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pCAL
 #define PNG_READ_pCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pHYs
 #define PNG_READ_pHYs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sBIT
 #define PNG_READ_sBIT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sRGB
 #define PNG_READ_sRGB_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tEXt
 #define PNG_READ_tEXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tIME
 #define PNG_READ_tIME_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tRNS
 #define PNG_READ_tRNS_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_zTXt
 #define PNG_READ_zTXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_OPT_PLTE
 #define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the optional */
-                                    /* PLTE chunk in RGB and RGBA images */
+#endif                              /* PLTE chunk in RGB and RGBA images */
 #endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */
 
 #ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#ifndef PNG_NO_WRITE_bKGD
 #define PNG_WRITE_bKGD_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_cHRM
 #define PNG_WRITE_cHRM_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_gAMA
 #define PNG_WRITE_gAMA_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_hIST
 #define PNG_WRITE_hIST_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_oFFs
 #define PNG_WRITE_oFFs_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_pCAL
 #define PNG_WRITE_pCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_pHYs
 #define PNG_WRITE_pHYs_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_sBIT
 #define PNG_WRITE_sBIT_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_sRGB
 #define PNG_WRITE_sRGB_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_tEXt
 #define PNG_WRITE_tEXt_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_tIME
 #define PNG_WRITE_tIME_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_tRNS
 #define PNG_WRITE_tRNS_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_zTXt
 #define PNG_WRITE_zTXt_SUPPORTED
+#endif
 #endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */
 
 /* need the time information for reading tIME chunks */
@@ -539,6 +663,7 @@ typedef z_stream FAR *  png_zstreamp;
 #   define NOCHECK 0
 #   define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))
 #   define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))
+#   define png_strcpy _fstrcpy
 #   define png_strlen _fstrlen
 #   define png_memcmp _fmemcmp      /* SJT: added */
 #   define png_memcpy _fmemcpy
@@ -546,6 +671,7 @@ typedef z_stream FAR *  png_zstreamp;
 #else /* use the usual functions */
 #   define CVT_PTR(ptr)         (ptr)
 #   define CVT_PTR_NOCHECK(ptr) (ptr)
+#   define png_strcpy strcpy
 #   define png_strlen strlen
 #   define png_memcmp memcmp     /* SJT: added */
 #   define png_memcpy memcpy

pngerror.c

@@ -1,14 +1,13 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
- * This file provides a location for all error handling.  Users which
+ * This file provides a location for all error handling.  Users who
  * need special error handling are expected to write replacement functions
  * and use png_set_error_fn() to use those functions.  See the instructions
  * at each function.
@@ -52,7 +51,7 @@ png_warning(png_structp png_ptr, png_const_charp message)
       png_default_warning(png_ptr, message);
 }
 
-/* These utilities are used internally to build an error message which relates
+/* These utilities are used internally to build an error message that relates
  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
  * this is used to prefix the message.  The message is limited in length
  * to 63 bytes, the name characters are output as hex digits wrapped in []
@@ -131,7 +130,7 @@ png_default_error(png_structp png_ptr, png_const_charp message)
 
 /* This function is called when there is a warning, but the library thinks
  * it can continue anyway.  Replacement functions don't have to do anything
- * here if you don't want to.  In the default configuration, png_ptr is
+ * here if you don't want them to.  In the default configuration, png_ptr is
  * not used, but it is passed in case it may be useful.
  */
 static void

pngget.c

@@ -1,12 +1,11 @@
 
 /* pngget.c - retrieval of values from info struct
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 #define PNG_INTERNAL
@@ -302,11 +301,11 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
    }
    return (retval);
 }
-#endif
-
+#endif /* PNG_READ_pHYs_SUPPORTED */
 #endif  /* PNG_INCH_CONVERSIONS */
 
 /* png_get_channels really belongs in here, too, but it's been around longer */
+
 #endif  /* PNG_EASY_ACCESS_SUPPORTED */
 
 png_byte

pngmem.c

@@ -1,31 +1,22 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
- * This file provides a location for all memory allocation.  Users which
- * need special memory handling are expected to modify the code in this file
- * to meet their needs.  See the instructions at each function.
+ * This file provides a location for all memory allocation.  Users who
+ * need special memory handling are expected to supply replacement
+ * functions for png_malloc() and png_free(), and to use
+ * png_create_read_struct_2() and png_create_write_struct_2() to
+ * identify the replacement functions.
  */
 
 #define PNG_INTERNAL
 #include "png.h"
 
-/* The following "hides" PNG_MALLOC and PNG_FREE thus allowing the pngtest
-   application to put a wrapper on top of them. */
-#ifdef PNGTEST_MEMORY_DEBUG
-#define PNG_MALLOC png_debug_malloc
-#define PNG_FREE   png_debug_free
-#else
-#define PNG_MALLOC png_malloc
-#define PNG_FREE   png_free
-#endif
-
 /* Borland DOS special memory handler */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 /* if you change this, be sure to change the one in png.h also */
@@ -35,6 +26,15 @@
 png_voidp
 png_create_struct(int type)
 {
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL));
+}
+
+/* Alternate version of png_create_struct, for use with user-defined malloc. */
+png_voidp
+png_create_struct_2(int type, png_malloc_ptr malloc_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
    png_size_t size;
    png_voidp struct_ptr;
 
@@ -45,11 +45,18 @@ png_create_struct(int type)
    else
      return ((png_voidp)NULL);
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(malloc_fn != NULL)
+   {
+      if ((struct_ptr = (*(malloc_fn))(NULL, size)) != NULL)
+         png_memset(struct_ptr, 0, size);
+         return (struct_ptr);
+   }
+#endif /* PNG_USER_MEM_SUPPORTED */
    if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
    {
       png_memset(struct_ptr, 0, size);
    }
-
    return (struct_ptr);
 }
 
@@ -58,8 +65,27 @@ png_create_struct(int type)
 void
 png_destroy_struct(png_voidp struct_ptr)
 {
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, (png_free_ptr)NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
+{
+#endif
    if (struct_ptr != NULL)
    {
+#ifdef PNG_USER_MEM_SUPPORTED
+      if(free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         (*(free_fn))(png_ptr, struct_ptr);
+         struct_ptr = NULL;
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */
       farfree (struct_ptr);
       struct_ptr = NULL;
    }
@@ -72,7 +98,7 @@ png_destroy_struct(png_voidp struct_ptr)
  * have the ability to do that.
  *
  * Borland seems to have a problem in DOS mode for exactly 64K.
- * It gives you a segment with an offset of 8 (perhaps to store it's
+ * It gives you a segment with an offset of 8 (perhaps to store its
  * memory stuff).  zlib doesn't like this at all, so we have to
  * detect and deal with it.  This code should not be needed in
  * Windows or OS/2 modes, and only in 16 bit mode.  This code has
@@ -85,12 +111,27 @@ png_destroy_struct(png_voidp struct_ptr)
  * (which should cause a fatal error) and introducing major problems.
  */
 png_voidp
-PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
+png_malloc(png_structp png_ptr, png_uint_32 size)
 {
+#ifndef PNG_USER_MEM_SUPPORTED
    png_voidp ret;
+#endif
    if (png_ptr == NULL || size == 0)
       return ((png_voidp)NULL);
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(png_ptr->malloc_fn != NULL)
+       return ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+   else
+       return png_malloc_default(png_ptr, size);
+}
+
+png_voidp
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+#endif PNG_USER_MEM_SUPPORTED
+
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
       png_error(png_ptr, "Cannot Allocate > 64K");
@@ -181,15 +222,30 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
    return (ret);
 }
 
-/* free a pointer allocated by PNG_MALLOC().  In the default
+/* free a pointer allocated by png_malloc().  In the default
    configuration, png_ptr is not used, but is passed in case it
    is needed.  If ptr is NULL, return without taking any action. */
 void
-PNG_FREE(png_structp png_ptr, png_voidp ptr)
+png_free(png_structp png_ptr, png_voidp ptr)
 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      ptr = NULL;
+      return;
+   }
+   else png_free_default(png_ptr, ptr);
+}
+
+void
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+      
    if (png_ptr->offset_table != NULL)
    {
       int i;
@@ -227,6 +283,17 @@ PNG_FREE(png_structp png_ptr, png_voidp ptr)
 png_voidp
 png_create_struct(int type)
 {
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL));
+}
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably.*/
+png_voidp
+png_create_struct_2(int type, png_malloc_ptr malloc_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
    png_size_t size;
    png_voidp struct_ptr;
 
@@ -237,6 +304,15 @@ png_create_struct(int type)
    else
       return ((png_voidp)NULL);
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(malloc_fn != NULL)
+   {
+      if ((struct_ptr = (*(malloc_fn))(NULL, size)) != NULL)
+         png_memset(struct_ptr, 0, size);
+      return (struct_ptr);
+   }
+#endif /* PNG_USER_MEM_SUPPORTED */
+
 #if defined(__TURBOC__) && !defined(__FLAT__)
    if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
 #else
@@ -258,15 +334,37 @@ png_create_struct(int type)
 void
 png_destroy_struct(png_voidp struct_ptr)
 {
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, (png_free_ptr)NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
    if (struct_ptr != NULL)
    {
+#ifdef PNG_USER_MEM_SUPPORTED
+      if(free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         (*(free_fn))(png_ptr, struct_ptr);
+         struct_ptr = NULL;
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */
 #if defined(__TURBOC__) && !defined(__FLAT__)
       farfree(struct_ptr);
+      struct_ptr = NULL;
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
       hfree(struct_ptr);
+      struct_ptr = NULL;
 # else
       free(struct_ptr);
+      struct_ptr = NULL;
 # endif
 #endif
    }
@@ -280,13 +378,26 @@ png_destroy_struct(png_voidp struct_ptr)
    have the ability to do that. */
 
 png_voidp
-PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
+png_malloc(png_structp png_ptr, png_uint_32 size)
 {
+#ifndef PNG_USER_MEM_SUPPORTED
    png_voidp ret;
-
+#endif
    if (png_ptr == NULL || size == 0)
       return ((png_voidp)NULL);
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(png_ptr->malloc_fn != NULL)
+       return ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+   else
+       return (png_malloc_default(png_ptr, size));
+}
+png_voidp
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
       png_error(png_ptr, "Cannot Allocate > 64K");
@@ -310,22 +421,38 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
    return (ret);
 }
 
-/* Free a pointer allocated by PNG_MALLOC().  In the default
-  configuration, png_ptr is not used, but is passed in case it
-  is needed.  If ptr is NULL, return without taking any action. */
+/* Free a pointer allocated by png_malloc().  If ptr is NULL, return
+   without taking any action. */
 void
-PNG_FREE(png_structp png_ptr, png_voidp ptr)
+png_free(png_structp png_ptr, png_voidp ptr)
 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      ptr = NULL;
+      return;
+   }
+   else png_free_default(png_ptr, ptr);
+}
+void
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
 #if defined(__TURBOC__) && !defined(__FLAT__)
    farfree(ptr);
+   ptr = NULL;
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
    hfree(ptr);
+   ptr = NULL;
 # else
    free(ptr);
+   ptr = NULL;
 # endif
 #endif
 }
@@ -358,3 +485,27 @@ png_memset_check (png_structp png_ptr, png_voidp s1, int value,
    return (png_memset (s1, value, size));
 
 }
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* This function is called when the application wants to use another method
+ * of allocating and freeing memory.
+ */
+void
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+  malloc_fn, png_free_ptr free_fn)
+{
+   png_ptr->mem_ptr = mem_ptr;
+   png_ptr->malloc_fn = malloc_fn;
+   png_ptr->free_fn = free_fn;
+}
+
+/* This function returns a pointer to the mem_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp
+png_get_mem_ptr(png_structp png_ptr)
+{
+   return ((png_voidp)png_ptr->mem_ptr);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */

pngpread.c

@@ -1,12 +1,11 @@
 
 /* pngpread.c - read a png file in push mode
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 #define PNG_INTERNAL
@@ -78,8 +77,9 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
 
 /* Read any remaining signature bytes from the stream and compare them with
  * the correct PNG signature.  It is possible that this routine is called
- * with bytes already read from the signature, whether because they have been
- * checked by the calling application, or from multiple calls to this routine.
+ * with bytes already read from the signature, either because they have been
+ * checked by the calling application, or because of multiple calls to this
+ * routine.
  */
 void
 png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
@@ -446,13 +446,13 @@ png_push_save_buffer(png_structp png_ptr)
    {
       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
       {
-         png_size_t i;
+         png_size_t i,istop;
          png_bytep sp;
          png_bytep dp;
 
+         istop = png_ptr->save_buffer_size;
          for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
-            i < png_ptr->save_buffer_size;
-            i++, sp++, dp++)
+            i < istop; i++, sp++, dp++)
          {
             *dp = *sp;
          }
@@ -1070,7 +1070,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
 #endif
 
 /* This function is called when we haven't found a handler for this
- * chunk.  In the future we will have code here which can handle
+ * chunk.  In the future we will have code here that can handle
  * user-defined callback functions for unknown chunks before they are
  * ignored or cause an error.  If there isn't a problem with the
  * chunk itself (ie a bad chunk name or a critical chunk), the chunk
@@ -1117,7 +1117,7 @@ void
 png_progressive_combine_row (png_structp png_ptr,
    png_bytep old_row, png_bytep new_row)
 {
-   if (new_row != NULL)
+   if (new_row != NULL)    /* new_row must == png_ptr->row_buf here. */
       png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
 }
 

pngread.c

@@ -1,12 +1,11 @@
 
 /* pngread.c - read a PNG file
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
  * This file contains routines that an application calls directly to
  * read a PNG file or stream.
@@ -17,15 +16,34 @@
 
 /* Create a PNG structure for reading, and allocate any memory needed. */
 png_structp
-png_create_read_struct(png_const_charp user_png_ver, voidp error_ptr,
+png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
    png_error_ptr error_fn, png_error_ptr warn_fn)
 {
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
+      warn_fn, NULL, NULL, NULL));
+}
+
+/* Alternate create PNG structure for reading, and allocate any memory needed. */
+png_structp
+png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
    png_structp png_ptr;
 #ifdef USE_FAR_KEYWORD
    jmp_buf jmpbuf;
 #endif
    png_debug(1, "in png_create_read_struct\n");
+#ifdef PNG_USER_MEM_SUPPORTED
+   if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+      (png_malloc_ptr)malloc_fn)) == NULL)
+#else
    if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
+#endif
    {
       return (png_structp)NULL;
    }
@@ -42,6 +60,11 @@ png_create_read_struct(png_const_charp user_png_ver, voidp error_ptr,
 #ifdef USE_FAR_KEYWORD
    png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
 #endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif /* PNG_USER_MEM_SUPPORTED */
+
    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
 
    /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
@@ -82,7 +105,7 @@ png_create_read_struct(png_const_charp user_png_ver, voidp error_ptr,
 }
 
 /* Initialize PNG structure for reading, and allocate any memory needed.
-   This interface is depreciated in favour of the png_create_read_struct(),
+   This interface is deprecated in favour of the png_create_read_struct(),
    and it will eventually disappear. */
 void
 png_read_init(png_structp png_ptr)
@@ -123,9 +146,9 @@ png_read_init(png_structp png_ptr)
 }
 
 /* Read the information before the actual image data.  This has been
- * changed in v0.90 to allow reading a file which already has the magic
+ * changed in v0.90 to allow reading a file that already has the magic
  * bytes read from the stream.  You can tell libpng how many bytes have
- * been read from the beginning of the stream (up to the maxumum of 8)
+ * been read from the beginning of the stream (up to the maximum of 8)
  * via png_set_sig_bytes(), and we will only check the remaining bytes
  * here.  The application can then have access to the signature bytes we
  * read if it is determined that this isn't a valid PNG file.
@@ -258,7 +281,7 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
 
 /* Initialize palette, background, etc, after transformations
  * are set, but before any reading takes place.  This allows
- * the user to obtail a gamma corrected palette, for example.
+ * the user to obtain a gamma-corrected palette, for example.
  * If the user doesn't call this, we will do it ourselves.
  */
 void
@@ -279,6 +302,38 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
    /* save jump buffer and error functions */
    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
       png_read_start_row(png_ptr);
+   if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+   {
+   /* check for transforms that have been set but were defined out */
+#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
+   if (png_ptr->transformations & PNG_FILLER)
+      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACK)
+      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
+   if (png_ptr->transformations & PNG_BGR)
+      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
+#endif
+   }
 
 #if defined(PNG_READ_INTERLACING_SUPPORTED)
    /* if interlaced and we do not need a new row, combine row and return */
@@ -457,7 +512,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
 /* Read one or more rows of image data.  If the image is interlaced,
  * and png_set_interlace_handling() has been called, the rows need to
  * contain the contents of the rows from the previous pass.  If the
- * image has alpha or transparency, and png_handle_alpha() has been
+ * image has alpha or transparency, and png_handle_alpha()[*] has been
  * called, the rows contents must be initialized to the contents of the
  * screen.
  * 
@@ -474,6 +529,8 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
  * also, but you may.  If the image is not interlaced, or if you have
  * not called png_set_interlace_handling(), the display_row buffer will
  * be ignored, so pass NULL to it.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.2.
  */
 
 void
@@ -488,29 +545,32 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
    /* save jump buffer and error functions */
    rp = row;
    dp = display_row;
-   for (i = 0; i < num_rows; i++)
-   {
-      png_bytep rptr;
-      png_bytep dptr;
-
-      if (rp != NULL)
-         rptr = *rp;
-      else
-         rptr = NULL;
-      if (dp != NULL)
-         dptr = *dp;
-      else
-         dptr = NULL;
-      png_read_row(png_ptr, rptr, dptr);
-      if (row != NULL)
+   if (rp != NULL && dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp++;
+         png_bytep dptr = *dp++;
+   
+         png_read_row(png_ptr, rptr, dptr);
+      }
+   else if(rp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp;
+         png_read_row(png_ptr, rptr, NULL);
          rp++;
-      if (display_row != NULL)
+      }
+   else if(dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep dptr = *dp;
+         png_read_row(png_ptr, NULL, dptr);
          dp++;
-   }
+      }
 }
 
 /* Read the entire image.  If the image has an alpha channel or a tRNS
- * chunk, and you have called png_handle_alpha(), you will need to
+ * chunk, and you have called png_handle_alpha()[*], you will need to
  * initialize the image to the current image that PNG will be overlaying.
  * We set the num_rows again here, in case it was incorrectly set in
  * png_read_start_row() by a call to png_read_update_info() or
@@ -518,11 +578,13 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
  * prior to either of these functions like it should have been.  You can
  * only call this function once.  If you desire to have an image for
  * each pass of a interlaced image, use png_read_rows() instead.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.2.
  */
 void
 png_read_image(png_structp png_ptr, png_bytepp image)
 {
-   png_uint_32 i;
+   png_uint_32 i,image_height;
    int pass, j;
    png_bytepp rp;
 
@@ -530,12 +592,13 @@ png_read_image(png_structp png_ptr, png_bytepp image)
    /* save jump buffer and error functions */
    pass = png_set_interlace_handling(png_ptr);
 
-   png_ptr->num_rows = png_ptr->height; /* Make sure this is set correctly */
+   image_height=png_ptr->height;
+   png_ptr->num_rows = image_height; /* Make sure this is set correctly */
 
    for (j = 0; j < pass; j++)
    {
       rp = image;
-      for (i = 0; i < png_ptr->height; i++)
+      for (i = 0; i < image_height; i++)
       {
          png_read_row(png_ptr, *rp, NULL);
          rp++;
@@ -647,6 +710,9 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 {
    png_structp png_ptr = NULL;
    png_infop info_ptr = NULL, end_info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn = NULL;
+#endif /* PNG_USER_MEM_SUPPORTED */
 
    png_debug(1, "in png_destroy_read_struct\n");
    /* save jump buffer and error functions */
@@ -659,6 +725,10 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
    if (end_info_ptr_ptr != NULL)
       end_info_ptr = *end_info_ptr_ptr;
 
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
+
    png_read_destroy(png_ptr, info_ptr, end_info_ptr);
 
    if (info_ptr != NULL)
@@ -666,7 +736,12 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
       png_free(png_ptr, info_ptr->text);
 #endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, free_fn);
+#else
       png_destroy_struct((png_voidp)info_ptr);
+#endif
       *info_ptr_ptr = (png_infop)NULL;
    }
 
@@ -675,13 +750,21 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
       png_free(png_ptr, end_info_ptr->text);
 #endif
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)end_info_ptr, free_fn);
+#else
       png_destroy_struct((png_voidp)end_info_ptr);
+#endif
       *end_info_ptr_ptr = (png_infop)NULL;
    }
 
    if (png_ptr != NULL)
    {
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)png_ptr, free_fn);
+#else
       png_destroy_struct((png_voidp)png_ptr);
+#endif
       *png_ptr_ptr = (png_structp)NULL;
    }
 }
@@ -694,6 +777,9 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
    png_error_ptr error_fn;
    png_error_ptr warning_fn;
    png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn;
+#endif
 
    png_debug(1, "in png_read_destroy\n");
    /* save jump buffer and error functions */
@@ -719,10 +805,8 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
 #endif
    if (png_ptr->flags & PNG_FLAG_FREE_PALETTE)
       png_zfree(png_ptr, png_ptr->palette);
-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_bKGD_SUPPORTED)
    if (png_ptr->flags & PNG_FLAG_FREE_TRANS)
       png_free(png_ptr, png_ptr->trans);
-#endif
 #if defined(PNG_READ_hIST_SUPPORTED)
    if (png_ptr->flags & PNG_FLAG_FREE_HIST)
       png_free(png_ptr, png_ptr->hist);
@@ -731,18 +815,19 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
    if (png_ptr->gamma_16_table != NULL)
    {
       int i;
-      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
       {
          png_free(png_ptr, png_ptr->gamma_16_table[i]);
       }
    }
-#endif
 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
    png_free(png_ptr, png_ptr->gamma_16_table);
    if (png_ptr->gamma_16_from_1 != NULL)
    {
       int i;
-      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
       {
          png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
       }
@@ -751,13 +836,18 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
    if (png_ptr->gamma_16_to_1 != NULL)
    {
       int i;
-      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
       {
          png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
       }
    }
    png_free(png_ptr, png_ptr->gamma_16_to_1);
 #endif
+#endif
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+   png_free(png_ptr, png_ptr->time_buffer);
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
 
    inflateEnd(&png_ptr->zstream);
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
@@ -772,12 +862,18 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
    error_fn = png_ptr->error_fn;
    warning_fn = png_ptr->warning_fn;
    error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
 
    png_memset(png_ptr, 0, sizeof (png_struct));
 
    png_ptr->error_fn = error_fn;
    png_ptr->warning_fn = warning_fn;
    png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr->free_fn = free_fn;
+#endif
 
    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
 }

pngrio.c

@@ -1,17 +1,16 @@
 
 /* pngrio.c - functions for data input
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
- * This file provides a location for all input.  Users which need
- * special handling are expected to write a function which has the same
- * arguments as this, and perform a similar function, but possibly has
- * a different input method.  Note that you shouldn't change this
+ * This file provides a location for all input.  Users who need
+ * special handling are expected to write a function that has the same
+ * arguments as this and performs a similar function, but that possibly
+ * has a different input method.  Note that you shouldn't change this
  * function, but rather write a replacement function and then make
  * libpng use it at run time with png_set_read_fn(...).
  */
@@ -35,7 +34,7 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 }
 
 #if !defined(PNG_NO_STDIO)
-/* This is the function which does the actual reading of data.  If you are
+/* This is the function that does the actual reading of data.  If you are
    not reading from a standard C stream, you should create a replacement
    read_data function and use it at run time with png_set_read_fn(), rather
    than changing the library. */
@@ -114,10 +113,10 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
    png_ptr      - pointer to a png input data structure
    io_ptr       - pointer to user supplied structure containing info about
                   the input functions.  May be NULL.
-   read_data_fn - pointer to a new input function which takes as it's
+   read_data_fn - pointer to a new input function that takes as its
                   arguments a pointer to a png_struct, a pointer to
                   a location where input data can be stored, and a 32-bit
-                  unsigned int which is the number of bytes to be read.
+                  unsigned int that is the number of bytes to be read.
                   To exit and output any fatal error messages the new write
                   function should call png_error(png_ptr, "Error msg"). */
 void
@@ -136,7 +135,14 @@ png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
 #endif
 
    /* It is an error to write to a read device */
-   png_ptr->write_data_fn = NULL;
+   if (png_ptr->write_data_fn != NULL)
+   {
+      png_ptr->write_data_fn = NULL;
+      png_warning(png_ptr,
+         "It's an error to set both read_data_fn and write_data_fn in the ");
+      png_warning(png_ptr,
+         "same structure.  Resetting write_data_fn to NULL.");
+   }
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
    png_ptr->output_flush_fn = NULL;

pngrutil.c

@@ -1,14 +1,13 @@
 
 /* pngrutil.c - utilities to read a PNG file
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
- * This file contains routines which are only called from within
+ * This file contains routines that are only called from within
  * libpng itself during the course of reading an image.
  */
 
@@ -16,13 +15,11 @@
 #include "png.h"
 
 #ifndef PNG_READ_BIG_ENDIAN_SUPPORTED
-/* Grab an unsigned 32-bit integer from a buffer in big endian format. */
+/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */
 png_uint_32
 png_get_uint_32(png_bytep buf)
 {
-   png_uint_32 i;
-
-   i = ((png_uint_32)(*buf) << 24) +
+   png_uint_32 i = ((png_uint_32)(*buf) << 24) +
       ((png_uint_32)(*(buf + 1)) << 16) +
       ((png_uint_32)(*(buf + 2)) << 8) +
       (png_uint_32)(*(buf + 3));
@@ -31,15 +28,13 @@ png_get_uint_32(png_bytep buf)
 }
 
 #if defined(PNG_READ_pCAL_SUPPORTED)
-/* Grab a signed 32-bit integer from a buffer in big endian format.  The
+/* Grab a signed 32-bit integer from a buffer in big-endian format.  The
  * data is stored in the PNG file in two's complement format, and it is
  * assumed that the machine format for signed integers is the same. */
 png_int_32
 png_get_int_32(png_bytep buf)
 {
-   png_int_32 i;
-
-   i = ((png_int_32)(*buf) << 24) +
+   png_int_32 i = ((png_int_32)(*buf) << 24) +
       ((png_int_32)(*(buf + 1)) << 16) +
       ((png_int_32)(*(buf + 2)) << 8) +
       (png_int_32)(*(buf + 3));
@@ -48,13 +43,11 @@ png_get_int_32(png_bytep buf)
 }
 #endif /* PNG_READ_pCAL_SUPPORTED */
 
-/* Grab an unsigned 16-bit integer from a buffer in big endian format. */
+/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */
 png_uint_16
 png_get_uint_16(png_bytep buf)
 {
-   png_uint_16 i;
-
-   i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
+   png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
       (png_uint_16)(*(buf + 1)));
 
    return (i);
@@ -76,15 +69,16 @@ png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
 int
 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
 {
-   png_uint_32 i;
+   png_size_t i;
+   png_size_t istop = png_ptr->zbuf_size;
 
-   for (i = skip; i > (png_uint_32)png_ptr->zbuf_size; i -= png_ptr->zbuf_size)
+   for (i = (png_size_t)skip; i > istop; i -= istop)
    {
       png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
    }
    if (i)
    {
-      png_crc_read(png_ptr, png_ptr->zbuf, (png_size_t)i);
+      png_crc_read(png_ptr, png_ptr->zbuf, i);
    }
 
    if (png_crc_error(png_ptr))
@@ -258,20 +252,6 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
    png_ptr->mode |= PNG_HAVE_PLTE;
 
-#if defined (PNG_READ_tRNS_SUPPORTED)
-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-   {
-      if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
-      {
-         if (png_ptr->num_trans > png_ptr->num_palette)
-         {
-            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
-            png_ptr->num_trans = png_ptr->num_palette;
-         }
-      }
-   }
-#endif
-
 #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
    if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
    {
@@ -349,6 +329,21 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
    png_ptr->palette = palette;
    png_ptr->num_palette = (png_uint_16)num;
    png_set_PLTE(png_ptr, info_ptr, palette, num);
+
+#if defined (PNG_READ_tRNS_SUPPORTED)
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
+      {
+         if (png_ptr->num_trans > png_ptr->num_palette)
+         {
+            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
+            png_ptr->num_trans = png_ptr->num_palette;
+         }
+      }
+   }
+#endif
+
 }
 
 void
@@ -758,6 +753,12 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
          png_crc_finish(png_ptr, length);
          return;
       }
+      if (length == 0)
+      {
+         png_warning(png_ptr, "Zero length tRNS chunk");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
 
       png_ptr->trans = (png_bytep)png_malloc(png_ptr, length);
       png_ptr->flags |= PNG_FLAG_FREE_TRANS;
@@ -1075,8 +1076,8 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
    purpose[slength] = 0x00; /* null terminate the last string */
 
    png_debug(3, "Finding end of pCAL purpose string\n");
-   for (buf = purpose; *buf != '\0'; buf++)
-      /* empty loop */;
+   for (buf = purpose; *buf; buf++)
+      /* empty loop */ ;
 
    endptr = purpose + slength;
 
@@ -1113,8 +1114,8 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
       png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
    }
 
-   /* Empty loop to move past the units string. */
-   for (buf = units; *buf != 0x00; buf++);
+   for (buf = units; *buf; buf++)
+      /* Empty loop to move past the units string. */ ;
 
    png_debug(3, "Allocating pCAL parameters array\n");
    params = (png_charpp)png_malloc(png_ptr, (png_uint_32)(nparams
@@ -1126,8 +1127,8 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
       buf++; /* Skip the null string terminator from previous parameter. */
 
       png_debug1(3, "Reading pCAL parameter %d\n", i);
-      /* Empty loop to move past each paramter string */
-      for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++);
+      for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++)
+         /* Empty loop to move past each parameter string */ ;
 
       /* Make sure we haven't run out of data yet */
       if (buf > endptr)
@@ -1465,13 +1466,13 @@ png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
    }
 }
 
-/* Combines the row recently read in with the previous row.
-   This routine takes care of alpha and transparency if requested.
+/* Combines the row recently read in with the existing pixels in the
+   row.  This routine takes care of alpha and transparency if requested.
    This routine also handles the two methods of progressive display
    of interlaced images, depending on the mask value.
    The mask value describes which pixels are to be combined with
    the row.  The pattern always repeats every 8 pixels, so just 8
-   bits are needed.  A one indicates the pixels is to be combined,
+   bits are needed.  A one indicates the pixel is to be combined,
    a zero indicates the pixel is to be skipped.  This is in addition
    to any alpha or transparency value associated with the pixel.  If
    you want all pixels to be combined, pass 0xff (255) in mask.  */
@@ -1492,16 +1493,14 @@ png_combine_row(png_structp png_ptr, png_bytep row,
       {
          case 1:
          {
-            png_bytep sp;
-            png_bytep dp;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
             int s_inc, s_start, s_end;
-            int m;
+            int m = 0x80;
             int shift;
             png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
 
-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {
@@ -1519,7 +1518,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
 
             shift = s_start;
 
-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)
             {
                if (m & mask)
                {
@@ -1548,17 +1547,15 @@ png_combine_row(png_structp png_ptr, png_bytep row,
          }
          case 2:
          {
-            png_bytep sp;
-            png_bytep dp;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
             int s_start, s_end, s_inc;
-            int m;
+            int m = 0x80;
             int shift;
             png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
             int value;
 
-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {
@@ -1576,7 +1573,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
 
             shift = s_start;
 
-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)
             {
                if (m & mask)
                {
@@ -1602,17 +1599,15 @@ png_combine_row(png_structp png_ptr, png_bytep row,
          }
          case 4:
          {
-            png_bytep sp;
-            png_bytep dp;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
             int s_start, s_end, s_inc;
-            int m;
+            int m = 0x80;
             int shift;
             png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
             int value;
 
-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {
@@ -1629,7 +1624,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
             }
             shift = s_start;
 
-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)
             {
                if (m & mask)
                {
@@ -1655,18 +1650,15 @@ png_combine_row(png_structp png_ptr, png_bytep row,
          }
          default:
          {
-            png_bytep sp;
-            png_bytep dp;
-            png_size_t pixel_bytes;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
+            png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
             png_uint_32 i;
-            png_byte m;
+            png_uint_32 row_width = png_ptr->width;
+            png_byte m = 0x80;
 
-            pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 
-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;
-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)
             {
                if (m & mask)
                {
@@ -1703,15 +1695,15 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
       {
          case 1:
          {
-            png_bytep sp, dp;
+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);
+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);
             int sshift, dshift;
             int s_start, s_end, s_inc;
+            int jstop = png_pass_inc[pass];
             png_byte v;
             png_uint_32 i;
             int j;
 
-            sp = row + (png_size_t)((row_info->width - 1) >> 3);
-            dp = row + (png_size_t)((final_width - 1) >> 3);
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {
@@ -1731,10 +1723,10 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
                 s_inc = 1;
             }
 
-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)
             {
                v = (png_byte)((*sp >> sshift) & 0x1);
-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)
                {
                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);
@@ -1758,13 +1750,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
          }
          case 2:
          {
-            png_bytep sp, dp;
+            png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);
+            png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);
             int sshift, dshift;
             int s_start, s_end, s_inc;
+            int jstop = png_pass_inc[pass];
             png_uint_32 i;
 
-            sp = row + (png_uint_32)((row_info->width - 1) >> 2);
-            dp = row + (png_uint_32)((final_width - 1) >> 2);
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {
@@ -1784,13 +1776,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
                s_inc = 2;
             }
 
-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)
             {
                png_byte v;
                int j;
 
                v = (png_byte)((*sp >> sshift) & 0x3);
-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)
                {
                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);
@@ -1814,13 +1806,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
          }
          case 4:
          {
-            png_bytep sp, dp;
+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);
+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);
             int sshift, dshift;
             int s_start, s_end, s_inc;
             png_uint_32 i;
+            int jstop = png_pass_inc[pass];
 
-            sp = row + (png_size_t)((row_info->width - 1) >> 1);
-            dp = row + (png_size_t)((final_width - 1) >> 1);
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {
@@ -1840,13 +1832,12 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
                s_inc = 4;
             }
 
-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)
             {
-               png_byte v;
+               png_byte v = (png_byte)((*sp >> sshift) & 0xf);
                int j;
 
-               v = (png_byte)((*sp >> sshift) & 0xf);
-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)
                {
                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);
@@ -1870,21 +1861,19 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
          }
          default:
          {
-            png_bytep sp, dp;
+            png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
+            png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
+            png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
+            int jstop = png_pass_inc[pass];
             png_uint_32 i;
-            png_size_t pixel_bytes;
 
-            pixel_bytes = (row_info->pixel_depth >> 3);
-
-            sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
-            dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)
             {
                png_byte v[8];
                int j;
 
                png_memcpy(v, sp, pixel_bytes);
-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)
                {
                   png_memcpy(dp, v, pixel_bytes);
                   dp -= pixel_bytes;
@@ -1901,6 +1890,7 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
 }
 #endif
 
+#ifndef PNG_READ_SLOW_FILTERING
 void
 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
    png_bytep prev_row, int filter)
@@ -1916,11 +1906,134 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
       case PNG_FILTER_VALUE_SUB:
       {
          png_uint_32 i;
-         int bpp;
+         png_uint_32 istop = row_info->rowbytes;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) / 8;
+         png_bytep rp = row + bpp;
+         png_bytep lp = row;
+
+         for (i = bpp; i < istop; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      case PNG_FILTER_VALUE_UP:
+      {
+         png_uint_32 i;
+         png_uint_32 istop = row_info->rowbytes;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+
+         for (i = 0; i < istop; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      case PNG_FILTER_VALUE_AVG:
+      {
+         png_uint_32 i;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+         png_bytep lp = row;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) / 8;
+         png_uint_32 istop = row_info->rowbytes - bpp;
+
+         for (i = 0; i < bpp; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) +
+               ((int)(*pp++) / 2)) & 0xff);
+            rp++;
+         }
+        
+         for (i = 0; i < istop; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) +
+               (int)(*pp++ + *lp++) / 2) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      case PNG_FILTER_VALUE_PAETH:
+      {
+         png_uint_32 i;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+         png_bytep lp = row;
+         png_bytep cp = prev_row;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) / 8;
+         png_uint_32 istop=row_info->rowbytes - bpp;
+
+         for (i = 0; i < bpp; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+            rp++;
+         }
+
+         for (i = 0; i < istop; i++)   /* use leftover rp,pp */
+         {
+            int a, b, c, pa, pb, pc, p;
+
+            a = *lp++;
+            b = *pp++;
+            c = *cp++;
+
+            p = b - c;
+            pc = a - c;
+
+#ifdef PNG_USE_ABS
+            pa = abs(p);
+            pb = abs(pc);
+            pc = abs(p + pc);
+#else
+            pa = p < 0 ? -p : p;
+            pb = pc < 0 ? -pc : pc;
+            pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+            /*
+               if (pa <= pb && pa <= pc)
+                  p = a;
+               else if (pb <= pc)
+                  p = b;
+               else
+                  p = c;
+             */
+
+            p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+
+            *rp = (png_byte)(((int)(*rp) + p) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      default:
+         png_error(png_ptr, "Bad adaptive filter type");
+         break;
+   }
+}
+#else /* PNG_READ_SLOW_FILTERING */
+void
+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
+   png_bytep prev_row, int filter)
+{
+   png_debug(1, "in png_read_filter_row\n");
+   png_debug2(2,"row = %d, filter = %d\n", png_ptr->row_number, filter);
+
+
+   switch (filter)
+   {
+      case PNG_FILTER_VALUE_NONE:
+         break;
+      case PNG_FILTER_VALUE_SUB:
+      {
+         png_uint_32 i;
+         int bpp = (row_info->pixel_depth + 7) / 8;
          png_bytep rp;
          png_bytep lp;
 
-         bpp = (row_info->pixel_depth + 7) / 8;
          for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
             i < row_info->rowbytes; i++, rp++, lp++)
          {
@@ -1944,12 +2057,11 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
       case PNG_FILTER_VALUE_AVG:
       {
          png_uint_32 i;
-         int bpp;
+         int bpp = (row_info->pixel_depth + 7) / 8;
          png_bytep rp;
          png_bytep pp;
          png_bytep lp;
 
-         bpp = (row_info->pixel_depth + 7) / 8;
          for (i = 0, rp = row, pp = prev_row;
             i < (png_uint_32)bpp; i++, rp++, pp++)
          {
@@ -1965,14 +2077,13 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
       }
       case PNG_FILTER_VALUE_PAETH:
       {
-         int bpp;
+         int bpp = (row_info->pixel_depth + 7) / 8;
          png_uint_32 i;
          png_bytep rp;
          png_bytep pp;
          png_bytep lp;
          png_bytep cp;
 
-         bpp = (row_info->pixel_depth + 7) / 8;
          for (i = 0, rp = row, pp = prev_row,
             lp = row - bpp, cp = prev_row - bpp;
             i < row_info->rowbytes; i++, rp++, pp++, lp++, cp++)
@@ -2010,6 +2121,7 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
          break;
    }
 }
+#endif /* PNG_READ_SLOW_FILTERING */
 
 void
 png_read_finish_row(png_structp png_ptr)
@@ -2044,7 +2156,7 @@ png_read_finish_row(png_structp png_ptr)
             if (!(png_ptr->num_rows))
                continue;
          }
-         if (png_ptr->transformations & PNG_INTERLACE)
+         else  /* if (png_ptr->transformations & PNG_INTERLACE) */
             break;
       } while (png_ptr->iwidth == 0);
 
@@ -2118,7 +2230,7 @@ void
 png_read_start_row(png_structp png_ptr)
 {
    int max_pixel_depth;
-   png_uint_32 rowbytes;
+   png_uint_32 row_bytes;
 
    png_debug(1, "in png_read_start_row\n");
    png_ptr->zstream.avail_in = 0;
@@ -2136,10 +2248,10 @@ png_read_start_row(png_structp png_ptr)
          png_pass_start[png_ptr->pass]) /
          png_pass_inc[png_ptr->pass];
 
-         rowbytes = ((png_ptr->iwidth *
+         row_bytes = ((png_ptr->iwidth *
             (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1;
-         png_ptr->irowbytes = (png_size_t)rowbytes;
-         if((png_uint_32)png_ptr->irowbytes != rowbytes)
+         png_ptr->irowbytes = (png_size_t)row_bytes;
+         if((png_uint_32)png_ptr->irowbytes != row_bytes)
             png_error(png_ptr, "Rowbytes overflow in png_read_start_row");
    }
    else
@@ -2186,8 +2298,22 @@ png_read_start_row(png_structp png_ptr)
 #if defined(PNG_READ_FILLER_SUPPORTED)
    if (png_ptr->transformations & (PNG_FILLER))
    {
-      if (max_pixel_depth < 32)
+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
          max_pixel_depth = 32;
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         if (max_pixel_depth <= 8)
+            max_pixel_depth = 16;
+         else
+            max_pixel_depth = 32;
+      }
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+      {
+         if (max_pixel_depth <= 32)
+            max_pixel_depth = 32;
+         else
+            max_pixel_depth = 64;
+      }
    }
 #endif
 
@@ -2214,16 +2340,16 @@ png_read_start_row(png_structp png_ptr)
 
    /* align the width on the next larger 8 pixels.  Mainly used
       for interlacing */
-   rowbytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
+   row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
    /* calculate the maximum bytes needed, adding a byte and a pixel
-      for safety sake */
-   rowbytes = ((rowbytes * (png_uint_32)max_pixel_depth + 7) >> 3) +
+      for safety's sake */
+   row_bytes = ((row_bytes * (png_uint_32)max_pixel_depth + 7) >> 3) +
       1 + ((max_pixel_depth + 7) >> 3);
 #ifdef PNG_MAX_MALLOC_64K
-   if (rowbytes > (png_uint_32)65536L)
+   if (row_bytes > (png_uint_32)65536L)
       png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
-   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, rowbytes);
+   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, row_bytes);
 
 #ifdef PNG_MAX_MALLOC_64K
    if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)

pngset.c

@@ -1,12 +1,11 @@
 
 /* pngset.c - storage of image information into info struct
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
  * The functions here are used during reads to store data from the file
  * into the info struct, and during writes to store application data
@@ -108,13 +107,14 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
 
    /* check for overflow */
    rowbytes_per_pixel = (info_ptr->pixel_depth + 7) >> 3;
-   info_ptr->rowbytes = info_ptr->width * rowbytes_per_pixel;
    if (( width > (png_uint_32)2147483647L/rowbytes_per_pixel))
    {
       png_warning(png_ptr,
          "Width too large to process image data; rowbytes will overflow.");
       info_ptr->rowbytes = (png_size_t)0;
    }
+   else
+      info_ptr->rowbytes = (info_ptr->width * info_ptr->pixel_depth + 7) >> 3;
 }
 
 #if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)

pngtest.c

@@ -1,12 +1,11 @@
 
 /* pngtest.c - a simple test program to test libpng
  *
- * libpng 1.0.0
+ * libpng 1.0.2 -June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
  * This program reads in a PNG image, writes it out again, and then
  * compares the two files.  If the files are identical, this shows that
@@ -14,9 +13,9 @@
  * properly.  It does not currently test all of the transforms, although
  * it probably should.
  *
- * The program will fail in certain legitimate cases:
+ * The program will report "FAIL" in certain legitimate cases:
  * 1) when the compression level or filter selection method is changed.
- * 2) when the chunk size is smaller than 8K.
+ * 2) when the chunk size is not 8K.
  * 3) unknown ancillary chunks exist in the input file.
  * 4) others not listed here...
  * In these cases, it is best to check with another tool such as "pngcheck"
@@ -24,7 +23,8 @@
  *
  * If a filename is given on the command-line, then this file is used
  * for the input, rather than the default "pngtest.png".  This allows
- * testing a wide variety of files easily.
+ * testing a wide variety of files easily.  You can also test a number
+ * of files at once by typing "pngtest -m file1.png file2.png ..."
  */
 
 #include <stdio.h>
@@ -37,6 +37,11 @@
 
 #include "png.h"
 
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+static int tIME_chunk_present=0;
+static char tIME_string[30] = "no tIME chunk present in file";
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
 int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
 
 #ifdef __TURBOC__
@@ -81,12 +86,12 @@ write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
 
 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 /* example of using user transform callback (we don't transform anything,
-   but merely count the black pixels) */
+   but merely count the zero samples) */
 
-static png_uint_32 black_pixels;
+static png_uint_32 zero_samples;
 
 void
-count_black_pixels(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
 {
    png_bytep dp = data;
    if(png_ptr == NULL)return; 
@@ -100,60 +105,66 @@ count_black_pixels(png_structp png_ptr, png_row_infop row_info, png_bytep data)
     *  png_byte pixel_depth   bits per pixel (depth*channels)
     */
 
-    /* counts the number of black pixels (or zero pixels if color_type is 3 */
+    /* counts the number of zero samples (or zero pixels if color_type is 3 */
 
     if(row_info->color_type == 0 || row_info->color_type == 3)
     {
        int pos=0;
-       png_uint_32 n;
-       for (n=0; n<row_info->width; n++)
+       png_uint_32 n, nstop;
+       for (n=0, nstop=row_info->width; n<nstop; n++)
        {
           if(row_info->bit_depth == 1)
-             if(((*dp << pos++ )& 0x80) == 0) black_pixels++;
+          {
+             if(((*dp << pos++ )& 0x80) == 0) zero_samples++;
              if(pos == 8)
              {
-                pos=0;
+                pos = 0;
                 dp++;
              }
+          }
           if(row_info->bit_depth == 2)
-             if(((*dp << (pos+=2))& 0xc0) == 0) black_pixels++;
+          {
+             if(((*dp << (pos+=2))& 0xc0) == 0) zero_samples++;
              if(pos == 8)
              {
-                pos=0;
+                pos = 0;
                 dp++;
              }
+          }
           if(row_info->bit_depth == 4)
-             if(((*dp << (pos+=4))& 0xf0) == 0) black_pixels++;
+          {
+             if(((*dp << (pos+=4))& 0xf0) == 0) zero_samples++;
              if(pos == 8)
              {
-                pos=0;
+                pos = 0;
                 dp++;
              }
+          }
           if(row_info->bit_depth == 8)
-             if(*dp++ == 0) black_pixels++;
+             if(*dp++ == 0) zero_samples++;
           if(row_info->bit_depth == 16)
           {
-             if((*dp | *(dp+1)) == 0) black_pixels++;
+             if((*dp | *(dp+1)) == 0) zero_samples++;
              dp+=2;
           }
        }
     }
     else /* other color types */
     {
-       png_uint_32 n;
+       png_uint_32 n, nstop;
        int channel;
        int color_channels = row_info->channels;
        if(row_info->color_type > 3)color_channels--;
 
-       for (n=0; n<row_info->width; n++)
+       for (n=0, nstop=row_info->width; n<nstop; n++)
        {
           for (channel = 0; channel < color_channels; channel++)
           {
              if(row_info->bit_depth == 8)
-                if(*dp++ == 0) black_pixels++;
+                if(*dp++ == 0) zero_samples++;
              if(row_info->bit_depth == 16)
              {
-                if((*dp | *(dp+1)) == 0) black_pixels++;
+                if((*dp | *(dp+1)) == 0) zero_samples++;
                 dp+=2;
              }
           }
@@ -174,7 +185,7 @@ static int wrote_question = 0;
 /* START of code to validate stdio-free compilation */
 /* These copies of the default read/write functions come from pngrio.c and */
 /* pngwio.c.  They allow "don't include stdio" testing of the library. */
-/* This is the function which does the actual reading of data.  If you are
+/* This is the function that does the actual reading of data.  If you are
    not reading from a standard C stream, you should create a replacement
    read_data function and use it at run time with png_set_read_fn(), rather
    than changing the library. */
@@ -256,7 +267,7 @@ png_default_flush(png_structp png_ptr)
 }
 #endif
 
-/* This is the function which does the actual writing of data.  If you are
+/* This is the function that does the actual writing of data.  If you are
    not writing to a standard C stream, you should create a replacement
    write_data function and use it at run time with png_set_write_fn(), rather
    than changing the library. */
@@ -346,18 +357,14 @@ static void
 png_default_error(png_structp png_ptr, png_const_charp message)
 {
    png_default_warning(png_ptr, message);
-   /* We can return because png_error calls the default handler which is
-    * actually ok in this case. */
+   /* We can return because png_error calls the default handler, which is
+    * actually OK in this case. */
 }
 #endif /* PNG_NO_STDIO */
 /* END of code to validate stdio-free compilation */
 
 /* START of code to validate memory allocation and deallocation */
-#ifdef PNGTEST_MEMORY_DEBUG
-/* Borland DOS special memory handler */
-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
-ERROR - memory debugging is not supported on this platform
-#else
+#ifdef PNG_USER_MEM_SUPPORTED
 
 /* Allocate memory.  For reasonable files, size should never exceed
    64K.  However, zlib may allocate more then 64K if you don't tell
@@ -369,7 +376,7 @@ ERROR - memory debugging is not supported on this platform
    by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */
 typedef struct memory_information {
    png_uint_32                    size;
-   png_voidp                      pointer;
+   png_voidp                 pointer;
    struct memory_information FAR *next;
 } memory_information;
 typedef memory_information FAR *memory_infop;
@@ -384,23 +391,23 @@ extern PNG_EXPORT(void,png_debug_free) PNGARG((png_structp png_ptr,
    png_voidp ptr));
 
 png_voidp
-png_malloc(png_structp png_ptr, png_uint_32 size) {
-   if (png_ptr == NULL) {
-      fprintf(STDERR, "NULL pointer to memory allocator\n");
-      return (NULL);
-   }
+png_debug_malloc(png_structp png_ptr, png_uint_32 size) {
+
+   /* png_malloc has already tested for NULL; png_create_struct calls
+      png_debug_malloc directly, with png_ptr == NULL which is OK */
+
    if (size == 0)
       return (png_voidp)(NULL);
 
    /* This calls the library allocator twice, once to get the requested
       buffer and once to get a new free list entry. */
    {
-      memory_infop pinfo = png_debug_malloc(png_ptr, sizeof *pinfo);
+      memory_infop pinfo = png_malloc_default(png_ptr, sizeof *pinfo);
       pinfo->size = size;
       current_allocation += size;
       if (current_allocation > maximum_allocation)
          maximum_allocation = current_allocation;
-      pinfo->pointer = png_debug_malloc(png_ptr, size);
+      pinfo->pointer = png_malloc_default(png_ptr, size);
       pinfo->next = pinformation;
       pinformation = pinfo;
       /* Make sure the caller isn't assuming zeroed memory. */
@@ -411,10 +418,10 @@ png_malloc(png_structp png_ptr, png_uint_32 size) {
 
 /* Free a pointer.  It is removed from the list at the same time. */
 void
-png_free(png_structp png_ptr, png_voidp ptr)
+png_debug_free(png_structp png_ptr, png_voidp ptr)
 {
    if (png_ptr == NULL)
-      fprintf(STDERR, "NULL pointer to memory allocator\n");
+      fprintf(STDERR, "NULL pointer to png_debug_free.\n");
    if (ptr == 0) {
 #if 0 /* This happens all the time. */
       fprintf(STDERR, "WARNING: freeing NULL pointer\n");
@@ -433,9 +440,9 @@ png_free(png_structp png_ptr, png_voidp ptr)
             if (current_allocation < 0)
                fprintf(STDERR, "Duplicate free of memory\n");
             /* We must free the list element too, but first kill
-               the memory which is to be freed. */
+               the memory that is to be freed. */
             memset(ptr, 0x55, pinfo->size);
-            png_debug_free(png_ptr, pinfo);
+            png_free_default(png_ptr, pinfo);
             break;
          }
          if (pinfo->next == NULL) {
@@ -447,10 +454,9 @@ png_free(png_structp png_ptr, png_voidp ptr)
    }
 
    /* Finally free the data. */
-   png_debug_free(png_ptr, ptr);
+   png_free_default(png_ptr, ptr);
 }
-#endif /* Not Borland DOS special memory handler */
-#endif
+#endif /* PNG_USER_MEM_SUPPORTED */
 /* END of code to test memory allocation/deallocation */
 
 /* Test one file */
@@ -487,14 +493,26 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
    }
 
    png_debug(0, "Allocating read and write structures\n");
+#ifdef PNG_USER_MEM_SUPPORTED
+   read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
+      (png_error_ptr)NULL, (png_error_ptr)NULL, (png_voidp)NULL,
+      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
+#else
    read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
       (png_error_ptr)NULL, (png_error_ptr)NULL);
+#endif
 #if defined(PNG_NO_STDIO)
    png_set_error_fn(read_ptr, (png_voidp)inname, png_default_error,
        png_default_warning);
 #endif
+#ifdef PNG_USER_MEM_SUPPORTED
+   write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
+      (png_error_ptr)NULL, (png_error_ptr)NULL, (png_voidp)NULL,
+      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
+#else
    write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
       (png_error_ptr)NULL, (png_error_ptr)NULL);
+#endif
 #if defined(PNG_NO_STDIO)
    png_set_error_fn(write_ptr, (png_voidp)inname, png_default_error,
        png_default_warning);
@@ -503,6 +521,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
    read_info_ptr = png_create_info_struct(read_ptr);
    write_info_ptr = png_create_info_struct(write_ptr);
    end_info_ptr = png_create_info_struct(read_ptr);
+#ifdef PNG_USER_MEM_SUPPORTED
+#endif
 
    png_debug(0, "Setting jmpbuf for read struct\n");
 #ifdef USE_FAR_KEYWORD
@@ -563,8 +583,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
    }
 
 #  if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-     black_pixels=0;
-     png_set_write_user_transform_fn(write_ptr, count_black_pixels);
+     zero_samples=0;
+     png_set_write_user_transform_fn(write_ptr, count_zero_samples);
 #  endif
 
    png_debug(0, "Reading info struct\n");
@@ -714,6 +734,15 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
       {
          png_set_tIME(write_ptr, write_info_ptr, mod_time);
       }
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+      {
+         /* we have to use png_strcpy instead of "=" because the string
+            pointed to by png_convert_to_rfc1123() gets free'ed before
+            we use it */
+         png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time));
+         tIME_chunk_present++;
+      }
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
    }
 #endif
 #if defined(PNG_READ_tRNS_SUPPORTED) && defined(PNG_WRITE_tRNS_SUPPORTED)
@@ -938,7 +967,7 @@ main(int argc, char *argv[])
    if (multiple)
    {
       int i;
-#ifdef PNGTEST_MEMORY_DEBUG
+#ifdef PNG_USER_MEM_SUPPORTED
       int allocation_now = current_allocation;
 #endif
       for (i=2; i<argc; ++i)
@@ -947,16 +976,24 @@ main(int argc, char *argv[])
          fprintf(STDERR, "Testing %s:",argv[i]);
          kerror = test_one_file(argv[i], outname);
          if (kerror == 0) 
+         {
 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-            fprintf(STDERR, " PASS (%lu black pixels)\n",black_pixels);
+            fprintf(STDERR, " PASS (%lu zero samples)\n",zero_samples);
 #else
             fprintf(STDERR, " PASS\n");
-#endif
-         else {
+#endif 
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+         if(tIME_chunk_present != 0)
+            fprintf(STDERR, " tIME = %s\n",tIME_string);
+         tIME_chunk_present = 0;
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+         }
+         else
+         {
             fprintf(STDERR, " FAIL\n");
             ierror += kerror;
-            }
-#ifdef PNGTEST_MEMORY_DEBUG
+         }
+#ifdef PNG_USER_MEM_SUPPORTED
          if (allocation_now != current_allocation)
             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
                current_allocation-allocation_now);
@@ -972,7 +1009,7 @@ main(int argc, char *argv[])
          }
 #endif
       }
-#ifdef PNGTEST_MEMORY_DEBUG
+#ifdef PNG_USER_MEM_SUPPORTED
          fprintf(STDERR, "Maximum memory allocation: %d bytes\n",
             maximum_allocation);
 #endif
@@ -982,7 +1019,7 @@ main(int argc, char *argv[])
       int i;
       for (i=0; i<3; ++i) {
          int kerror;
-#ifdef PNGTEST_MEMORY_DEBUG
+#ifdef PNG_USER_MEM_SUPPORTED
          int allocation_now = current_allocation;
 #endif
          if (i == 1) status_dots_requested = 1;
@@ -993,11 +1030,17 @@ main(int argc, char *argv[])
          if(kerror == 0)
          {
             if(verbose == 1 || i == 2)
+            {
 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-                fprintf(STDERR, " PASS (%lu black pixels)\n",black_pixels);
+                fprintf(STDERR, " PASS (%lu zero samples)\n",zero_samples);
 #else
                 fprintf(STDERR, " PASS\n");
 #endif
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+         if(tIME_chunk_present != 0)
+            fprintf(STDERR, " tIME = %s\n",tIME_string);
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+            }
          }
          else
          {
@@ -1006,7 +1049,7 @@ main(int argc, char *argv[])
             fprintf(STDERR, " FAIL\n");
             ierror += kerror;
          }
-#ifdef PNGTEST_MEMORY_DEBUG
+#ifdef PNG_USER_MEM_SUPPORTED
          if (allocation_now != current_allocation)
              fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
                current_allocation-allocation_now);
@@ -1022,7 +1065,7 @@ main(int argc, char *argv[])
           }
 #endif
        }
-#ifdef PNGTEST_MEMORY_DEBUG
+#ifdef PNG_USER_MEM_SUPPORTED
        fprintf(STDERR, "Maximum memory allocation: %d bytes\n",
           maximum_allocation);
 #endif
@@ -1034,3 +1077,4 @@ main(int argc, char *argv[])
       fprintf(STDERR, "libpng FAILS test\n");
    return (int)(ierror != 0);
 }
+

pngtrans.c

@@ -1,12 +1,11 @@
 
 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 #define PNG_INTERNAL
@@ -87,8 +86,8 @@ png_set_interlace_handling(png_structp png_ptr)
 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
 /* Add a filler byte on read, or remove a filler or alpha byte on write.
  * The filler type has changed in v0.95 to allow future 2-byte fillers
- * for 48-bit input data, as well as avoiding problems with some compilers
- * which don't like bytes as parameters.
+ * for 48-bit input data, as well as to avoid problems with some compilers
+ * that don't like bytes as parameters.
  */
 void
 png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
@@ -100,12 +99,6 @@ png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
    else
       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
-
-   /* This should probably go in the "do_filler" routine */
-   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB && png_ptr->bit_depth == 8)
-   {
-      png_ptr->usr_channels = 4;
-   }
 }
 #endif
 
@@ -137,7 +130,7 @@ png_set_invert_mono(png_structp png_ptr)
    png_ptr->transformations |= PNG_INVERT_MONO;
 }
 
-/* invert monocrome grayscale data */
+/* invert monochrome grayscale data */
 void
 png_do_invert(png_row_infop row_info, png_bytep row)
 {
@@ -148,12 +141,14 @@ png_do_invert(png_row_infop row_info, png_bytep row)
 #endif
        row_info->color_type == PNG_COLOR_TYPE_GRAY)
    {
-      png_bytep rp;
+      png_bytep rp = row;
       png_uint_32 i;
+      png_uint_32 istop = row_info->rowbytes;
 
-      for (i = 0, rp = row; i < row_info->rowbytes; i++, rp++)
+      for (i = 0; i < istop; i++)
       {
          *rp = (png_byte)(~(*rp));
+         rp++;
       }
    }
 }
@@ -171,15 +166,13 @@ png_do_swap(png_row_infop row_info, png_bytep row)
 #endif
        row_info->bit_depth == 16)
    {
-      png_bytep rp;
-      png_byte t;
+      png_bytep rp = row;
       png_uint_32 i;
+      png_uint_32 istop= row_info->width * row_info->channels;
 
-      for (i = 0, rp = row;
-         i < row_info->width * row_info->channels;
-         i++, rp += 2)
+      for (i = 0; i < istop; i++, rp += 2)
       {
-         t = *rp;
+         png_byte t = *rp;
          *rp = *(rp + 1);
          *(rp + 1) = t;
       }
@@ -338,6 +331,11 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
       if (row_info->color_type == PNG_COLOR_TYPE_RGB ||
           row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 */
+      png_bytep sp=row;
+      png_bytep dp=row;
+      png_uint_32 row_width=row_info->width;
+      png_uint_32 i;
+
       if (row_info->channels == 4)
       {
          if (row_info->bit_depth == 8)
@@ -345,10 +343,8 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
             /* This converts from RGBX or RGBA to RGB */
             if (flags & PNG_FLAG_FILLER_AFTER)
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
-               for (i = 1, sp = row + 4, dp = row + 3; i < row_info->width; i++)
+               dp+=3; sp+=4;
+               for (i = 1; i < row_width; i++)
                {
                   *dp++ = *sp++;
                   *dp++ = *sp++;
@@ -359,10 +355,7 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
             /* This converts from XRGB or ARGB to RGB */
             else
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
-               for (i = 0, sp = row, dp = row; i < row_info->width; i++)
+               for (i = 0; i < row_width; i++)
                {
                   sp++;
                   *dp++ = *sp++;
@@ -371,17 +364,15 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
                }
             }
             row_info->pixel_depth = 24;
-            row_info->rowbytes = row_info->width * 3;
+            row_info->rowbytes = row_width * 3;
          }
          else /* if (row_info->bit_depth == 16) */
          {
             if (flags & PNG_FLAG_FILLER_AFTER)
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
                /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
-               for (i = 1, sp = row + 8, dp = row + 6; i < row_info->width; i++)
+               sp += 8; dp += 6;
+               for (i = 1; i < row_width; i++)
                {
                   /* This could be (although memcpy is probably slower):
                   png_memcpy(dp, sp, 6);
@@ -399,17 +390,15 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
             }
             else
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
                /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
-               for (i = 0, sp = row + 2, dp = row; i < row_info->width; i++)
+               for (i = 0; i < row_width; i++)
                {
                   /* This could be (although memcpy is probably slower):
                   png_memcpy(dp, sp, 6);
                   sp += 8;
                   dp += 6;
                   */
+                  sp+=2;
                   *dp++ = *sp++;
                   *dp++ = *sp++;
                   *dp++ = *sp++;
@@ -419,9 +408,10 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
                }
             }
             row_info->pixel_depth = 48;
-            row_info->rowbytes = row_info->width * 6;
+            row_info->rowbytes = row_width * 6;
          }
          row_info->channels = 3;
+         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
       }
 /*
       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY ||
@@ -434,10 +424,7 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
             /* This converts from GX or GA to G */
             if (flags & PNG_FLAG_FILLER_AFTER)
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
-               for (i = 1, sp = row + 2, dp = row + 1; i < row_info->width; i++)
+               for (i = 0; i < row_width; i++)
                {
                   *dp++ = *sp++;
                   sp++;
@@ -446,27 +433,22 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
             /* This converts from XG or AG to G */
             else
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
-               for (i = 0, sp = row, dp = row; i < row_info->width; i++)
+               for (i = 0; i < row_width; i++)
                {
                   sp++;
                   *dp++ = *sp++;
                }
             }
             row_info->pixel_depth = 8;
-            row_info->rowbytes = row_info->width;
+            row_info->rowbytes = row_width;
          }
          else /* if (row_info->bit_depth == 16) */
          {
             if (flags & PNG_FLAG_FILLER_AFTER)
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
                /* This converts from GGXX or GGAA to GG */
-               for (i = 1, sp = row + 4, dp = row + 2; i < row_info->width; i++)
+               sp += 4; dp += 2;
+               for (i = 1; i < row_width; i++)
                {
                   *dp++ = *sp++;
                   *dp++ = *sp++;
@@ -475,11 +457,8 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
             }
             else
             {
-               png_bytep sp, dp;
-               png_uint_32 i;
-
                /* This converts from XXGG or AAGG to GG */
-               for (i = 0, sp = row, dp = row; i < row_info->width; i++)
+               for (i = 0; i < row_width; i++)
                {
                   sp += 2;
                   *dp++ = *sp++;
@@ -487,9 +466,10 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
                }
             }
             row_info->pixel_depth = 16;
-            row_info->rowbytes = row_info->width * 2;
+            row_info->rowbytes = row_width * 2;
          }
          row_info->channels = 1;
+         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
       }
    }
 }
@@ -507,17 +487,17 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
 #endif
        (row_info->color_type & PNG_COLOR_MASK_COLOR))
    {
+      png_uint_32 row_width = row_info->width;
       if (row_info->bit_depth == 8)
       {
          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
          {
             png_bytep rp;
-            png_byte save;
             png_uint_32 i;
 
-            for (i = 0, rp = row; i < row_info->width; i++, rp += 3)
+            for (i = 0, rp = row; i < row_width; i++, rp += 3)
             {
-               save = *rp;
+               png_byte save = *rp;
                *rp = *(rp + 2);
                *(rp + 2) = save;
             }
@@ -525,12 +505,11 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
          {
             png_bytep rp;
-            png_byte save;
             png_uint_32 i;
 
-            for (i = 0, rp = row; i < row_info->width; i++, rp += 4)
+            for (i = 0, rp = row; i < row_width; i++, rp += 4)
             {
-               save = *rp;
+               png_byte save = *rp;
                *rp = *(rp + 2);
                *(rp + 2) = save;
             }
@@ -541,33 +520,31 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
          {
             png_bytep rp;
-            png_byte save[2];
             png_uint_32 i;
 
-            for (i = 0, rp = row; i < row_info->width; i++, rp += 6)
+            for (i = 0, rp = row; i < row_width; i++, rp += 6)
             {
-               save[0] = *rp;
-               save[1] = *(rp + 1);
+               png_byte save = *rp;
                *rp = *(rp + 4);
+               *(rp + 4) = save;
+               save = *(rp + 1);
                *(rp + 1) = *(rp + 5);
-               *(rp + 4) = save[0];
-               *(rp + 5) = save[1];
+               *(rp + 5) = save;
             }
          }
          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
          {
             png_bytep rp;
-            png_byte save[2];
             png_uint_32 i;
 
-            for (i = 0, rp = row; i < row_info->width; i++, rp += 8)
+            for (i = 0, rp = row; i < row_width; i++, rp += 8)
             {
-               save[0] = *rp;
-               save[1] = *(rp + 1);
+               png_byte save = *rp;
                *rp = *(rp + 4);
+               *(rp + 4) = save;
+               save = *(rp + 1);
                *(rp + 1) = *(rp + 5);
-               *(rp + 4) = save[0];
-               *(rp + 5) = save[1];
+               *(rp + 5) = save;
             }
          }
       }

pngwio.c

@@ -1,17 +1,16 @@
 
 /* pngwio.c - functions for data output
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  *
- * This file provides a location for all output.  Users which need
- * special handling are expected to write functions which have the same
- * arguments as these, and perform similar functions, but possibly use
- * different output methods.  Note that you shouldn't change these
+ * This file provides a location for all output.  Users who need
+ * special handling are expected to write functions that have the same
+ * arguments as these and perform similar functions, but that possibly
+ * use different output methods.  Note that you shouldn't change these
  * functions, but rather write replacement functions and then change
  * them at run time with png_set_write_fn(...).
  */
@@ -23,7 +22,7 @@
    writes to a file pointer.  Note that this routine sometimes gets called
    with very small lengths, so you should implement some kind of simple
    buffering if you are using unbuffered writes.  This should never be asked
-   to write more then 64K on a 16 bit machine.  */
+   to write more than 64K on a 16 bit machine.  */
 
 void
 png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@@ -35,7 +34,7 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 }
 
 #if !defined(PNG_NO_STDIO)
-/* This is the function which does the actual writing of data.  If you are
+/* This is the function that does the actual writing of data.  If you are
    not writing to a standard C stream, you should create a replacement
    write_data function and use it at run time with png_set_write_fn(), rather
    than changing the library. */
@@ -133,13 +132,13 @@ png_default_flush(png_structp png_ptr)
    png_ptr       - pointer to a png output data structure
    io_ptr        - pointer to user supplied structure containing info about
                    the output functions.  May be NULL.
-   write_data_fn - pointer to a new output function which takes as its
+   write_data_fn - pointer to a new output function that takes as its
                    arguments a pointer to a png_struct, a pointer to
-                   data to be written, and a 32-bit unsigned int which is
+                   data to be written, and a 32-bit unsigned int that is
                    the number of bytes to be written.  The new write
                    function should call png_error(png_ptr, "Error msg")
                    to exit and output any fatal error messages.
-   flush_data_fn - pointer to a new flush function which takes as its
+   flush_data_fn - pointer to a new flush function that takes as its
                    arguments a pointer to a png_struct.  After a call to
                    the flush function, there should be no data in any buffers
                    or pending transmission.  If the output method doesn't do
@@ -175,7 +174,14 @@ png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 
    /* It is an error to read while writing a png file */
-   png_ptr->read_data_fn = NULL;
+   if (png_ptr->read_data_fn != NULL)
+   {
+      png_ptr->read_data_fn = NULL;
+      png_warning(png_ptr,
+         "Attempted to set both read_data_fn and write_data_fn in");
+      png_warning(png_ptr,
+         "the same structure.  Resetting read_data_fn to NULL.");
+   }
 }
 
 #if defined(USE_FAR_KEYWORD) 

pngwrite.c

@@ -1,12 +1,11 @@
    
 /* pngwrite.c - general routines to write a PNG file
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 /* get internal access to png.h */
@@ -16,7 +15,7 @@
 /* Writes all the PNG information.  This is the suggested way to use the
  * library.  If you have a new chunk to add, make a function to write it,
  * and put it in the correct location here.  If you want the chunk written
- * after the image data, put it in png_write_end().  I strongly encurage
+ * after the image data, put it in png_write_end().  I strongly encourage
  * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
  * the chunk, as that will keep the code from breaking if you want to just
  * write a plain PNG file.  If you have long comments, I suggest writing
@@ -218,43 +217,6 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
    png_write_IEND(png_ptr);
 }
 
-#if defined(PNG_TIME_RFC1123_SUPPORTED)
-/* Convert the supplied time into an RFC 1123 string suitable for use in
- * a "Creation Time" or other text-based time string.
- */
-png_charp
-png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
-{
-   static PNG_CONST char short_months[12][4] =
-	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-	 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-
-   if (png_ptr->time_buffer == NULL)
-   {
-      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
-         sizeof(char)));
-   }
-
-#ifdef USE_FAR_KEYWORD
-   {
-      char near_time_buf[29];
-      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
-               ptime->day % 31, short_months[ptime->month],
-               ptime->year, ptime->hour % 24, ptime->minute % 60,
-               ptime->second % 61);
-      png_memcpy(png_ptr->time_buffer, near_time_buf,
-      29*sizeof(char));
-   }
-#else
-   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
-               ptime->day % 31, short_months[ptime->month],
-               ptime->year, ptime->hour % 24, ptime->minute % 60,
-               ptime->second % 61);
-#endif
-   return ((png_charp)png_ptr->time_buffer);
-}
-#endif /* PNG_TIME_RFC1123_SUPPORTED */
-
 #if defined(PNG_WRITE_tIME_SUPPORTED)
 void
 png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
@@ -281,15 +243,32 @@ png_convert_from_time_t(png_timep ptime, time_t ttime)
 
 /* Initialize png_ptr structure, and allocate any memory needed */
 png_structp
-png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
+png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
    png_error_ptr error_fn, png_error_ptr warn_fn)
 {
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
+      warn_fn, NULL, NULL, NULL));
+}
+
+/* Alternate initialize png_ptr structure, and allocate any memory needed */
+png_structp
+png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
    png_structp png_ptr;
 #ifdef USE_FAR_KEYWORD
    jmp_buf jmpbuf;
 #endif
    png_debug(1, "in png_create_write_struct\n");
+#ifdef PNG_USER_MEM_SUPPORTED
+   if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+      (png_malloc_ptr)malloc_fn)) == NULL)
+#else
    if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
+#endif /* PNG_USER_MEM_SUPPORTED */
    {
       return ((png_structp)NULL);
    }
@@ -306,6 +285,9 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
 #ifdef USE_FAR_KEYWORD
    png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
 #endif
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif /* PNG_USER_MEM_SUPPORTED */
    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
 
    /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
@@ -335,7 +317,6 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
    return ((png_structp)png_ptr);
 }
 
-
 /* Initialize png_ptr structure, and allocate any memory needed */
 void
 png_write_init(png_structp png_ptr)
@@ -422,6 +403,36 @@ png_write_row(png_structp png_ptr, png_bytep row)
    /* initialize transformations and other stuff if first time */
    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
    {
+   /* check for transforms that have been set but were defined out */
+#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
+   if (png_ptr->transformations & PNG_FILLER)
+      png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACK)
+      png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
+   if (png_ptr->transformations & PNG_BGR)
+      png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");
+#endif
+
       png_write_start_row(png_ptr);
    }
 
@@ -601,10 +612,18 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
 {
    png_structp png_ptr = NULL;
    png_infop info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn = NULL;
+#endif
 
    png_debug(1, "in png_destroy_write_struct\n");
    if (png_ptr_ptr != NULL)
+   {
       png_ptr = *png_ptr_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+      free_fn = png_ptr->free_fn;
+#endif
+   }
 
    if (info_ptr_ptr != NULL)
       info_ptr = *info_ptr_ptr;
@@ -627,14 +646,22 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
          png_free(png_ptr, info_ptr->pcal_params);
       }
 #endif
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, free_fn);
+#else
       png_destroy_struct((png_voidp)info_ptr);
+#endif
       *info_ptr_ptr = (png_infop)NULL;
    }
 
    if (png_ptr != NULL)
    {
       png_write_destroy(png_ptr);
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)png_ptr, free_fn);
+#else
       png_destroy_struct((png_voidp)png_ptr);
+#endif
       *png_ptr_ptr = (png_structp)NULL;
    }
 }
@@ -648,6 +675,9 @@ png_write_destroy(png_structp png_ptr)
    png_error_ptr error_fn;
    png_error_ptr warning_fn;
    png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn;
+#endif
 
    png_debug(1, "in png_write_destroy\n");
    /* free any memory zlib uses */
@@ -678,12 +708,18 @@ png_write_destroy(png_structp png_ptr)
    error_fn = png_ptr->error_fn;
    warning_fn = png_ptr->warning_fn;
    error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
 
    png_memset(png_ptr, 0, sizeof (png_struct));
 
    png_ptr->error_fn = error_fn;
    png_ptr->warning_fn = warning_fn;
    png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr->free_fn = free_fn;
+#endif
 
    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
 }
@@ -794,9 +830,7 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
    int num_weights, png_doublep filter_weights,
    png_doublep filter_costs)
 {
-#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
    int i;
-#endif
 
    png_debug(1, "in png_set_filter_heuristics\n");
    if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)

pngwtran.c

@@ -1,18 +1,17 @@
 
 /* pngwtran.c - transforms the data in a row for PNG writers
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 #define PNG_INTERNAL
 #include "png.h"
 
-/* Transform the data according to the users wishes.  The order of
+/* Transform the data according to the user's wishes.  The order of
  * transformations is significant.
  */
 void
@@ -97,12 +96,14 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
             png_bytep sp, dp;
             int mask, v;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
             sp = row;
             dp = row;
             mask = 0x80;
             v = 0;
-            for (i = 0; i < row_info->width; i++)
+           
+            for (i = 0; i < row_width; i++)
             {
                if (*sp != 0)
                   v |= mask;
@@ -126,12 +127,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
             png_bytep sp, dp;
             int shift, v;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
             sp = row;
             dp = row;
             shift = 6;
             v = 0;
-            for (i = 0; i < row_info->width; i++)
+            for (i = 0; i < row_width; i++)
             {
                png_byte value;
 
@@ -157,12 +159,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
             png_bytep sp, dp;
             int shift, v;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
             sp = row;
             dp = row;
             shift = 4;
             v = 0;
-            for (i = 0; i < row_info->width; i++)
+            for (i = 0; i < row_width; i++)
             {
                png_byte value;
 
@@ -214,9 +217,8 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
       row_info->color_type != PNG_COLOR_TYPE_PALETTE)
    {
       int shift_start[4], shift_dec[4];
-      png_uint_32 channels;
+      int channels = 0;
 
-      channels = 0;
       if (row_info->color_type & PNG_COLOR_MASK_COLOR)
       {
          shift_start[channels] = row_info->bit_depth - bit_depth->red;
@@ -245,9 +247,10 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
       /* with low row depths, could only be grayscale, so one channel */
       if (row_info->bit_depth < 8)
       {
-         png_bytep bp;
+         png_bytep bp = row;
          png_uint_32 i;
          png_byte mask;
+         png_uint_32 row_bytes = row_info->rowbytes;
 
          if (bit_depth->gray == 1 && row_info->bit_depth == 2)
             mask = 0x55;
@@ -256,7 +259,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
          else
             mask = 0xff;
 
-         for (bp = row, i = 0; i < row_info->rowbytes; i++, bp++)
+         for (i = 0; i < row_bytes; i++, bp++)
          {
             png_uint_16 v;
             int j;
@@ -274,27 +277,25 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
       }
       else if (row_info->bit_depth == 8)
       {
-         png_bytep bp;
+         png_bytep bp = row;
          png_uint_32 i;
+         png_uint_32 istop = channels * row_info->width;
 
-         for (bp = row, i = 0; i < row_info->width; i++)
+         for (i = 0; i < istop; i++, bp++)
          {
-            png_uint_32 c;
 
-            for (c = 0; c < channels; c++, bp++)
+            png_uint_16 v;
+            int j;
+            int c = (int)(i%channels);
+
+            v = *bp;
+            *bp = 0;
+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
             {
-               png_uint_16 v;
-               int j;
-
-               v = *bp;
-               *bp = 0;
-               for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
-               {
-                  if (j > 0)
-                     *bp |= (png_byte)((v << j) & 0xff);
-                  else
-                     *bp |= (png_byte)((v >> (-j)) & 0xff);
-               }
+               if (j > 0)
+                  *bp |= (png_byte)((v << j) & 0xff);
+               else
+                  *bp |= (png_byte)((v >> (-j)) & 0xff);
             }
          }
       }
@@ -302,28 +303,25 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
       {
          png_bytep bp;
          png_uint_32 i;
+         png_uint_32 istop = channels * row_info->width;
 
-         for (bp = row, i = 0; i < row_info->width * row_info->channels; i++)
+         for (bp = row, i = 0; i < istop; i++)
          {
-            png_uint_32 c;
+            int c = (int)(i%channels);
+            png_uint_16 value, v;
+            int j;
 
-            for (c = 0; c < channels; c++, bp += 2)
+            v = ((png_uint_16)(*bp) << 8) + *(bp + 1);
+            value = 0;
+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
             {
-               png_uint_16 value, v;
-               int j;
-
-               v = ((png_uint_16)(*bp) << 8) + *(bp + 1);
-               value = 0;
-               for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
-               {
-                  if (j > 0)
-                     value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
-                  else
-                     value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
-               }
-               *bp = (png_byte)(value >> 8);
-               *(bp + 1) = (png_byte)(value & 0xff);
+               if (j > 0)
+                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
+               else
+                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
             }
+            *bp++ = (png_byte)(value >> 8);
+            *bp++ = (png_byte)(value & 0xff);
          }
       }
    }
@@ -345,12 +343,11 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
          if (row_info->bit_depth == 8)
          {
             png_bytep sp, dp;
-            png_byte save;
             png_uint_32 i;
-
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
-               save = *(sp++);
+               png_byte save = *(sp++);
                *(dp++) = *(sp++);
                *(dp++) = *(sp++);
                *(dp++) = *(sp++);
@@ -361,11 +358,12 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
          else
          {
             png_bytep sp, dp;
-            png_byte save[2];
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
+               png_byte save[2];
                save[0] = *(sp++);
                save[1] = *(sp++);
                *(dp++) = *(sp++);
@@ -385,12 +383,12 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
          if (row_info->bit_depth == 8)
          {
             png_bytep sp, dp;
-            png_byte save;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
-               save = *(sp++);
+               png_byte save = *(sp++);
                *(dp++) = *(sp++);
                *(dp++) = save;
             }
@@ -399,11 +397,12 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
          else
          {
             png_bytep sp, dp;
-            png_byte save[2];
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
+               png_byte save[2];
                save[0] = *(sp++);
                save[1] = *(sp++);
                *(dp++) = *(sp++);
@@ -433,8 +432,8 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
          {
             png_bytep sp, dp;
             png_uint_32 i;
-
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
                *(dp++) = *(sp++);
                *(dp++) = *(sp++);
@@ -447,8 +446,9 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
          {
             png_bytep sp, dp;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
                *(dp++) = *(sp++);
                *(dp++) = *(sp++);
@@ -468,8 +468,9 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
          {
             png_bytep sp, dp;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
                *(dp++) = *(sp++);
                *(dp++) = 255 - *(sp++);
@@ -480,8 +481,9 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
          {
             png_bytep sp, dp;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
-            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            for (i = 0, sp = dp = row; i < row_width; i++)
             {
                *(dp++) = *(sp++);
                *(dp++) = *(sp++);

pngwutil.c

@@ -1,12 +1,11 @@
 
 /* pngwutil.c - utilities to write a PNG file
  *
- * libpng 1.0.0
+ * libpng 1.0.2 - June 14, 1998
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 8, 1998
  */
 
 #define PNG_INTERNAL
@@ -274,7 +273,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
 }
 
 /* write the palette.  We are careful not to trust png_color to be in the
- * correct order for PNG, so people can redefine it to any convient
+ * correct order for PNG, so people can redefine it to any convenient
  * structure.
  */
 void
@@ -340,7 +339,7 @@ png_write_gAMA(png_structp png_ptr, double file_gamma)
    png_byte buf[4];
 
    png_debug(1, "in png_write_gAMA\n");
-   /* file_gamma is saved in 1/100,000ths */
+   /* file_gamma is saved in 1/1000000ths */
    igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
    png_save_uint_32(buf, igamma);
    png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
@@ -426,7 +425,7 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
    png_byte buf[32];
 
    png_debug(1, "in png_write_cHRM\n");
-   /* each value is saved int 1/100,000ths */
+   /* each value is saved int 1/1000000ths */
    if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||
        white_x + white_y > 1.0)
    {
@@ -575,7 +574,8 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
 }
 #endif
 
-#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
+#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) || \
+    defined(PNG_WRITE_pCAL_SUPPORTED)
 /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
  * and if invalid, correct the keyword rather than discarding the entire
  * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in
@@ -766,7 +766,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    }
 
    /* We can't write the chunk until we find out how much data we have,
-    * which means we need to run the compressor first, and save the
+    * which means we need to run the compressor first and save the
     * output.  This shouldn't be a problem, as the vast majority of
     * comments should be reasonable, but we will set up an array of
     * malloc'd pointers to be sure.
@@ -835,7 +835,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
          png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
          png_ptr->zstream.next_out = png_ptr->zbuf;
       }
-   /* continue until we don't have anymore to compress */
+   /* continue until we don't have any more to compress */
    } while (png_ptr->zstream.avail_in);
 
    /* finish the compression */
@@ -1241,7 +1241,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
    if (pass < 6)
 #endif
    {
-      /* each pixel depth is handled seperately */
+      /* each pixel depth is handled separately */
       switch (row_info->pixel_depth)
       {
          case 1:
@@ -1252,11 +1252,12 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             int d;
             int value;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
             dp = row;
             d = 0;
             shift = 7;
-            for (i = png_pass_start[pass]; i < row_info->width;
+            for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 3);
@@ -1285,11 +1286,12 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             int d;
             int value;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
             dp = row;
             shift = 6;
             d = 0;
-            for (i = png_pass_start[pass]; i < row_info->width;
+            for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 2);
@@ -1317,11 +1319,12 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             int d;
             int value;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
 
             dp = row;
             shift = 4;
             d = 0;
-            for (i = png_pass_start[pass]; i < row_info->width;
+            for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 1);
@@ -1346,6 +1349,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             png_bytep sp;
             png_bytep dp;
             png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
             png_size_t pixel_bytes;
 
             /* start at the beginning */
@@ -1354,7 +1358,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             pixel_bytes = (row_info->pixel_depth >> 3);
             /* loop through the row, only looking at the pixels that
                matter */
-            for (i = png_pass_start[pass]; i < row_info->width;
+            for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                /* find out where the original pixel is */
@@ -1392,6 +1396,11 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 {
    png_bytep prev_row, best_row, row_buf;
    png_uint_32 mins, bpp;
+   png_byte filter_to_do = png_ptr->do_filter;
+   png_uint_32 row_bytes = row_info->rowbytes;
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+   int num_p_filters = (int)png_ptr->num_prev_filters;
+#endif
 
    png_debug(1, "in png_write_find_filter\n");
    /* find out how many bytes offset each pixel is */
@@ -1403,28 +1412,38 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 
    /* The prediction method we use is to find which method provides the
     * smallest value when summing the absolute values of the distances
-    * from zero using anything >= 128 as negative numbers.  This is known
+    * from zero, using anything >= 128 as negative numbers.  This is known
     * as the "minimum sum of absolute differences" heuristic.  Other
-    * heuristics are the "weighted minumum sum of absolute differences"
+    * heuristics are the "weighted minimum sum of absolute differences"
     * (experimental and can in theory improve compression), and the "zlib
-    * predictive" method (not implemented in libpng 0.95), which does test
-    * compressions of lines using different filter methods, and then chooses
-    * the (series of) filter(s) which give minimum compressed data size (VERY
+    * predictive" method (not implemented yet), which does test compressions
+    * of lines using different filter methods, and then chooses the
+    * (series of) filter(s) that give minimum compressed data size (VERY
     * computationally expensive).
+    *
+    * GRR 980525:  consider also
+    *   (1) minimum sum of absolute differences from running average (i.e.,
+    *       keep running sum of non-absolute differences & count of bytes)
+    *       [track dispersion, too?  restart average if dispersion too large?]
+    *  (1b) minimum sum of absolute differences from sliding average, probably
+    *       with window size <= deflate window (usually 32K)
+    *   (2) minimum sum of squared differences from zero or running average
+    *       (i.e., ~ root-mean-square approach)
     */
 
+
    /* We don't need to test the 'no filter' case if this is the only filter
     * that has been chosen, as it doesn't actually do anything to the data.
     */
-   if (png_ptr->do_filter & PNG_FILTER_NONE &&
-       png_ptr->do_filter != PNG_FILTER_NONE)
+   if (filter_to_do & PNG_FILTER_NONE &&
+       filter_to_do != PNG_FILTER_NONE)
    {
       png_bytep rp;
       png_uint_32 sum = 0;
       png_uint_32 i;
       int v;
 
-      for (i = 0, rp = row_buf + 1; i < row_info->rowbytes; i++, rp++)
+      for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
       {
          v = *rp;
          sum += (v < 128) ? v : 256 - v;
@@ -1434,17 +1453,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          png_uint_32 sumhi, sumlo;
+         int j;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
 
          /* Reduce the sum if we match any of the previous rows */
-         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_NONE)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
             {
-               sumlo = (sumlo * png_ptr->filter_weights[i]) >>
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               sumhi = (sumhi * png_ptr->filter_weights[i]) >>
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1468,7 +1488,25 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
    }
 
    /* sub filter */
-   if (png_ptr->do_filter & PNG_FILTER_SUB)
+   if (filter_to_do == PNG_FILTER_SUB)
+   /* it's the only filter so no testing is needed */
+   {
+      png_bytep rp, lp, dp;
+      png_uint_32 i;
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
+           i++, rp++, dp++)
+      {
+         *dp = *rp;
+      }
+      for (lp = row_buf + 1; i < row_bytes;
+         i++, rp++, lp++, dp++)
+      {
+         *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
+      }
+      best_row = png_ptr->sub_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_SUB)
    {
       png_bytep rp, dp, lp;
       png_uint_32 sum = 0, lmins = mins;
@@ -1476,23 +1514,24 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
       int v;
 
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
-      /* We temporarily increase the "minumum sum" by the factor we
+      /* We temporarily increase the "minimum sum" by the factor we
        * would reduce the sum of this filter, so that we can do the
        * early exit comparison without scaling the sum each time.
        */
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_SUB)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
             {
-               lmlo = (lmlo * png_ptr->inv_filter_weights[i]) >>
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               lmhi = (lmhi * png_ptr->inv_filter_weights[i]) >>
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1530,17 +1569,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_SUB)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
             {
-               sumlo = (sumlo * png_ptr->inv_filter_weights[i]) >>
+               sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               sumhi = (sumhi * png_ptr->inv_filter_weights[i]) >>
+               sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1565,27 +1605,43 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
    }
 
    /* up filter */
-   if (png_ptr->do_filter & PNG_FILTER_UP)
+   if (filter_to_do == PNG_FILTER_UP)
+   {
+      png_bytep rp, dp, pp;
+      png_uint_32 i;
+
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
+           pp = prev_row + 1; i < row_bytes;
+           i++, rp++, pp++, dp++)
+      {
+         *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
+      }
+      best_row = png_ptr->up_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_UP)
    {
       png_bytep rp, dp, pp;
       png_uint_32 sum = 0, lmins = mins;
       png_uint_32 i;
       int v;
 
+
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_UP)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
             {
-               lmlo = (lmlo * png_ptr->inv_filter_weights[i]) >>
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               lmhi = (lmhi * png_ptr->inv_filter_weights[i]) >>
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1603,10 +1659,9 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
-           pp = prev_row + 1; i < row_info->rowbytes;
-           i++, rp++, pp++, dp++)
+           pp = prev_row + 1; i < row_bytes; i++)
       {
-         v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
+         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
@@ -1617,17 +1672,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_UP)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
             {
-               sumlo = (sumlo * png_ptr->filter_weights[i]) >>
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               sumhi = (sumhi * png_ptr->filter_weights[i]) >>
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1652,7 +1708,24 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
    }
 
    /* avg filter */
-   if (png_ptr->do_filter & PNG_FILTER_AVG)
+   if (filter_to_do == PNG_FILTER_AVG)
+   {
+      png_bytep rp, dp, pp, lp;
+      png_uint_32 i;
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
+           pp = prev_row + 1; i < bpp; i++)
+      {
+         *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
+      }
+      for (lp = row_buf + 1; i < row_bytes; i++)
+      {
+         *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
+                 & 0xff);
+      }
+      best_row = png_ptr->avg_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_AVG)
    {
       png_bytep rp, dp, pp, lp;
       png_uint_32 sum = 0, lmins = mins;
@@ -1662,17 +1735,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_AVG)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
             {
-               lmlo = (lmlo * png_ptr->inv_filter_weights[i]) >>
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               lmhi = (lmhi * png_ptr->inv_filter_weights[i]) >>
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1690,16 +1764,16 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
-           pp = prev_row + 1; i < bpp; i++, rp++, pp++, dp++)
+           pp = prev_row + 1; i < bpp; i++)
       {
-         v = *dp = (png_byte)(((int)*rp - ((int)*pp / 2)) & 0xff);
+         v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
       }
-      for (lp = row_buf + 1; i < row_info->rowbytes;
-           i++, rp++, pp++, lp++, dp++)
+      for (lp = row_buf + 1; i < row_bytes; i++)
       {
-         v = *dp = (png_byte)(((int)*rp - (((int)*pp + (int)*lp) / 2)) & 0xff);
+         v = *dp++ = 
+          (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
@@ -1710,17 +1784,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_NONE)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
             {
-               sumlo = (sumlo * png_ptr->filter_weights[i]) >>
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               sumhi = (sumhi * png_ptr->filter_weights[i]) >>
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1745,7 +1820,45 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
    }
 
    /* Paeth filter */
-   if (png_ptr->do_filter & PNG_FILTER_PAETH)
+   if (filter_to_do == PNG_FILTER_PAETH)
+   {
+      png_bytep rp, dp, pp, cp, lp;
+      png_uint_32 i;
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
+           pp = prev_row + 1; i < bpp; i++)
+      {
+         *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+      }
+
+      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
+      {
+         int a, b, c, pa, pb, pc, p;
+
+         b = *pp++;
+         c = *cp++;
+         a = *lp++;
+
+         p = b - c;
+         pc = a - c;
+
+#ifdef PNG_USE_ABS
+         pa = abs(p);
+         pb = abs(pc);
+         pc = abs(p + pc);
+#else
+         pa = p < 0 ? -p : p;
+         pb = pc < 0 ? -pc : pc;
+         pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+
+         *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
+      }
+      best_row = png_ptr->paeth_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_PAETH)
    {
       png_bytep rp, dp, pp, cp, lp;
       png_uint_32 sum = 0, lmins = mins;
@@ -1755,17 +1868,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_PAETH)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
             {
-               lmlo = (lmlo * png_ptr->inv_filter_weights[i]) >>
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               lmhi = (lmhi * png_ptr->inv_filter_weights[i]) >>
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1783,34 +1897,48 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
-           pp = prev_row + 1; (unsigned)i < bpp; i++, rp++, pp++, dp++)
+           pp = prev_row + 1; i < bpp; i++)
       {
-         v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
+         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
       }
-      for (lp = row_buf + 1, cp = prev_row + 1; i < row_info->rowbytes;
-           i++, rp++, pp++, lp++, dp++, cp++)
+
+      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
       {
          int a, b, c, pa, pb, pc, p;
 
-         b = *pp;
-         c = *cp;
-         a = *lp;
+         b = *pp++;
+         c = *cp++;
+         a = *lp++;
 
+#ifndef PNG_SLOW_PAETH
+         p = b - c;
+         pc = a - c;
+#ifdef PNG_USE_ABS
+         pa = abs(p);
+         pb = abs(pc);
+         pc = abs(p + pc);
+#else
+         pa = p < 0 ? -p : p;
+         pb = pc < 0 ? -pc : pc;
+         pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+#else /* PNG_SLOW_PAETH */
          p = a + b - c;
          pa = abs(p - a);
          pb = abs(p - b);
          pc = abs(p - c);
-
          if (pa <= pb && pa <= pc)
             p = a;
          else if (pb <= pc)
             p = b;
          else
             p = c;
+#endif /* PNG_SLOW_PAETH */
 
-         v = *dp = (png_byte)(((int)*rp - p) & 0xff);
+         v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
@@ -1821,17 +1949,18 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
+         int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (j = 0; j < num_p_filters; j++)
          {
-            if (png_ptr->prev_filters[i] == PNG_FILTER_PAETH)
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
             {
-               sumlo = (sumlo * png_ptr->filter_weights[i]) >>
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
-               sumhi = (sumhi * png_ptr->filter_weights[i]) >>
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                   PNG_WEIGHT_SHIFT;
             }
          }
@@ -1855,19 +1984,19 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
    }
 
    /* Do the actual writing of the filtered row data from the chosen filter. */
+
    png_write_filtered_row(png_ptr, best_row);
 
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
    /* Save the type of filter we picked this time for future calculations */
    if (png_ptr->num_prev_filters > 0)
    {
-      int i;
-
-      for (i = 1; i < (int)png_ptr->num_prev_filters; i++)
+      int j;
+      for (j = 1; j < num_p_filters; j++)
       {
-         png_ptr->prev_filters[i] = png_ptr->prev_filters[i - 1];
+         png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
       }
-      png_ptr->prev_filters[i] = best_row[0];
+      png_ptr->prev_filters[j] = best_row[0];
    }
 #endif
 }

scripts/makefile.lnx

@@ -11,11 +11,16 @@ CC=gcc
 ZLIBLIB=../zlib
 ZLIBINC=../zlib
 
+ALIGN=
+# For I-386:
+#ALIGN=-malign-loops=2 -malign-functions=2
+
 WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
          -Wmissing-declarations -Wtraditional -Wcast-align \
          -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
-CFLAGS=-I$(ZLIBINC) -Wall -O3 -funroll-loops -malign-loops=2 \
-       -malign-functions=2 #$(WARNMORE) -g -DPNG_DEBUG=5
+
+CFLAGS=-I$(ZLIBINC) -Wall -O3 -funroll-loops \
+     $(ALIGN) # $(WARNMORE) -g -DPNG_DEBUG=5
 LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm
 
 RANLIB=ranlib
@@ -24,7 +29,7 @@ RANLIB=ranlib
 # read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
 # have to change it.
 PNGMAJ = 2
-PNGMIN = 1.0
+PNGMIN = 1.0.2
 PNGVER = $(PNGMAJ).$(PNGMIN)
 
 # where make install puts libpng.a, libpng.so*, and png.h

scripts/makefile.s2x

@@ -1,4 +1,4 @@
- makefile for libpng on Solaris 2.x with gcc
+# makefile for libpng on Solaris 2.x with gcc
 # Contributed by William L. Sebok, based on makefile.lnx
 # Copyright (C) 1996, 1997 Andreas Dilger
 # Copyright (C) 1998 Greg Roelofs
@@ -7,14 +7,20 @@
 CC=gcc
 
 # Where the zlib library and include files are located
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+
 ZLIBLIB=/usr/local/lib
 ZLIBINC=/usr/local/include
 
+
 WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
          -Wmissing-declarations -Wtraditional -Wcast-align \
          -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
 CFLAGS=-I$(ZLIBINC) -Wall -O3 \
-      #$(WARNMORE) -g -DPNG_DEBUG=5
+      # $(WARNMORE) -g -DPNG_DEBUG=5
 LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng -lz -lm
 
 #RANLIB=ranlib
@@ -23,11 +29,11 @@ RANLIB=echo
 # read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
 # have to change it.
 PNGMAJ = 2
-PNGMIN = 1.0
+PNGMIN = 1.0.2
 PNGVER = $(PNGMAJ).$(PNGMIN)
 
 # where make install puts libpng.a, libpng.so*, and png.h
-prefix=/local
+prefix=/usr/local
 INCPATH=$(prefix)/include
 LIBPATH=$(prefix)/lib
 
@@ -55,7 +61,7 @@ libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
 	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
 
 libpng.so.$(PNGVER): $(OBJSDLL)
-	$(LD) -G -L$(LIBPATH) -R$(LIBPATH) -h libpng.so.$(PNGMAJ) \
+	$(LD) -G -L$(ZLIBLIB) -R$(ZLIBLIB) -h libpng.so.$(PNGMAJ) \
 	 -o libpng.so.$(PNGVER) $(OBJSDLL) -lz
 
 pngtest: pngtest.o libpng.so

scripts/makefile.sco

@@ -0,0 +1,97 @@
+# makefile for SCO OSr5  ELF and Unixware 7 with Native cc
+# Contributed by Mike Hopkirk (hops@sco.com) modified from Makefile.lnx
+#   force ELF build dynamic linking, SONAME setting in lib and RPATH in app
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1998 Greg Roelofs
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=cc
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CFLAGS= -dy -belf -I$(ZLIBINC) -O3 
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
+PNGMAJ = 2
+PNGMIN = 1.0.2
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+# where make install puts libpng.a, libpng.so*, and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.pic.o:
+	$(CC) -c $(CFLAGS) -KPIC -o $@ $*.c
+
+all: libpng.a libpng.so pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.so: libpng.so.$(PNGMAJ)
+	ln -sf libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(CC) -G  -Wl,-h,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) \
+	 $(OBJSDLL)
+
+pngtest: pngtest.o libpng.so
+	LD_RUN_PATH=.:$(ZLIBLIB) $(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a libpng.so.$(PNGVER)
+	-@mkdir $(INCPATH) $(LIBPATH)
+	cp png.h pngconf.h $(INCPATH)
+	chmod 644 $(INCPATH)/png.h $(INCPATH)/pngconf.h
+	cp libpng.a libpng.so.$(PNGVER) $(LIBPATH)
+	chmod 755 $(LIBPATH)/libpng.so.$(PNGVER)
+	-@/bin/rm -f $(LIBPATH)/libpng.so.$(PNGMAJ) $(LIBPATH)/libpng.so
+	(cd $(LIBPATH); ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ); \
+	 ln -sf libpng.so.$(PNGMAJ) libpng.so)
+
+clean:
+	/bin/rm -f *.o libpng.a libpng.so* pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h
+pngerror.o pngerror.pic.o: png.h pngconf.h
+pngrio.o pngrio.pic.o: png.h pngconf.h
+pngwio.o pngwio.pic.o: png.h pngconf.h
+pngmem.o pngmem.pic.o: png.h pngconf.h
+pngset.o pngset.pic.o: png.h pngconf.h
+pngget.o pngget.pic.o: png.h pngconf.h
+pngread.o pngread.pic.o: png.h pngconf.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h
+pngpread.o pngpread.pic.o: png.h pngconf.h
+
+pngtest.o: png.h pngconf.h

scripts/makefile.sgi

@@ -10,7 +10,8 @@ ZLIBINC=../zlib
 
 CC=cc
 
-CFLAGS=-I$(ZLIBINC) -O -fullwarn # -g -DPNG_DEBUG=1
+WARNMORE=-fullwarn
+CFLAGS=-I$(ZLIBINC) -O $(WARNMORE) # -g -DPNG_DEBUG=5
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 
 RANLIB=echo

scripts/makefile.std

@@ -9,7 +9,7 @@ ZLIBLIB=../zlib
 ZLIBINC=../zlib
 
 CC=cc
-CFLAGS=-I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+CFLAGS=-I$(ZLIBINC) -O # -g -DPNG_DEBUG=5
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 
 #RANLIB=echo

scripts/makefile.sun

@@ -13,7 +13,7 @@ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow -Wconversion \
          -Wmissing-declarations -Wtraditional -Wcast-align \
          -Wstrict-prototypes -Wmissing-prototypes
 CC=gcc
-CFLAGS=-I$(ZLIBINC) -O $(WARNMORE) -DPNG_DEBUG=4
+CFLAGS=-I$(ZLIBINC) -O # $(WARNMORE) -DPNG_DEBUG=5
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 
 RANLIB=ranlib

scripts/makefile.w32

@@ -0,0 +1,85 @@
+# makefile for libpng
+# Copyright (C) 1998 Tim Wegner
+# For conditions of distribution and use, see copyright notice in png.h
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+# To use, do "nmake /f scripts\makefile.w32"
+
+# ------------- Microsoft Visual C++ 4.0 and later -------------
+MODEL=- 
+CFLAGS=-Ox -GA3s -nologo -W3 -I..\zlib
+
+CC=cl
+LD=link
+LDFLAGS= 
+O=.obj
+
+#uncomment next to put error messages in a file
+ERRFILE= >> pngerrs
+
+# variables
+OBJS1 = png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O)
+OBJS2 = pngmem$(O) pngpread$(O) pngread$(O) pngerror$(O) pngwrite$(O)
+OBJS3 = pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+
+all: libpng.lib
+
+png$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngset$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngget$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngtest$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
+        del libpng.lib
+	lib /OUT:libpng.lib $(OBJS1) $(OBJS2) $(OBJS3)
+
+pngtest.exe: pngtest.obj libpng.lib 
+	$(LD) $(LDFLAGS) pngtest.obj libpng.lib ..\zlib\zlib.lib /OUT:pngtest.exe /SUBSYSTEM:CONSOLE
+
+test: pngtest.exe
+	pngtest
+
+# End of makefile for libpng
+

scripts/makefile.wat

@@ -1,5 +1,5 @@
 # Makefile for libpng
-# Watcom 10a and later 32-bit protected mode flat memory model
+# Watcom 10.0a and later 32-bit protected mode flat memory model
 
 # Adapted by Pawel Mrochen, based on makefile.msc
 # For conditions of distribution and use, see copyright notice in png.h
@@ -7,9 +7,9 @@
 
 # To use, do "wmake -f makefile.wat"
 
-# ------------- Watcom 10a and later -------------
+# ------------- Watcom 10.0a and later -------------
 MODEL=-mf
-CFLAGS= $(MODEL) -fpi87 -fp5 -5r -oaeilmnrt -s -zp4 -i=..\zlib
+CFLAGS= $(MODEL) -5r -fp5 -fpi87 -oneatx -zp8 -i=..\zlib
 CC=wcc386
 LD=wcl386
 LIB=wlib -b -c
@@ -75,9 +75,9 @@ pngwutil$(O): png.h pngconf.h
 	$(CC) $(CFLAGS) $*.c $(ERRFILE)
 
 libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
-	$(LIB) -n libpng.lib +$(OBJS1)
-	$(LIB) libpng.lib +$(OBJS2)
-	$(LIB) libpng.lib +$(OBJS3)
+	$(LIB) -n libpng.lib $(OBJS1)
+	$(LIB) libpng.lib $(OBJS2)
+	$(LIB) libpng.lib $(OBJS3)
 
 pngtest.exe: pngtest.obj libpng.lib
 	$(LD) $(LDFLAGS) pngtest.obj libpng.lib ..\zlib\zlib.lib

scripts/pngdef.pas

@@ -0,0 +1,708 @@
+unit pngdef;
+
+interface
+
+const
+  PNG_LIBPNG_VER_STRING = '1.0.2';
+  PNG_LIBPNG_VER        =  10001;
+
+type
+  png_uint_32 = Cardinal;
+  png_int_32  = Longint;
+  png_uint_16 = Word;
+  png_int_16  = Smallint;
+  png_byte    = Byte;
+  png_size_t  = png_uint_32;
+  png_charpp  = ^png_charp;
+  png_charp   = PChar;
+  float       = single;
+  int         = Integer;
+  png_bytepp  = ^png_bytep;
+  png_bytep   = ^png_byte;
+  png_uint_16p = ^png_uint_16;
+  png_uint_16pp = ^png_uint_16p;
+  png_voidp    = pointer;
+  time_t       = Longint;
+  png_doublep  = ^png_double;
+  png_double   = double;
+
+  user_error_ptr  = Pointer;
+  png_error_ptrp = ^png_error_ptr;
+  png_error_ptr  = procedure(png_ptr: Pointer; msg: Pointer);
+             stdcall;
+  png_rw_ptrp = ^png_rw_ptr;
+  png_rw_ptr = procedure(png_ptr: Pointer; data: Pointer;
+                         length: png_size_t);
+             stdcall;
+  png_flush_ptrp = ^png_flush_ptr;
+  png_flush_ptr = procedure(png_ptr: Pointer);
+             stdcall;
+  png_progressive_info_ptrp = ^png_progressive_info_ptr;
+  png_progressive_info_ptr  = procedure(png_ptr: Pointer;
+                                        info_ptr: Pointer);
+             stdcall;
+  png_progressive_end_ptrp  = ^png_progressive_end_ptr;
+  png_progressive_end_ptr   = procedure(png_ptr: Pointer;
+                                        info_ptr: Pointer);
+             stdcall;
+  png_progressive_row_ptrp  = ^png_progressive_row_ptr;
+  png_progressive_row_ptr   = procedure(png_ptr: Pointer;
+                                data: Pointer; length: png_uint_32;
+                                count: int);
+             stdcall;
+  png_read_status_ptr = procedure(png_ptr: Pointer;
+                          row_number: png_uint_32; pass: int);
+             stdcall;
+  png_write_status_ptr = procedure(png_ptr: Pointer;
+                           row_number: png_uint_32; pass: int);
+             stdcall;
+  png_user_transform_ptr = procedure(png_ptr: Pointer;
+                             row_info: Pointer; data: png_bytep);
+             stdcall;
+
+  png_colorpp = ^png_colorp;
+  png_colorp = ^png_color;
+  png_color = packed record
+    red, green, blue: png_byte;
+    end;
+
+  png_color_16pp = ^png_color_16p;
+  png_color_16p = ^png_color_16;
+  png_color_16 = packed record
+    index: png_byte;                 //used for palette files
+    red, green, blue: png_uint_16;   //for use in red green blue files
+    gray: png_uint_16;               //for use in grayscale files
+    end;
+
+  png_color_8pp = ^png_color_8p;
+  png_color_8p = ^png_color_8;
+  png_color_8 = packed record
+    red, green, blue: png_byte;   //for use in red green blue files
+    gray: png_byte;               //for use in grayscale files
+    alpha: png_byte;              //for alpha channel files
+    end;
+
+  png_textpp = ^png_textp;
+  png_textp = ^png_text;
+  png_text = packed record
+    compression: int;            //compression value
+    key: png_charp;              //keyword, 1-79 character description of "text"
+    text: png_charp;             //comment, may be empty ("")
+    text_length: png_size_t;     //length of text field
+    end;
+
+  png_timepp = ^png_timep;
+  png_timep = ^png_time;
+  png_time = packed record
+    year: png_uint_16;           //yyyy
+    month: png_byte;             //1..12
+    day: png_byte;               //1..31
+    hour: png_byte;              //0..23
+    minute: png_byte;            //0..59
+    second: png_byte;            //0..60 (leap seconds)
+    end;
+
+  png_infopp = ^png_infop;
+  png_infop = Pointer;
+
+  png_row_infopp = ^png_row_infop;
+  png_row_infop = ^png_row_info;
+  png_row_info = packed record
+    width: png_uint_32;          //width of row
+    rowbytes: png_size_t;        //number of bytes in row
+    color_type: png_byte;        //color type of row
+    bit_depth: png_byte;         //bit depth of row
+    channels: png_byte;          //number of channels (1, 2, 3, or 4)
+    pixel_depth: png_byte;       //bits per pixel (depth * channels)
+    end;
+
+  png_structpp = ^png_structp;
+  png_structp = Pointer;
+
+const
+
+// Supported compression types for text in PNG files (tEXt, and zTXt).
+// The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed.
+
+  PNG_TEXT_COMPRESSION_NONE_WR = -3;
+  PNG_TEXT_COMPRESSION_zTXt_WR = -2;
+  PNG_TEXT_COMPRESSION_NONE    = -1;
+  PNG_TEXT_COMPRESSION_zTXt    = 0;
+
+// These describe the color_type field in png_info.
+// color type masks
+
+  PNG_COLOR_MASK_PALETTE   = 1;
+  PNG_COLOR_MASK_COLOR     = 2;
+  PNG_COLOR_MASK_ALPHA     = 4;
+
+// color types.  Note that not all combinations are legal
+
+  PNG_COLOR_TYPE_GRAY       = 0;
+  PNG_COLOR_TYPE_PALETTE    = PNG_COLOR_MASK_COLOR or
+                              PNG_COLOR_MASK_PALETTE;
+  PNG_COLOR_TYPE_RGB        = PNG_COLOR_MASK_COLOR;
+  PNG_COLOR_TYPE_RGB_ALPHA  = PNG_COLOR_MASK_COLOR or
+                              PNG_COLOR_MASK_ALPHA;
+  PNG_COLOR_TYPE_GRAY_ALPHA = PNG_COLOR_MASK_ALPHA;
+
+// This is for compression type. PNG 1.0 only defines the single type.
+
+  PNG_COMPRESSION_TYPE_BASE    = 0;   // Deflate method 8, 32K window
+  PNG_COMPRESSION_TYPE_DEFAULT = PNG_COMPRESSION_TYPE_BASE;
+
+// This is for filter type. PNG 1.0 only defines the single type.
+
+  PNG_FILTER_TYPE_BASE    = 0;       // Single row per-byte filtering
+  PNG_FILTER_TYPE_DEFAULT = PNG_FILTER_TYPE_BASE;
+
+// These are for the interlacing type.  These values should NOT be changed.
+
+  PNG_INTERLACE_NONE  = 0;      // Non-interlaced image
+  PNG_INTERLACE_ADAM7 = 1;      // Adam7 interlacing
+
+// These are for the oFFs chunk.  These values should NOT be changed.
+
+  PNG_OFFSET_PIXEL      = 0;    // Offset in pixels
+  PNG_OFFSET_MICROMETER = 1;    // Offset in micrometers (1/10^6 meter)
+
+// These are for the pCAL chunk.  These values should NOT be changed.
+
+  PNG_EQUATION_LINEAR     = 0;  // Linear transformation
+  PNG_EQUATION_BASE_E     = 1;  // Exponential base e transform
+  PNG_EQUATION_ARBITRARY  = 2;  // Arbitrary base exponential transform
+  PNG_EQUATION_HYPERBOLIC = 3;  // Hyperbolic sine transformation
+
+// These are for the pHYs chunk.  These values should NOT be changed.
+
+  PNG_RESOLUTION_UNKNOWN = 0;   // pixels/unknown unit (aspect ratio)
+  PNG_RESOLUTION_METER   = 1;   // pixels/meter
+
+// These are for the sRGB chunk.  These values should NOT be changed.
+  PNG_sRGB_INTENT_SATURATION = 0;
+  PNG_sRGB_INTENT_PERCEPTUAL = 1;
+  PNG_sRGB_INTENT_ABSOLUTE   = 2;
+  PNG_sRGB_INTENT_RELATIVE   = 3;
+
+// Handle alpha and tRNS by replacing with a background color.
+  PNG_BACKGROUND_GAMMA_UNKNOWN = 0;
+  PNG_BACKGROUND_GAMMA_SCREEN  = 1;
+  PNG_BACKGROUND_GAMMA_FILE    = 2;
+  PNG_BACKGROUND_GAMMA_UNIQUE  = 3;
+
+// Values for png_set_crc_action() to say how to handle CRC errors in
+// ancillary and critical chunks, and whether to use the data contained
+// therein.  Note that it is impossible to "discard" data in a critical
+// chunk.  For versions prior to 0.90, the action was always error/quit,
+// whereas in version 0.90 and later, the action for CRC errors in ancillary
+// chunks is warn/discard.  These values should NOT be changed.
+
+//      value                   action:critical     action:ancillary
+
+  PNG_CRC_DEFAULT      = 0;  // error/quit          warn/discard data
+  PNG_CRC_ERROR_QUIT   = 1;  // error/quit          error/quit
+  PNG_CRC_WARN_DISCARD = 2;  // (INVALID)           warn/discard data
+  PNG_CRC_WARN_USE     = 3;  // warn/use data       warn/use data
+  PNG_CRC_QUIET_USE    = 4;  // quiet/use data      quiet/use data
+  PNG_CRC_NO_CHANGE    = 5;  // use current value   use current value 
+
+// Flags for png_set_filter() to say which filters to use.  The flags
+// are chosen so that they don't conflict with real filter types
+// below, in case they are supplied instead of the #defined constants.
+// These values should NOT be changed.
+
+  PNG_NO_FILTERS   = $00;
+  PNG_FILTER_NONE  = $08;
+  PNG_FILTER_SUB   = $10;
+  PNG_FILTER_UP    = $20;
+  PNG_FILTER_AVG   = $40;
+  PNG_FILTER_PAETH = $80;
+  PNG_ALL_FILTERS  = PNG_FILTER_NONE or PNG_FILTER_SUB or
+                     PNG_FILTER_UP   or PNG_FILTER_AVG or
+                     PNG_FILTER_PAETH;
+
+// Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
+// These defines should NOT be changed.
+
+  PNG_FILTER_VALUE_NONE  = 0;
+  PNG_FILTER_VALUE_SUB   = 1;
+  PNG_FILTER_VALUE_UP    = 2;
+  PNG_FILTER_VALUE_AVG   = 3;
+  PNG_FILTER_VALUE_PAETH = 4;
+
+// Heuristic used for row filter selection.  These defines should NOT be
+// changed.
+
+  PNG_FILTER_HEURISTIC_DEFAULT    = 0;  // Currently "UNWEIGHTED"
+  PNG_FILTER_HEURISTIC_UNWEIGHTED = 1;  // Used by libpng < 0.95
+  PNG_FILTER_HEURISTIC_WEIGHTED   = 2;  // Experimental feature
+  PNG_FILTER_HEURISTIC_LAST       = 3;  // Not a valid value 
+
+procedure png_build_grayscale_palette(bit_depth: int; palette: png_colorp);
+             stdcall;
+function png_check_sig(sig: png_bytep; num: int): int;
+             stdcall;
+procedure png_chunk_error(png_ptr: png_structp;
+             const mess: png_charp);
+             stdcall;
+procedure png_chunk_warning(png_ptr: png_structp;
+             const mess: png_charp);
+             stdcall;
+procedure png_convert_from_time_t(ptime: png_timep; ttime: time_t);
+             stdcall;
+function png_convert_to_rfc1123(png_ptr: png_structp; ptime: png_timep):
+             png_charp;
+             stdcall;
+function png_create_info_struct(png_ptr: png_structp): png_infop;
+             stdcall;
+function png_create_read_struct(user_png_ver: png_charp;
+             error_ptr: user_error_ptr; error_fn: png_error_ptr;
+             warn_fn: png_error_ptr): png_structp;
+             stdcall;
+function png_create_write_struct(user_png_ver: png_charp;
+             error_ptr: user_error_ptr; error_fn: png_error_ptr;
+             warn_fn: png_error_ptr): png_structp;
+             stdcall;
+procedure png_destroy_info_struct(png_ptr: png_structp;
+             info_ptr_ptr: png_infopp);
+             stdcall;
+procedure png_destroy_read_struct(png_ptr_ptr: png_structpp;
+             info_ptr_ptr, end_info_ptr_ptr: png_infopp);
+             stdcall;
+procedure png_destroy_write_struct(png_ptr_ptr: png_structpp;
+             info_ptr_ptr: png_infopp);
+             stdcall;
+function png_get_IHDR(png_ptr: png_structp; info_ptr: png_infop;
+             var width, height: png_uint_32; var bit_depth,
+             color_type, interlace_type, compression_type,
+             filter_type: int): png_uint_32;
+             stdcall;
+function png_get_PLTE(png_ptr: png_structp; info_ptr: png_infop;
+             var palette: png_colorp; var num_palette: int):
+             png_uint_32;
+             stdcall;
+function png_get_bKGD(png_ptr: png_structp; info_ptr: png_infop;
+             var background: png_color_16p): png_uint_32;
+             stdcall;
+function png_get_bit_depth(png_ptr: png_structp; info_ptr: png_infop):
+             png_byte;
+             stdcall;
+function png_get_cHRM(png_ptr: png_structp; info_ptr: png_infop;
+             var white_x, white_y, red_x, red_y, green_x, green_y,
+             blue_x, blue_y: double): png_uint_32;
+             stdcall;
+function png_get_channels(png_ptr: png_structp; info_ptr: png_infop):
+             png_byte;
+             stdcall;
+function png_get_color_type(png_ptr: png_structp; info_ptr: png_infop):
+             png_byte;
+             stdcall;
+function png_get_compression_type(png_ptr: png_structp;
+             info_ptr: png_infop): png_byte;
+             stdcall;
+function png_get_error_ptr(png_ptr: png_structp): png_voidp;
+             stdcall;
+function png_get_filter_type(png_ptr: png_structp; info_ptr: png_infop):
+             png_byte;
+             stdcall;
+function png_get_gAMA(png_ptr: png_structp; info_ptr: png_infop;
+             var file_gamma: double): png_uint_32;
+             stdcall;
+function png_get_hIST(png_ptr: png_structp; info_ptr: png_infop;
+             var hist: png_uint_16p): png_uint_32;
+             stdcall;
+function png_get_image_height(png_ptr: png_structp; info_ptr: png_infop):
+             png_uint_32;
+             stdcall;
+function png_get_image_width(png_ptr: png_structp; info_ptr: png_infop):
+             png_uint_32;
+             stdcall;
+function png_get_interlace_type(png_ptr: png_structp;
+             info_ptr: png_infop): png_byte;
+             stdcall;
+function png_get_io_ptr(png_ptr: png_structp): png_voidp;
+             stdcall;
+function png_get_oFFs(png_ptr: png_structp; info_ptr: png_infop;
+             var offset_x, offset_y: png_uint_32;
+             var unit_type: int): png_uint_32;
+             stdcall;
+function png_get_pCAL(png_ptr: png_structp; info_ptr: png_infop;
+             var purpose: png_charp; var X0, X1: png_int_32;
+             var typ, nparams: int; var units: png_charp;
+             var params: png_charpp): png_uint_32;
+             stdcall;
+function png_get_pHYs(png_ptr: png_structp; info_ptr: png_infop;
+             var res_x, res_y: png_uint_32; var unit_type: int):
+             png_uint_32;
+             stdcall;
+function png_get_pixel_aspect_ratio(png_ptr: png_structp;
+             info_ptr: png_infop): float;
+             stdcall;
+function png_get_pixels_per_meter(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+function png_get_progressive_ptr(png_ptr: png_structp): png_voidp;
+             stdcall;
+function png_get_rowbytes(png_ptr: png_structp; info_ptr: png_infop):
+             png_uint_32;
+             stdcall;
+function png_get_sBIT(png_ptr: png_structp; info_ptr: png_infop;
+             var sig_bits: png_color_8p): png_uint_32;
+             stdcall;
+function png_get_sRGB(png_ptr: png_structp; info_ptr: png_infop;
+             var file_srgb_intent: int): png_uint_32;
+             stdcall; 
+function png_get_signature(png_ptr: png_structp; info_ptr: png_infop):
+             png_bytep;
+             stdcall;
+function png_get_tIME(png_ptr: png_structp; info_ptr: png_infop;
+             var mod_time: png_timep): png_uint_32;
+             stdcall;
+function png_get_tRNS(png_ptr: png_structp; info_ptr: png_infop;
+             var trans: png_bytep; var num_trans: int;
+             var trans_values: png_color_16p): png_uint_32;
+             stdcall;
+function png_get_text(png_ptr: png_structp; info_ptr: png_infop;
+             var text_ptr: png_textp; var num_text: int):
+             png_uint_32;
+             stdcall;
+function png_get_valid(png_ptr: png_structp; info_ptr: png_infop;
+             flag: png_uint_32): png_uint_32;
+             stdcall;
+function png_get_x_offset_microns(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+function png_get_x_offset_pixels(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+function png_get_x_pixels_per_meter(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+function png_get_y_offset_microns(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+function png_get_y_offset_pixels(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+function png_get_y_pixels_per_meter(png_ptr: png_structp;
+             info_ptr: png_infop): png_uint_32;
+             stdcall;
+procedure png_process_data(png_ptr: png_structp; info_ptr: png_infop;
+             buffer: png_bytep; buffer_size: png_size_t);
+             stdcall;
+procedure png_progressive_combine_row(png_ptr: png_structp;
+             old_row, new_row: png_bytep);
+             stdcall;
+procedure png_read_end(png_ptr: png_structp; info_ptr: png_infop);
+              stdcall;
+procedure png_read_image(png_ptr: png_structp; image: png_bytepp);
+             stdcall;
+procedure png_read_info(png_ptr: png_structp; info_ptr: png_infop);
+             stdcall;
+procedure png_read_row(png_ptr: png_structp; row, dsp_row: png_bytep);
+             stdcall;
+procedure png_read_rows(png_ptr: png_structp; row, display_row:
+              png_bytepp; num_rows: png_uint_32);
+             stdcall;
+procedure png_read_update_info(png_ptr: png_structp; info_ptr: png_infop);
+             stdcall;
+procedure png_set_IHDR(png_ptr: png_structp; info_ptr: png_infop;
+             width, height: png_uint_32; bit_depth, color_type,
+             interlace_type, compression_type, filter_type: int);
+             stdcall;
+procedure png_set_PLTE(png_ptr: png_structp; info_ptr: png_infop;
+             palette: png_colorp; num_palette: int);
+             stdcall;
+procedure png_set_bKGD(png_ptr: png_structp; info_ptr: png_infop;
+             background: png_color_16p);
+             stdcall;
+procedure png_set_background(png_ptr: png_structp;
+             background_color: png_color_16p;
+             background_gamma_code, need_expand: int;
+             background_gamma: double);
+             stdcall;
+procedure png_set_bgr(png_ptr: png_structp);
+             stdcall;
+procedure png_set_cHRM(png_ptr: png_structp; info_ptr: png_infop;
+             white_x, white_y, red_x, red_y, green_x, green_y,
+             blue_x, blue_y: double);
+             stdcall;
+procedure png_set_compression_level(png_ptr: png_structp; level: int);
+             stdcall;
+procedure png_set_compression_mem_level(png_ptr: png_structp;
+             mem_level: int);
+             stdcall;
+procedure png_set_compression_method(png_ptr: png_structp; method: int);
+             stdcall;
+procedure png_set_compression_strategy(png_ptr: png_structp;
+             strategy: int);
+             stdcall;
+procedure png_set_compression_window_bits(png_ptr: png_structp;
+             window_bits: int);
+             stdcall;
+procedure png_set_crc_action(png_ptr: png_structp;
+             crit_action, ancil_action: int);
+             stdcall;
+procedure png_set_dither(png_ptr: png_structp; plaette: png_colorp;
+             num_palette, maximum_colors: int;
+             histogram: png_uint_16p; full_dither: int);
+             stdcall;
+procedure png_set_error_fn(png_ptr: png_structp; error_ptr: png_voidp;
+             error_fn, warning_fn: png_error_ptr);
+             stdcall;
+procedure png_set_expand(png_ptr: png_structp);
+             stdcall;
+procedure png_set_filler(png_ptr: png_structp; filler: png_uint_32;
+             filler_loc: int);
+             stdcall;
+procedure png_set_filter(png_ptr: png_structp; method, filters: int);
+             stdcall;
+procedure png_set_filter_heuristics(png_ptr: png_structp;
+             heuristic_method, num_weights: int;
+             filter_weights, filter_costs: png_doublep);
+             stdcall;
+procedure png_set_flush(png_ptr: png_structp; nrows: int);
+             stdcall;
+procedure png_set_gAMA(png_ptr: png_structp; info_ptr: png_infop;
+             file_gamma: double);
+             stdcall;
+procedure png_set_gamma(png_ptr: png_structp; screen_gamma,
+             default_file_gamma: double);
+             stdcall;
+procedure png_set_gray_to_rgb(png_ptr: png_structp);
+             stdcall;
+procedure png_set_hIST(png_ptr: png_structp; info_ptr: png_infop;
+             hist: png_uint_16p);
+             stdcall;
+function png_set_interlace_handling(png_ptr: png_structp): int;
+             stdcall;
+procedure png_set_invert_alpha(png_ptr: png_structp);
+             stdcall;
+procedure png_set_invert_mono(png_ptr: png_structp);
+             stdcall;
+procedure png_set_oFFs(png_ptr: png_structp; info_ptr: png_infop;
+             offset_x, offset_y: png_uint_32; unit_type: int);
+             stdcall;
+procedure png_set_pCAL(png_ptr: png_structp; info_ptr: png_infop;
+             purpose: png_charp; X0, X1: png_int_32;
+             typ, nparams: int; units: png_charp;
+             params: png_charpp);
+             stdcall;
+procedure png_set_pHYs(png_ptr: png_structp; info_ptr: png_infop;
+             res_x, res_y: png_uint_32; unit_type: int);
+             stdcall;
+procedure png_set_packing(png_ptr: png_structp);
+             stdcall;
+procedure png_set_packswap(png_ptr: png_structp);
+             stdcall;
+procedure png_set_progressive_read_fn(png_ptr: png_structp;
+             progressive_ptr: png_voidp;
+             info_fn: png_progressive_info_ptr;
+             row_fn: png_progressive_row_ptr;
+             end_fn: png_progressive_end_ptr);
+             stdcall;
+procedure png_set_read_fn(png_ptr: png_structp;
+             io_ptr: png_voidp; read_data_fn: png_rw_ptr);
+             stdcall;
+procedure png_set_read_status_fn(png_ptr: png_structp;
+             read_row_fn: png_read_status_ptr);
+             stdcall;
+procedure png_set_read_user_transform_fn(png_ptr: png_structp;
+             read_user_transform_fn: png_user_transform_ptr);
+             stdcall;
+procedure png_set_sBIT(png_ptr: png_structp; info_ptr: png_infop;
+             sig_bits: png_color_8p);
+             stdcall;
+procedure png_set_sRGB(png_ptr: png_structp; info_ptr: png_infop;
+             intent: int);
+             stdcall;
+procedure png_set_sRGB_gAMA_and_cHRM(png_ptr: png_structp;
+             info_ptr: png_infop; intent: int);
+             stdcall;
+procedure png_set_shift(png_ptr: png_structp; true_bits: png_color_8p);
+             stdcall;
+procedure png_set_sig_bytes(png_ptr: png_structp; num_bytes: int);
+             stdcall;
+procedure png_set_strip_16(png_ptr: png_structp);
+             stdcall;
+procedure png_set_strip_alpha(png_ptr: png_structp);
+             stdcall;
+procedure png_set_swap(png_ptr: png_structp);
+             stdcall;
+procedure png_set_swap_alpha(png_ptr: png_structp);
+             stdcall;
+procedure png_set_tIME(png_ptr: png_structp; info_ptr: png_infop;
+             mod_time: png_timep);
+             stdcall;
+procedure png_set_tRNS(png_ptr: png_structp; info_ptr: png_infop;
+             trans: png_bytep; num_trans: int;
+             trans_values: png_color_16p);
+             stdcall;
+procedure png_set_text(png_ptr: png_structp; info_ptr: png_infop;
+             text_ptr: png_textp; num_text: int);
+             stdcall;
+procedure png_set_write_fn(png_ptr: png_structp;
+             io_ptr: png_voidp; write_data_fn: png_rw_ptr;
+             output_flush_fn: png_flush_ptr);
+             stdcall;
+procedure png_set_write_status_fn(png_ptr: png_structp;
+             write_row_fn: png_write_status_ptr);
+             stdcall;
+procedure png_set_write_user_transform_fn(png_ptr: png_structp;
+             write_user_transform_fn: png_user_transform_ptr);
+             stdcall;
+function png_sig_cmp(sig: png_bytep; start, num_to_check: png_size_t):
+             int;
+             stdcall;
+procedure png_start_read_image(png_ptr: png_structp);
+             stdcall;
+procedure png_write_chunk(png_ptr: png_structp;
+             chunk_name, data: png_bytep; length: png_size_t);
+             stdcall;
+procedure png_write_chunk_data(png_ptr: png_structp;
+             data: png_bytep; length: png_size_t);
+             stdcall;
+procedure png_write_chunk_end(png_ptr: png_structp);
+             stdcall;
+procedure png_write_chunk_start(png_ptr: png_structp;
+             chunk_name: png_bytep; length: png_uint_32);
+             stdcall;
+procedure png_write_end(png_ptr: png_structp; info_ptr: png_infop);
+             stdcall;
+procedure png_write_flush(png_ptr: png_structp);
+             stdcall;
+procedure png_write_image(png_ptr: png_structp; image: png_bytepp);
+             stdcall;
+procedure png_write_info(png_ptr: png_structp; info_ptr: png_infop);
+             stdcall;
+procedure png_write_row(png_ptr: png_structp; row: png_bytep);
+             stdcall;
+procedure png_write_rows(png_ptr: png_structp; row: png_bytepp;
+             num_rows: png_uint_32);
+             stdcall;
+
+implementation
+
+const
+  pngDLL = 'png32bd.dll';
+
+procedure png_build_grayscale_palette; external pngDLL;
+function png_check_sig; external pngDLL;
+procedure png_chunk_error; external pngDLL;
+procedure png_chunk_warning; external pngDLL;
+procedure png_convert_from_time_t; external pngDLL;
+function png_convert_to_rfc1123; external pngDLL;
+function png_create_info_struct; external pngDLL;
+function png_create_read_struct; external pngDLL;
+function png_create_write_struct; external pngDLL;
+procedure png_destroy_info_struct; external pngDLL;
+procedure png_destroy_read_struct; external pngDLL;
+procedure png_destroy_write_struct; external pngDLL;
+function png_get_IHDR; external pngDLL;
+function png_get_PLTE; external pngDLL;
+function png_get_bKGD; external pngDLL;
+function png_get_bit_depth; external pngDLL;
+function png_get_cHRM; external pngDLL;
+function png_get_channels; external pngDLL;
+function png_get_color_type; external pngDLL;
+function png_get_compression_type; external pngDLL;
+function png_get_error_ptr; external pngDLL;
+function png_get_filter_type; external pngDLL;
+function png_get_gAMA; external pngDLL;
+function png_get_hIST; external pngDLL;
+function png_get_image_height; external pngDLL;
+function png_get_image_width; external pngDLL;
+function png_get_interlace_type; external pngDLL;
+function png_get_io_ptr; external pngDLL;
+function png_get_oFFs; external pngDLL;
+function png_get_pCAL; external pngDLL;
+function png_get_pHYs; external pngDLL;
+function png_get_pixel_aspect_ratio; external pngDLL;
+function png_get_pixels_per_meter; external pngDLL;
+function png_get_progressive_ptr; external pngDLL;
+function png_get_rowbytes; external pngDLL;
+function png_get_sBIT; external pngDLL;
+function png_get_sRGB; external pngDLL;
+function png_get_signature; external pngDLL;
+function png_get_tIME; external pngDLL;
+function png_get_tRNS; external pngDLL;
+function png_get_text; external pngDLL;
+function png_get_valid; external pngDLL;
+function png_get_x_offset_microns; external pngDLL;
+function png_get_x_offset_pixels; external pngDLL;
+function png_get_x_pixels_per_meter; external pngDLL;
+function png_get_y_offset_microns; external pngDLL;
+function png_get_y_offset_pixels; external pngDLL;
+function png_get_y_pixels_per_meter; external pngDLL;
+procedure png_process_data; external pngDLL;
+procedure png_progressive_combine_row; external pngDLL;
+procedure png_read_end; external pngDLL;
+procedure png_read_image; external pngDLL;
+procedure png_read_info; external pngDLL;
+procedure png_read_row; external pngDLL;
+procedure png_read_rows; external pngDLL;
+procedure png_read_update_info; external pngDLL;
+procedure png_set_IHDR; external pngDLL;
+procedure png_set_PLTE; external pngDLL;
+procedure png_set_bKGD; external pngDLL;
+procedure png_set_background; external pngDLL;
+procedure png_set_bgr; external pngDLL;
+procedure png_set_cHRM; external pngDLL;
+procedure png_set_compression_level; external pngDLL;
+procedure png_set_compression_mem_level; external pngDLL;
+procedure png_set_compression_method; external pngDLL;
+procedure png_set_compression_strategy; external pngDLL;
+procedure png_set_compression_window_bits; external pngDLL;
+procedure png_set_crc_action; external pngDLL;
+procedure png_set_dither; external pngDLL;
+procedure png_set_error_fn; external pngDLL;
+procedure png_set_expand; external pngDLL;
+procedure png_set_filler; external pngDLL;
+procedure png_set_filter; external pngDLL;
+procedure png_set_filter_heuristics; external pngDLL;
+procedure png_set_flush; external pngDLL;
+procedure png_set_gAMA; external pngDLL;
+procedure png_set_gamma; external pngDLL;
+procedure png_set_gray_to_rgb; external pngDLL;
+procedure png_set_hIST; external pngDLL;
+function png_set_interlace_handling; external pngDLL;
+procedure png_set_invert_alpha; external pngDLL;
+procedure png_set_invert_mono; external pngDLL;
+procedure png_set_oFFs; external pngDLL;
+procedure png_set_pCAL; external pngDLL;
+procedure png_set_pHYs; external pngDLL;
+procedure png_set_packing; external pngDLL;
+procedure png_set_packswap; external pngDLL;
+procedure png_set_progressive_read_fn; external pngDLL;
+procedure png_set_read_fn; external pngDLL;
+procedure png_set_read_status_fn; external pngDLL;
+procedure png_set_read_user_transform_fn; external pngDLL;
+procedure png_set_sBIT; external pngDLL;
+procedure png_set_sRGB; external pngDLL;
+procedure png_set_sRGB_gAMA_and_cHRM; external pngDLL;
+procedure png_set_shift; external pngDLL;
+procedure png_set_sig_bytes; external pngDLL;
+procedure png_set_strip_16; external pngDLL;
+procedure png_set_strip_alpha; external pngDLL;
+procedure png_set_swap; external pngDLL;
+procedure png_set_swap_alpha; external pngDLL;
+procedure png_set_tIME; external pngDLL;
+procedure png_set_tRNS; external pngDLL;
+procedure png_set_text; external pngDLL;
+procedure png_set_write_fn; external pngDLL;
+procedure png_set_write_status_fn; external pngDLL;
+procedure png_set_write_user_transform_fn; external pngDLL;
+function png_sig_cmp; external pngDLL;
+procedure png_start_read_image; external pngDLL;
+procedure png_write_chunk; external pngDLL;
+procedure png_write_chunk_data; external pngDLL;
+procedure png_write_chunk_end; external pngDLL;
+procedure png_write_chunk_start; external pngDLL;
+procedure png_write_end; external pngDLL;
+procedure png_write_flush; external pngDLL;
+procedure png_write_image; external pngDLL;
+procedure png_write_info; external pngDLL;
+procedure png_write_row; external pngDLL;
+procedure png_write_rows; external pngDLL;
+
+end.

scripts/pngdll.mak

@@ -0,0 +1,53 @@
+# Makefile for png32bd.dll
+# ------------- Borland C++ 4.5 -------------
+
+# This makefile expects to find zlib.h and zlib32bd.lib in the
+# $(ZLIBDIR) directory.
+
+# The object files here are compiled with the "stdcall" calling convention.
+# This DLL requires zlib32bd.lib to be compiled in the same way.
+
+# Note that png32bd.dll exports the zlib functions adler32, crc32 and
+# the deflate... and inflate... functions. It does not export the
+# compress and uncompress functions, nor any of the gz... functions,
+# since libpng does not call them.
+
+ZLIBDIR=..\zlib112
+ZLIB=zlib32bd.lib
+PNGDLL=png32bd.dll
+
+CFLAGS= -ps -O2 -C -K -N- -k- -d -3 -r- -w-par -w-aus -WDE -I$(ZLIBDIR)
+CC=f:\bc45\bin\bcc32
+LINKFLAGS= -Tpd -aa -c
+LINK=f:\bc45\bin\tlink32
+LIBDIR=f:\bc45\lib
+IMPLIB=f:\bc45\bin\implib
+
+.autodepend
+.c.obj:
+        $(CC) -c $(CFLAGS) $<
+ 
+OBJ1=png.obj pngerror.obj pngget.obj pngmem.obj pngpread.obj 
+OBJ2=pngread.obj pngrio.obj pngrtran.obj pngrutil.obj pngset.obj 
+OBJ3=pngtrans.obj pngwio.obj pngwrite.obj pngwtran.obj pngwutil.obj
+
+all: $(PNGDLL)
+
+$(PNGDLL): $(OBJ1) $(OBJ2) $(OBJ3) $(ZLIBDIR)\$(ZLIB)
+        $(LINK) @&&|
+$(LINKFLAGS) $(LIBDIR)\c0d32 +
+$(OBJ1) +
+$(OBJ2) +
+$(OBJ3)
+$@
+-x
+$(ZLIBDIR)\$(ZLIB) $(LIBDIR)\import32 $(LIBDIR)\cw32
+|,&&|
+LIBRARY $(@B)
+EXETYPE WINDOWS
+CODE PRELOAD MOVEABLE DISCARDABLE
+DATA PRELOAD MOVEABLE MULTIPLE
+|
+        $(IMPLIB) -c $(@R).lib $@
+
+# End of makefile for png32bd.dll

scripts/pngos2.def

@@ -12,7 +12,9 @@ EXPORTS
   png_sig_cmp
   png_check_sig
   png_create_read_struct
+; png_create_read_struct_2
   png_create_write_struct
+; png_create_write_struct_2
   png_write_chunk
   png_write_chunk_start
   png_write_chunk_data
@@ -72,6 +74,8 @@ EXPORTS
   png_init_io
   png_set_error_fn
   png_get_error_ptr
+; png_get_mem_fn
+; png_set_mem_fn
   png_set_write_fn
   png_set_read_fn
   png_set_write_status_fn
@@ -89,8 +93,8 @@ EXPORTS
   png_free
   png_memcpy_check
   png_memset_check
-; png_debug_malloc
-; png_debug_free
+; png_malloc_default
+; png_free_default
 ; png_far_to_near
   png_error
   png_chunk_error

scripts/zlibdef.pas

@@ -0,0 +1,169 @@
+unit zlibdef;
+
+interface
+
+uses
+  Windows;
+
+const
+  ZLIB_VERSION = '1.1.2';
+
+type
+  voidpf = Pointer;
+  int    = Integer;
+  uInt   = Cardinal;
+  pBytef = PChar;
+  uLong  = Cardinal;
+
+  alloc_func = function(opaque: voidpf; items, size: uInt): voidpf;
+                    stdcall;
+  free_func  = procedure(opaque, address: voidpf);
+                    stdcall;
+
+  internal_state = Pointer;
+
+  z_streamp = ^z_stream;
+  z_stream = packed record
+    next_in: pBytef;          // next input byte
+    avail_in: uInt;           // number of bytes available at next_in
+    total_in: uLong;          // total nb of input bytes read so far
+
+    next_out: pBytef;         // next output byte should be put there
+    avail_out: uInt;          // remaining free space at next_out
+    total_out: uLong;         // total nb of bytes output so far
+
+    msg: PChar;               // last error message, NULL if no error
+    state: internal_state;    // not visible by applications
+
+    zalloc: alloc_func;       // used to allocate the internal state
+    zfree: free_func;         // used to free the internal state
+    opaque: voidpf;           // private data object passed to zalloc and zfree
+
+    data_type: int;           // best guess about the data type: ascii or binary
+    adler: uLong;             // adler32 value of the uncompressed data
+    reserved: uLong;          // reserved for future use
+    end;
+
+const
+  Z_NO_FLUSH      = 0;
+  Z_SYNC_FLUSH    = 2;
+  Z_FULL_FLUSH    = 3;
+  Z_FINISH        = 4;
+
+  Z_OK            = 0;
+  Z_STREAM_END    = 1;
+
+  Z_NO_COMPRESSION         =  0;
+  Z_BEST_SPEED             =  1;
+  Z_BEST_COMPRESSION       =  9;
+  Z_DEFAULT_COMPRESSION    = -1;
+
+  Z_FILTERED            = 1;
+  Z_HUFFMAN_ONLY        = 2;
+  Z_DEFAULT_STRATEGY    = 0;
+
+  Z_BINARY   = 0;
+  Z_ASCII    = 1;
+  Z_UNKNOWN  = 2;
+
+  Z_DEFLATED    = 8;
+
+  MAX_MEM_LEVEL = 9;
+
+function adler32(adler: uLong; const buf: pBytef; len: uInt): uLong;
+             stdcall;
+function crc32(crc: uLong; const buf: pBytef; len: uInt): uLong;
+             stdcall;
+function deflate(strm: z_streamp; flush: int): int;
+             stdcall;
+function deflateCopy(dest, source: z_streamp): int;
+             stdcall;
+function deflateEnd(strm: z_streamp): int;
+             stdcall;
+function deflateInit2_(strm: z_streamp; level, method,
+                       windowBits, memLevel, strategy: int;
+                       const version: PChar; stream_size: int): int;
+             stdcall;
+function deflateInit_(strm: z_streamp; level: int;
+                      const version: PChar; stream_size: int): int;
+             stdcall;
+function deflateParams(strm: z_streamp; level, strategy: int): int;
+             stdcall;
+function deflateReset(strm: z_streamp): int;
+             stdcall;
+function deflateSetDictionary(strm: z_streamp;
+                              const dictionary: pBytef;
+                              dictLength: uInt): int;
+             stdcall;
+function inflate(strm: z_streamp; flush: int): int;
+             stdcall;
+function inflateEnd(strm: z_streamp): int;
+             stdcall;
+function inflateInit2_(strm: z_streamp; windowBits: int;
+                       const version: PChar; stream_size: int): int;
+             stdcall;
+function inflateInit_(strm: z_streamp; const version: PChar;
+                      stream_size: int): int;
+             stdcall;
+function inflateReset(strm: z_streamp): int;
+             stdcall;
+function inflateSetDictionary(strm: z_streamp;
+                              const dictionary: pBytef;
+                              dictLength: uInt): int;
+             stdcall;
+function inflateSync(strm: z_streamp): int;
+             stdcall;
+
+function deflateInit(strm: z_streamp; level: int): int;
+function deflateInit2(strm: z_streamp; level, method, windowBits,
+                      memLevel, strategy: int): int;
+function inflateInit(strm: z_streamp): int;
+function inflateInit2(strm: z_streamp; windowBits: int): int;
+
+implementation
+
+function deflateInit(strm: z_streamp; level: int): int;
+begin
+  Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function deflateInit2(strm: z_streamp; level, method, windowBits,
+                      memLevel, strategy: int): int;
+begin
+  Result := deflateInit2_(strm, level, method, windowBits, memLevel,
+                          strategy, ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function inflateInit(strm: z_streamp): int;
+begin
+  Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function inflateInit2(strm: z_streamp; windowBits: int): int;
+begin
+  Result := inflateInit2_(strm, windowBits, ZLIB_VERSION,
+                          sizeof(z_stream));
+end;
+
+const
+  zlibDLL = 'png32bd.dll';
+
+function adler32; external zlibDLL;
+function crc32; external zlibDLL;
+function deflate; external zlibDLL;
+function deflateCopy; external zlibDLL;
+function deflateEnd; external zlibDLL;
+function deflateInit2_; external zlibDLL;
+function deflateInit_; external zlibDLL;
+function deflateParams; external zlibDLL;
+function deflateReset; external zlibDLL;
+function deflateSetDictionary; external zlibDLL;
+function inflate; external zlibDLL;
+function inflateEnd; external zlibDLL;
+function inflateInit2_; external zlibDLL;
+function inflateInit_; external zlibDLL;
+function inflateReset; external zlibDLL;
+function inflateSetDictionary; external zlibDLL;
+function inflateSync; external zlibDLL;
+
+end.

scripts/zlibdll.mak

@@ -0,0 +1,36 @@
+# Makefile for zlib32bd.lib
+# ------------- Borland C++ 4.5 -------------
+
+# The (32-bit) zlib32bd.lib made with this makefile is intended for use 
+# in making the (32-bit) DLL, png32bd.dll. It uses the "stdcall" calling 
+# convention.
+
+CFLAGS= -ps -O2 -C -K -N- -k- -d -3 -r- -w-par -w-aus -WDE
+CC=f:\bc45\bin\bcc32
+LIBFLAGS= /C
+LIB=f:\bc45\bin\tlib
+ZLIB=zlib32bd.lib
+
+.autodepend
+.c.obj:
+        $(CC) -c $(CFLAGS) $<
+
+OBJ1=adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infblock.obj 
+OBJ2=infcodes.obj inflate.obj inftrees.obj infutil.obj inffast.obj 
+OBJ3=trees.obj uncompr.obj zutil.obj
+pOBJ1=+adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infblock.obj 
+pOBJ2=+infcodes.obj+inflate.obj+inftrees.obj+infutil.obj+inffast.obj 
+pOBJ3=+trees.obj+uncompr.obj+zutil.obj
+
+all: $(ZLIB)
+
+$(ZLIB): $(OBJ1) $(OBJ2) $(OBJ3)
+        @if exist $@ del $@
+        $(LIB) @&&|
+$@ $(LIBFLAGS) &
+$(pOBJ1) &
+$(pOBJ2) &
+$(pOBJ3)
+|
+
+# End of makefile for zlib32bd.lib