Imported from libpng-1.0.4e.tar

ANNOUNCE

@@ -0,0 +1,94 @@
+
+Libpng 1.0.4e - October 10, 1999
+
+This is not intended to be a public release.  It will be replaced
+within a few weeks by a public version or by another test version.
+
+Changes since the last public release (1.0.3):
+
+version 1.0.3a [August 12, 1999]
+  Added check for PNG_READ_INTERLACE_SUPPORTED in pngread.c; issue a warning
+     if an attempt is made to read an interlaced image when it's not supported.
+  Added check if png_ptr->trans is defined before free'ing it in pngread.c
+  Modified the Y2K statement to include versions back to version 0.71
+  Fixed a bug in the check for valid IHDR bit_depth/color_types in pngrutil.c
+  Modified makefile.wat (added -zp8 flag, ".symbolic", changed some comments)
+  Replaced leading blanks with tab characters in makefile.hux
+  Changed "dworkin.wustl.edu" to "ccrc.wustl.edu" in various documents.
+  Changed (float)red and (float)green to (double)red, (double)green
+     in png_set_rgb_to_gray() to avoid "promotion" problems in AIX.
+  Fixed a bug in pngconf.h that omitted <stdio.h> when PNG_DEBUG==0 (K Bracey).
+  Reformatted libpng.3 and libpngpf.3 with proper fonts (script by J. vanZandt).
+  Updated documentation to refer to the PNG-1.2 specification.
+  Removed ansi2knr.c and left pointers to the latest source for ansi2knr.c
+    in makefile.knr, INSTALL, and README (L. Peter Deutsch)
+  Fixed bugs in calculation of the length of rowbytes when adding alpha
+    channels to 16-bit images, in pngrtran.c (Chris Nokleberg)
+  Added function png_set_user_transform_info() to store user_transform_ptr,
+    user_depth, and user_channels into the png_struct, and a function
+    png_get_user_transform_ptr() to retrieve the pointer (Chris Nokleberg)
+  Added function png_set_empty_plte_permitted() to make libpng useable
+    in MNG applications.
+  Corrected the typedef for png_free_ptr in png.h (Jesse Jones).
+  Correct gamma with srgb is 45455 instead of 45000 in pngrutil.c, to be
+    consistent with PNG-1.2, and allow variance of 500 before complaining.
+  Added assembler code contributed by Intel in file pngvcrd.c and modified
+    makefile.w32 to use it (Nirav Chhatrapati, INTEL Corporation, Gilles Vollant)
+  Changed "ln -s -f" to "ln -f -s" in the makefiles to make Solaris happy.
+  Added some aliases for png_set_expand() in pngrtran.c, namely
+    png_set_expand_PLTE(), png_set_expand_depth(), and png_set_expand_tRNS()
+    (Greg Roelofs, in "PNG: The Definitive Guide").
+  Added makefile.beo for BEOS on X86, contributed by Sander Stok.
+version 1.0.3b [August 26, 1999]
+  Replaced 2147483647L several places with PNG_MAX_UINT macro, defined in png.h
+  Changed leading blanks to tabs in all makefiles.
+  Define PNG_USE_PNGVCRD in makefile.w32, to get MMX assembler code.
+  Made alternate versions of  png_set_expand() in pngrtran.c, namely
+    png_set_gray_1_2_4_to_8, png_set_palette_to_rgb, and png_set_tRNS_to_alpha
+    (Greg Roelofs, in "PNG: The Definitive Guide").  Deleted the 1.0.3a aliases.
+  Relocated start of 'extern "C"' block in png.h so it doesn't include pngconf.h
+  Revised calculation of num_blocks in pngmem.c to avoid a potentially
+    negative shift distance, whose results are undefined in the C language.
+  Added a check in pngset.c to prevent writing multiple tIME chunks.
+  Added a check in pngwrite.c to detect invalid small window_bits sizes.
+version 1.0.3d [September 4, 1999]
+  Fixed type casting of igamma in pngrutil.c
+  Added new png_expand functions to scripts/pngdef.pas and pngos2.def
+  Added a demo read_user_transform_fn that examines the row filters in pngtest.c
+version 1.0.4 [September 24, 1999]
+  Define PNG_ALWAYS_EXTERN in pngconf.h if __STDC__ is defined
+  Delete #define PNG_INTERNAL and include "png.h" from pngasmrd.h
+  Made several minor corrections to pngtest.c
+  Changed "hptr += 16L" to "hptr = hptr + 16L" in pngmem.c for Turbo 3.0
+  Renamed the makefiles with longer but more user friendly extensions.
+  Copied the PNG copyright and license to a separate LICENSE file.
+  Revised documentation, png.h, and example.c to remove reference to
+    "viewing_gamma" which no longer appears in the PNG specification.
+  Revised pngvcrd.c to use MMX code for interlacing only on the final pass.
+  Updated pngvcrd.c to use the faster C filter algorithms from libpng-1.0.1a
+  Split makefile.win32vc into two versions, makefile.vcawin32 (uses MMX
+    assembler code) and makefile.vcwin32 (doesn't).
+  Added a CPU timing report to pngtest.c (enabled by defining PNGTEST_TIMING)
+  Added a copy of pngnow.png to the distribution.
+version 1.0.4a September 25, 1999
+  Increase max_pixel_depth in pngrutil.c if a user transform needs it.
+  Changed several division operations to right-shifts in pngvcrd.c
+version 1.0.4b September 30, 1999
+  Added parentheses in line 3732 of pngvcrd.c
+  Added a comment in makefile.linux warning about buggy -O3 in pgcc 2.95.1
+  Added a "png_check_version" function in png.c and pngtest.c that will generate
+    a helpful compiler error if an old png.h is found in the search path.
+version 1.0.4c October 1, 1999
+  Changed type of png_user_transform_depth|channels from int to png_byte.
+version 1.0.4e [October 10, 1999]
+  Changed 0.45 to 0.45455 in png_set_sRGB()
+  Removed unused PLTE entries from pngnow.png
+  Re-enabled some parts of pngvcrd.c (png_combine_row) that work properly.
+version 1.0.4e [October 10, 1999]
+  Fixed sign error in pngvcrd.c (Greg Roelofs)
+  Replaced some instances of memcpy with simple assignments in pngvcrd (GR-P)
+
+Send comments/corrections/commendations to
+png-implement@ccrc.wustl.edu or to randeg@alum.rpi.edu
+
+Glenn R-P

CHANGES

@@ -1,189 +1,469 @@
-pngchange.txt - changes for libpng
+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.
-   added RFC 1152 date support
-   fixed bug in gamma handling of 4-bit grayscale
-   added more typecasts. 65536L becomes (png_uint_32)65536L, etc.
-   minor corrections in libpng.txt
-   added simple sRGB support
-   make it simpler to do conditional compiling: PNG_READ_NOT_FULLY_SUPPORTED
-   fixed memory leak in pngwrite.c (free info_ptr->text)
-   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
-   added "-m" option to pngtest
-   [anything else?  2-bit grayscale gamma bug?]
-   regularized version numbering scheme and bumped shared-library major
-      version number to 2 to avoid potential problems with libpng 0.89 apps
+  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
+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
+version 0.99a [January 31, 1998]
+  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.
+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.
+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
+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)
+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
+version 0.99g [March 6, 1998, morning]
+  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
+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
+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)
+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.1e [June 6, 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).
+version 1.0.2 [June 14, 1998]
+  Fixed two bugs in makefile.bor .
+version 1.0.2a [December 30, 1998]
+  Replaced and extended code that was removed from png_set_filler() in 1.0.1a.
+  Fixed a bug in png_do_filler() that made it fail to write filler bytes in
+    the left-most pixel of each row (Kevin Bracey).
+  Changed "static pngcharp tIME_string" to "static char tIME_string[30]"
+    in pngtest.c (Duncan Simpson).
+  Fixed a bug in pngtest.c that caused pngtest to try to write a tIME chunk
+    even when no tIME chunk was present in the source file.
+  Fixed a problem in pngrutil.c: gray_to_rgb didn't always work with 16-bit.
+  Fixed a problem in png_read_push_finish_row(), which would not skip some
+    passes that it should skip, for images that are less than 3 pixels high.
+  Interchanged the order of calls to png_do_swap() and png_do_shift()
+    in pngwtran.c (John Cromer).
+  Added #ifdef PNG_DEBUG/#endif surrounding use of PNG_DEBUG in png.h .
+  Changed "bad adaptive filter type" from error to warning in pngrutil.c .
+  Fixed a documentation error about default filtering with 8-bit indexed-color.
+  Separated the PNG_NO_STDIO macro into PNG_NO_STDIO and PNG_NO_CONSOLE_IO
+    (L. Peter Deutsch).
+  Added png_set_rgb_to_gray() and png_get_rgb_to_gray_status() functions.
+  Added png_get_copyright() and png_get_header_version() functions.
+  Revised comments on png_set_progressive_read_fn() in libpng.txt and example.c
+  Added information about debugging in libpng.txt and libpng.3 .
+  Changed "ln -sf" to "ln -s -f" in makefile.s2x, makefile.lnx, and makefile.sco.
+  Removed lines after Dynamic Dependencies" in makefile.aco .
+  Revised makefile.dec to make a shared library (Jeremie Petit).
+  Removed trailing blanks from all files. 
+version 1.0.2a [January 6, 1999]
+  Removed misplaced #endif and #ifdef PNG_NO_EXTERN near the end of png.h
+  Added "if" tests to silence complaints about unused png_ptr in png.h and png.c
+  Changed "check_if_png" function in example.c to return true (nonzero) if PNG.
+  Changed libpng.txt to demonstrate png_sig_cmp() instead of png_check_sig()
+    which is obsolete.
+version 1.0.3 [January 14, 1999]
+  Added makefile.hux, for Hewlett Packard HPUX 10.20 and 11.00 (Jim Rice)
+  Added a statement of Y2K compliance in png.h, libpng.3, and Y2KINFO.
+version 1.0.3a [August 12, 1999]
+  Added check for PNG_READ_INTERLACE_SUPPORTED in pngread.c; issue a warning
+     if an attempt is made to read an interlaced image when it's not supported.
+  Added check if png_ptr->trans is defined before free'ing it in pngread.c
+  Modified the Y2K statement to include versions back to version 0.71
+  Fixed a bug in the check for valid IHDR bit_depth/color_types in pngrutil.c
+  Modified makefile.wat (added -zp8 flag, ".symbolic", changed some comments)
+  Replaced leading blanks with tab characters in makefile.hux
+  Changed "dworkin.wustl.edu" to "ccrc.wustl.edu" in various documents.
+  Changed (float)red and (float)green to (double)red, (double)green
+     in png_set_rgb_to_gray() to avoid "promotion" problems in AIX.
+  Fixed a bug in pngconf.h that omitted <stdio.h> when PNG_DEBUG==0 (K Bracey).
+  Reformatted libpng.3 and libpngpf.3 with proper fonts (script by J. vanZandt).
+  Updated documentation to refer to the PNG-1.2 specification.
+  Removed ansi2knr.c and left pointers to the latest source for ansi2knr.c
+    in makefile.knr, INSTALL, and README (L. Peter Deutsch)
+  Fixed bugs in calculation of the length of rowbytes when adding alpha
+    channels to 16-bit images, in pngrtran.c (Chris Nokleberg)
+  Added function png_set_user_transform_info() to store user_transform_ptr,
+    user_depth, and user_channels into the png_struct, and a function
+    png_get_user_transform_ptr() to retrieve the pointer (Chris Nokleberg)
+  Added function png_set_empty_plte_permitted() to make libpng useable
+    in MNG applications.
+  Corrected the typedef for png_free_ptr in png.h (Jesse Jones).
+  Correct gamma with srgb is 45455 instead of 45000 in pngrutil.c, to be
+    consistent with PNG-1.2, and allow variance of 500 before complaining.
+  Added assembler code contributed by Intel in file pngvcrd.c and modified
+    makefile.w32 to use it (Nirav Chhatrapati, INTEL Corporation, Gilles Vollant)
+  Changed "ln -s -f" to "ln -f -s" in the makefiles to make Solaris happy.
+  Added some aliases for png_set_expand() in pngrtran.c, namely
+    png_set_expand_PLTE(), png_set_expand_depth(), and png_set_expand_tRNS()
+    (Greg Roelofs, in "PNG: The Definitive Guide").
+  Added makefile.beo for BEOS on X86, contributed by Sander Stok.
+version 1.0.3b [August 26, 1999]
+  Replaced 2147483647L several places with PNG_MAX_UINT macro, defined in png.h
+  Changed leading blanks to tabs in all makefiles.
+  Define PNG_USE_PNGVCRD in makefile.w32, to get MMX assembler code.
+  Made alternate versions of  png_set_expand() in pngrtran.c, namely
+    png_set_gray_1_2_4_to_8, png_set_palette_to_rgb, and png_set_tRNS_to_alpha
+    (Greg Roelofs, in "PNG: The Definitive Guide").  Deleted the 1.0.3a aliases.
+  Relocated start of 'extern "C"' block in png.h so it doesn't include pngconf.h
+  Revised calculation of num_blocks in pngmem.c to avoid a potentially
+    negative shift distance, whose results are undefined in the C language.
+  Added a check in pngset.c to prevent writing multiple tIME chunks.
+  Added a check in pngwrite.c to detect invalid small window_bits sizes.
+version 1.0.3d [September 4, 1999]
+  Fixed type casting of igamma in pngrutil.c
+  Added new png_expand functions to scripts/pngdef.pas and pngos2.def
+  Added a demo read_user_transform_fn that examines the row filters in pngtest.c
+version 1.0.4 [September 24, 1999]
+  Define PNG_ALWAYS_EXTERN in pngconf.h if __STDC__ is defined
+  Delete #define PNG_INTERNAL and include "png.h" from pngasmrd.h
+  Made several minor corrections to pngtest.c
+  Renamed the makefiles with longer but more user friendly extensions.
+  Copied the PNG copyright and license to a separate LICENSE file.
+  Revised documentation, png.h, and example.c to remove reference to
+    "viewing_gamma" which no longer appears in the PNG specification.
+  Revised pngvcrd.c to use MMX code for interlacing only on the final pass.
+  Updated pngvcrd.c to use the faster C filter algorithms from libpng-1.0.1a
+  Split makefile.win32vc into two versions, makefile.vcawin32 (uses MMX
+    assembler code) and makefile.vcwin32 (doesn't).
+  Added a CPU timing report to pngtest.c (enabled by defining PNGTEST_TIMING)
+  Added a copy of pngnow.png to the distribution.
+version 1.0.4a [September 25, 1999]
+  Increase max_pixel_depth in pngrutil.c if a user transform needs it.
+  Changed several division operations to right-shifts in pngvcrd.c
+version 1.0.4b [September 30, 1999]
+  Added parentheses in line 3732 of pngvcrd.c
+  Added a comment in makefile.linux warning about buggy -O3 in pgcc 2.95.1
+version 1.0.4c [October 1, 1999]
+  Added a "png_check_version" function in png.c and pngtest.c that will generate
+    a helpful compiler error if an old png.h is found in the search path.
+  Changed type of png_user_transform_depth|channels from int to png_byte.
+version 1.0.4d [October 6, 1999]
+  Changed 0.45 to 0.45455 in png_set_sRGB()
+  Removed unused PLTE entries from pngnow.png
+  Re-enabled some parts of pngvcrd.c (png_combine_row) that work properly.
+version 1.0.4e [October 10, 1999]
+  Fixed sign error in pngvcrd.c (Greg Roelofs)
+  Replaced some instances of memcpy with simple assignments in pngvcrd (GR-P)

INSTALL

@@ -0,0 +1,99 @@
+
+Installing libpng version 1.0.4e - October 10, 1999
+
+Before installing libpng, you must first install zlib.  zlib
+can usually be found wherever you got libpng.  zlib can be
+placed in another directory, at the same level as libpng.
+Note that your system might already have a preinstalled
+zlib, but you will still need to have access to the
+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.4e" or "lpng103" and "zlib-1.1.3"
+or "zlib113") so that you have directories called "zlib" and "libpng".
+
+Your directory structure should look like this:
+
+   ..       (the parent directory)
+      libpng  (this directory)
+          INSTALL (this file)
+          README
+          *.h
+          *.c
+          scripts
+             makefile.*
+          pngtest.png
+          etc.
+      zlib
+          README
+          *.h
+          *.c
+          contrib
+          etc.
+
+First enter the zlib directory and follow the instructions
+in zlib/README.  Then come back here and choose the
+appropriate makefile.sys in the scripts directory.
+The files that are presently available in the scripts directory
+include
+
+ descrip.mms      =>  VMS makefile for MMS or MMK
+ makefile.std     =>  Generic UNIX makefile
+ makefile.knr     =>  Archaic UNIX Makefile that converts files with
+                      ansi2knr (Requires ansi2knr.c from
+                      ftp://ftp.cs.wisc.edu/ghost)
+ makefile.dec     =>  DEC Alpha UNIX makefile
+ makefile.hpux    =>  HPUX (10.20 and 11.00) makefile
+ makefile.sgi     =>  Silicon Graphics IRIX makefile
+ makefile.sunos   =>  Sun makefile
+ makefile.solaris =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.0.4e)
+ makefile.linux   =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0.4e)
+ makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc
+ makefile.mips    =>  MIPS makefile
+ makefile.acorn   =>  Acorn makefile
+ makefile.amiga   =>  Amiga makefile
+ smakefile.ppc    =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                   (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+ makefile.atari   =>  Atari makefile
+ makefile.beos    =>  BEOS makefile for X86
+ makefile.borland =>  Borland makefile
+ build.bat        =>  MS-DOS batch file for Borland compiler
+ makefile.dj2     =>  DJGPP 2 makefile
+ makefile.msc     =>  Microsoft C makefile
+ makefile.vcawin32 => makefile for Microsoft Visual C++ 5.0 and later (uses
+                      assembler code)
+ makefile.vcwin32 =>  makefile for Microsoft Visual C++ 4.0 and later (does not
+                      use assembler code)
+ makefile.turboc3 =>  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.watcom  =>  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
+ SCOPTIONS.ppc    =>  Used with smakefile.ppc
+
+Copy the file (or files) that you need from the
+scripts directory into this directory, for example
+
+   MSDOS example: copy scripts\makefile.msd makefile
+   UNIX example:    cp scripts/makefile.std makefile
+
+Read the makefile to see if you need to change any source or
+target directories to match your preferences.
+
+Then read pngconf.h to see if you want to make any configuration
+changes.
+
+Then just run "make test" which will create the libpng library in
+this directory and run a quick test that reads the "pngtest.png"
+file and writes a "pngout.png" file that should be identical to it.
+
+Most of the makefiles will allow you to run "make install" to
+put the library in its final resting place (if you want to
+do that, run "make install" in the zlib directory first if necessary).
+
+Further information can be found in the README and libpng.txt
+files, in the individual makefiles, and in png.h, and the manual
+pages libpng.3 and png.5.

KNOWNBUG

@@ -0,0 +1,58 @@
+
+Known bugs and suggested enhancements in libpng-1.0.4
+
+
+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.5.  About 160 loops will be turned around
+   in libpng-1.0.Nn, for testing.
+
+2. July 4, 1998 -- ENHANCEMENT -- Glenn R-P
+
+   libpng-1.0.5 and earlier transform colors to gamma=1.0 space for
+   merging with background, and then back to the image's gamma.  The
+   bit_depth of the intermediate (gamma=1.0) representation is probably
+   not sufficient.  In the typical gamma=1/2.2 situation, the linear
+   pixels need about 4 more bits than the gamma-encoded ones, to avoid
+   loss of precision.  A similar situation exists with the rgb_to_gray
+   operation.
+
+   STATUS: under development.
+
+3. September 1999 -- ENHANCEMENT --
+
+   It should be possible to use libpng without floating-point aritmetic.
+
+   STATUS: Under investigation, implementation postponed until after
+   libpng-1.0.5.  The application interface will change because replacements
+   for the png_set_gAMA(), png_set_cHRM(), and corresponding png_get_()
+   functions will be needed.
+
+4. September 1999 -- BUG [FIXED] --
+
+   Portions of the new MMX code in pngvcrd.c were ifdef'd out because they
+   didn't work properly, but the bug appears to have been found and fixed.
+   As a result, all parts of the code are once again enabled.  If you think
+   there's still a problem, you can recompile with one of the following two
+   macros defined and see if the problem goes away:
+
+	DISABLE_PNGVCRD_COMBINE
+	DISABLE_PNGVCRD_INTERLACE
+
+   The second one is in the function where the bug was; as far as we are
+   aware, there was never any bug in the other function.  Please notify us
+   if you find any problems in libpng, regardless of whether the two macros
+   make any difference:  png-implement@ccrc.wustl.edu
+
+   Again, we believe the MMX code in pngvcrd.c is 100% correct, but it has
+   not yet been tested extensively.

LICENSE

@@ -0,0 +1,59 @@
+COPYRIGHT NOTICE:
+
+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+(libpng versions 0.5, May 1995, through 0.89c, May 1996)
+Copyright (c) 1996, 1997 Andreas Dilger
+(libpng versions 0.90, December 1996, through 0.96, May 1997)
+Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+(libpng versions 0.97, January 1998, through 1.0.4e, October 10, 1999)
+
+For the purposes of this copyright and license, "Contributing Authors"
+is defined as the following set of individuals:
+
+   John Bowler
+   Kevin Bracey
+   Sam Bushell
+   Andreas Dilger
+   Magnus Holmgren
+   Tom Lane
+   Dave Martindale
+   Glenn Randers-Pehrson
+   Greg Roelofs
+   Guy Eric Schalnat
+   Paul Schmidt
+   Tom Tanner
+   Willem van Schaik
+   Tim Wegner
+
+The PNG Reference Library is supplied "AS IS".  The Contributing Authors
+and Group 42, Inc. disclaim all warranties, expressed or implied,
+including, without limitation, the warranties of merchantability and of
+fitness for any purpose.  The Contributing Authors and Group 42, Inc.
+assume no liability for direct, indirect, incidental, special, exemplary,
+or consequential damages, which may result from the use of the PNG
+Reference Library, even if advised of the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+ 1. The origin of this source code must not be
+    misrepresented.
+
+ 2. Altered versions must be plainly marked as such
+    and must not be misrepresented as being the
+    original source.
+
+ 3. This Copyright notice may not be removed or
+    altered from any source or altered source
+    distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit, without
+fee, and encourage the use of this source code as a component to
+supporting the PNG file format in commercial products.  If you use this
+source code in a product, acknowledgment is not required but would be
+appreciated.
+
+Glenn Randers-Pehrson
+randeg@alum.rpi.edu
+October 10, 1999

README

@@ -1,12 +1,11 @@
-[NOTE:  this is still beta version 0.97c; the text below has already
- been updated in anticipation of the imminent 1.0 release.]
+README for libpng 1.0.4e - October 10, 1999 (shared library 2.1)
+See the note about version numbers near the top of png.h
 
-
-README for libpng 1.0
+See INSTALL for instructions on how to install libpng.
 
 This is the first official release of libpng.  Don't let the fact that
 it's the first release fool you.  The libpng library has been in
-extensive use and testing for about two years.  However, it's
+extensive use and testing for about two and a half years.  However, it's
 finally gotten to the stage where there haven't been significant
 changes to the API in some time, and people have a bad feeling about
 libraries with versions < 1.0.
@@ -50,7 +49,7 @@ to set different actions based on whether the CRC error occurred in a
 critical or an ancillary chunk.
 
 The changes made to the library, and bugs fixed are based on discussions
-on the PNG implementation mailing list <png-implement@dworking.wustl.edu>
+on the PNG implementation mailing list <png-implement@ccrc.wustl.edu>
 and not on material submitted to Guy.
 
 For a detailed description on using libpng, read libpng.txt.  For
@@ -77,7 +76,7 @@ If not, it should be at ftp.uu.net in /graphics/png
 Eventually, it will be at ftp.uu.net in /pub/archiving/zip/zlib
 
 You may also want a copy of the PNG specification.  It is available
-as an Internet Draft, and RFC, and a W3C Recommendation.  Failing
+as an RFC and a W3C Recommendation.  Failing
 these resources you can try ftp.uu.net in the /graphics/png directory.
 
 This code is currently being archived at ftp.uu.net in the
@@ -97,19 +96,19 @@ Finally, if you get any warning messages when compiling libpng
 fix.  Please mention "libpng" somewhere in the subject line.  Thanks.
 
 This release was created and will be supported by myself (of course
-based in a large way on Guy's earlier work), and the PNG group.
+based in a large way on Guy's and Andreas' earlier work), and the PNG group.
 
-adilger@enel.ucalgary.ca
-png-implement@dworkin.wustl.edu
+randeg@alum.rpi.edu
+png-implement@ccrc.wustl.edu
 
-You can reach Guy, the original libpng author, at (internet preferred):
-
-internet: schalnat@group42.com
-CompuServe: 75501,1625
+You can't reach Guy, the original libpng author, at the addresses
+given in previous versions of this document.  He and Andreas will read mail
+addressed to the png-implement list, however.
 
 Please do not send general questions about PNG.  Send them to
-the address in the specification.  At the same time, please do
-not send libpng questions to that address, send them to me.  I'll
+the address in the specification (png-group@w3.org).  At the same
+time, please do not send libpng questions to that address, send them to me
+or to png-implement@ccrc.wustl.edu.  I'll
 get them in the end anyway.  If you have a question about something
 in the PNG specification that is related to using libpng, send it
 to me.  Send me any questions that start with "I was using libpng,
@@ -117,7 +116,7 @@ and ...".  If in doubt, send questions to me.  I'll bounce them
 to others, if necessary.
 
 Please do not send suggestions on how to change PNG.  We have
-been discussing PNG for a couple years now, and it is official and
+been discussing PNG for three years now, and it is official and
 finished.  If you have suggestions for libpng, however, I'll
 gladly listen.  Even if your suggestion is not used for version
 1.0, it may be used later.
@@ -127,28 +126,18 @@ Files in this distribution:
       CHANGES       =>  Description of changes between libpng versions
       README        =>  This file
       TODO          =>  Things not implemented in the current library
-      ansi2knr.c    =>  Converts files to K&R style function declarations
       build.bat     =>  MS-DOS batch file for Borland compiler
       descrip.mms   =>  VMS project file
       example.c     =>  Example code for using libpng functions
+      libpng.3      =>  manual page for libpng
       libpng.txt    =>  Description of libpng and its functions
-      makefile      =>  Default Unixish makefile
-      makefile.aco  =>  ACORN makefile
-      makefile.ama  =>  Amiga makefile
-      makefile.atr  =>  Atari makefile
-      makefile.bor  =>  Borland makefile
-      makefile.dj2  =>  DJGPP 2 makefile
-      makefile.elf  =>  Unix ELF makefile
-      makefile.knr  =>  Makefile which calls ansi2knr to convert files
-      makefile.mip  =>  MIPS makefile
-      makefile.msc  =>  Microsoft C makefile
-      makefile.std  =>  Standard Unix makefile
-      makefile.tc   =>  Turbo C makefile
-      makevms.com   =>  VMS make program
+      libpngpf.3    =>  manual page for libpng's private functions
+      png.5         =>  manual page for the PNG format
       png.c         =>  Basic interface functions common to library
       png.h         =>  Library function and interface declarations
       pngconf.h     =>  System specific library configuration
       pngerror.c    =>  Error/warning message I/O functions
+      pngget.c      =>  Functions for retrieving info from struct
       pngmem.c      =>  Memory handling functions
       pngpread.c    =>  Progressive reading functions
       pngread.c     =>  Read data/helper high-level functions
@@ -163,16 +152,56 @@ Files in this distribution:
       pngwrite.c    =>  High-level write functions
       pngwtran.c    =>  Write data transformations
       pngwutil.c    =>  Write utility functions
+      scripts       =>  Directory containing scripts for building libpng:
+       descrip.mms      =>  VMS makefile for MMS or MMK
+       makefile.std     =>  Generic UNIX makefile
+       makefile.knr     =>  Archaic UNIX Makefile that converts files with
+                            ansi2knr (Requires ansi2knr.c from
+                            ftp://ftp.cs.wisc.edu/ghost)
+       makefile.dec     =>  DEC Alpha UNIX makefile
+       makefile.hpux    =>  HPUX (10.20 and 11.00) makefile
+       makefile.sgi     =>  Silicon Graphics IRIX makefile
+       makefile.sunos   =>  Sun makefile
+       makefile.solaris =>  Solaris 2.X makefile
+                            (gcc, creates libpng.so.2.1.0.4e)
+       makefile.linux   =>  Linux/ELF makefile
+                            (gcc, creates libpng.so.2.1.0.4e)
+       makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc
+       makefile.mips    =>  MIPS makefile
+       makefile.acorn   =>  Acorn makefile
+       makefile.amiga   =>  Amiga makefile
+       smakefile.ppc    =>  AMIGA smakefile for SAS C V6.58/7.00 PPC
+                            compiler (Requires SCOPTIONS, copied from
+                            scripts/SCOPTIONS.ppc)
+       makefile.atari   =>  Atari makefile
+       makefile.beos    =>  BEOS makefile for X86
+       makefile.borland =>  Borland makefile
+       build.bat        =>  MS-DOS batch file for Borland compiler
+       makefile.dj2     =>  DJGPP 2 makefile
+       makefile.msc     =>  Microsoft C makefile
+       makefile.vcawin32 => makefile for Microsoft Visual C++ 5.0 and
+                            later (uses assembler code)
+       makefile.vcwin32 =>  makefile for Microsoft Visual C++ 4.0 and
+                            later (does not use assembler code)
+       makefile.turboc3 =>  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.watcom  =>  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
+       SCOPTIONS.ppc    =>  Used with smakefile.ppc
 
 Good luck, and happy coding.
 
+-Glenn Randers-Pehrson
+ Internet: randeg@alum.rpi.edu
+ Web: http://www.rpi.edu/~randeg/index.html
+
 -Andreas Eric Dilger
  Internet: adilger@enel.ucalgary.ca
  Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/
 
 -Guy Eric Schalnat
- Group 42, Inc.
- Internet: schalnat@group42.com
- CompuServe: 75501,1625
- Web: http://www.group42.com/
-
+ (formerly of Group 42, Inc)
+ Internet: gschal@infinet.com

TODO

@@ -1,20 +1,24 @@
-pngtodo.txt - list of things to do for libpng
+TODO - list of things to do for libpng:
 
-add "grayscale->palette" transformation and "palette->grayscale" detection
-improved dithering
-multi-lingual error and warning message support
-sPLT chunk handling
-cHRM transformation
-complete sRGB transformation (presently it simply uses gamma=0.5)
-man pages for function calls
-high-level API for reading images
-final bug fixes
-better documentation
-better filter selection
-   (counting huffman bits/precompression?  filter inertia?  filter costs?)
-optional palette creation
-histogram creation
-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)
+Final bug fixes.
+Fix problem with C++ and EXTERN "C".
+Better C++ wrapper/full C++ implementation?
+Keep up with public chunks.
+sPLT chunk handling.
+cHRM transformation.
+Support for application-defined chunk handlers.
+Improve setjmp/longjmp usage or remove it in favor of returning error codes.
+High-level API for reading images.
+Add "grayscale->palette" transformation and "palette->grayscale" detection.
+Improved dithering.
+Multi-lingual error and warning message support.
+Complete sRGB transformation (presently it simply uses gamma=0.45455).
+Man pages for function calls.
+Better documentation.
+Better filter selection
+   (counting huffman bits/precompression?  filter inertia?  filter costs?).
+Optional palette (sPLT) creation.
+Histogram creation.
+Text conversion between different code pages (Latin-1 -> Mac and DOS).
+Improve API by hiding the info_ptr.
+Make a no-floating-point version.

Y2KINFO

@@ -0,0 +1,55 @@
+   Y2K compliance in libpng:
+   =========================
+      
+      October 10, 1999
+      
+      Since the PNG Development group is an ad-hoc body, we can't make
+      an official declaration.
+      
+      This is your unofficial assurance that libpng from version 0.71 and
+      upward through 1.0.4e are Y2K compliant.  It is my belief that earlier
+      versions were also Y2K compliant.
+      
+      Libpng only has three year fields.  One is a 2-byte unsigned integer
+      that will hold years up to 65535.  The other two hold the date in text
+      format, and will hold years up to 9999.
+      
+      The integer is
+          "png_uint_16 year" in png_time_struct.
+      
+      The strings are
+          "png_charp time_buffer" in png_struct and
+          "near_time_buffer", which is a local character string in png.c.
+      
+      There are seven time-related functions:
+
+          png_convert_to_rfc_1123() in png.c 
+            (formerly png_convert_to_rfc_1152() in error)
+          png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+          png_convert_from_time_t() in pngwrite.c
+          png_get_tIME() in pngget.c
+          png_handle_tIME() in pngrutil.c, called in pngread.c
+          png_set_tIME() in pngset.c
+          png_write_tIME() in pngwutil.c, called in pngwrite.c
+      
+      All appear to handle dates properly in a Y2K environment.  The 
+      png_convert_from_time_t() function calls gmtime() to convert from system
+      clock time, which returns (year - 1900), which we properly convert to
+      the full 4-digit year.  There is a possibility that applications using
+      libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
+      function, or that they are incorrectly passing only a 2-digit year
+      instead of "year - 1900" into the png_convert_from_struct_tm() function,
+      but this is not under our control.  The libpng documentation has always
+      stated that it works with 4-digit years, and the APIs have been
+      documented as such.
+      
+      The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
+      integer to hold the year, and can hold years as large as 65535.
+
+      zlib, upon which libpng depends, is also Y2K compliant.  It contains
+      no date-related code.
+      
+      
+         Glenn Randers-Pehrson
+         libpng maintainer
+         PNG Development Group

ansi2knr.c

@@ -1,488 +0,0 @@
-/* Copyright (C) 1989, 1991, 1993 Aladdin Enterprises. All rights reserved. */
-
-/* ansi2knr.c */
-/* Convert ANSI function declarations to K&R syntax */
-
-/*
-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 works at all, unless he says so in writing.  Refer
-to the GNU General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute
-ansi2knr, but only under the conditions described in the GNU
-General Public License.  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 COPYING.  Among other
-things, the copyright notice and this notice must be preserved on all
-copies.
-*/
-
-/*
----------- Here is the GNU GPL file COPYING, referred to above ----------
------ These terms do NOT apply to the JPEG software itself; see README ------
-
-		    GHOSTSCRIPT GENERAL PUBLIC LICENSE
-		    (Clarified 11 Feb 1988)
-
- Copyright (C) 1988 Richard M. Stallman
- Everyone is permitted to copy and distribute verbatim copies of this
- license, but changing it is not allowed.  You can also use this wording
- to make the terms for other programs.
-
-  The license agreements of most software companies keep you at the
-mercy of those companies.  By contrast, our general public license is
-intended to give everyone the right to share Ghostscript.  To make sure
-that you get the rights we want you to have, we need to make
-restrictions that forbid anyone to deny you these rights or to ask you
-to surrender the rights.  Hence this license agreement.
-
-  Specifically, we want to make sure that you have the right to give
-away copies of Ghostscript, that you receive source code or else can get
-it if you want it, that you can change Ghostscript or use pieces of it
-in new free programs, and that you know you can do these things.
-
-  To make sure that everyone has such rights, we have to forbid you to
-deprive anyone else of these rights.  For example, if you distribute
-copies of Ghostscript, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must tell them their rights.
-
-  Also, for our own protection, we must make certain that everyone finds
-out that there is no warranty for Ghostscript.  If Ghostscript is
-modified by someone else and passed on, we want its recipients to know
-that what they have is not what we distributed, so that any problems
-introduced by others will not reflect on our reputation.
-
-  Therefore we (Richard M. Stallman and the Free Software Foundation,
-Inc.) make the following terms which say what you must do to be allowed
-to distribute or change Ghostscript.
-
-
-			COPYING POLICIES
-
-  1. You may copy and distribute verbatim copies of Ghostscript source
-code as you receive it, in any medium, provided that you conspicuously
-and appropriately publish on each copy a valid copyright and license
-notice "Copyright (C) 1989 Aladdin Enterprises.  All rights reserved.
-Distributed by Free Software Foundation, Inc." (or with whatever year is
-appropriate); keep intact the notices on all files that refer to this
-License Agreement and to the absence of any warranty; and give any other
-recipients of the Ghostscript program a copy of this License Agreement
-along with the program.  You may charge a distribution fee for the
-physical act of transferring a copy.
-
-  2. You may modify your copy or copies of Ghostscript or any portion of
-it, and copy and distribute such modifications under the terms of
-Paragraph 1 above, provided that you also do the following:
-
-    a) cause the modified files to carry prominent notices stating
-    that you changed the files and the date of any change; and
-
-    b) cause the whole of any work that you distribute or publish,
-    that in whole or in part contains or is a derivative of Ghostscript
-    or any part thereof, to be licensed at no charge to all third
-    parties on terms identical to those contained in this License
-    Agreement (except that you may choose to grant more extensive
-    warranty protection to some or all third parties, at your option).
-
-    c) You may charge a distribution fee for the physical act of
-    transferring a copy, and you may at your option offer warranty
-    protection in exchange for a fee.
-
-Mere aggregation of another unrelated program with this program (or its
-derivative) on a volume of a storage or distribution medium does not bring
-the other program under the scope of these terms.
-
-  3. You may copy and distribute Ghostscript (or a portion or derivative
-of it, under Paragraph 2) in object code or executable form under the
-terms of Paragraphs 1 and 2 above provided that you also do one of the
-following:
-
-    a) accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of
-    Paragraphs 1 and 2 above; or,
-
-    b) accompany it with a written offer, valid for at least three
-    years, to give any third party free (except for a nominal
-    shipping charge) a complete machine-readable copy of the
-    corresponding source code, to be distributed under the terms of
-    Paragraphs 1 and 2 above; or,
-
-    c) accompany it with the information you received as to where the
-    corresponding source code may be obtained.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form alone.)
-
-For an executable file, complete source code means all the source code for
-all modules it contains; but, as a special exception, it need not include
-source code for modules which are standard libraries that accompany the
-operating system on which the executable file runs.
-
-  4. You may not copy, sublicense, distribute or transfer Ghostscript
-except as expressly provided under this License Agreement.  Any attempt
-otherwise to copy, sublicense, distribute or transfer Ghostscript is
-void and your rights to use the program under this License agreement
-shall be automatically terminated.  However, parties who have received
-computer software programs from you with this License Agreement will not
-have their licenses terminated so long as such parties remain in full
-compliance.
-
-  5. If you wish to incorporate parts of Ghostscript into other free
-programs whose distribution conditions are different, write to the Free
-Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not
-yet worked out a simple rule that can be stated here, but we will often
-permit this.  We will be guided by the two goals of preserving the free
-status of all derivatives of our free software and of promoting the
-sharing and reuse of software.
-
-Your comments and suggestions about our licensing policies and our
-software are welcome!  Please contact the Free Software Foundation,
-Inc., 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
-
-		       NO WARRANTY
-
-  BECAUSE GHOSTSCRIPT IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
-NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
-WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD
-M. STALLMAN, ALADDIN ENTERPRISES, L. PETER DEUTSCH, AND/OR OTHER PARTIES
-PROVIDE GHOSTSCRIPT "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
-EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE
-ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GHOSTSCRIPT IS WITH
-YOU.  SHOULD GHOSTSCRIPT PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
-NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
-STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., L. PETER DEUTSCH, ALADDIN
-ENTERPRISES, AND/OR ANY OTHER PARTY WHO MAY MODIFY AND REDISTRIBUTE
-GHOSTSCRIPT AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
-ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
-(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
-INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE
-PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GHOSTSCRIPT, EVEN IF YOU
-HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM
-BY ANY OTHER PARTY.
-
--------------------- End of file COPYING ------------------------------
-*/
-
-
-#include <stdio.h>
-#include <ctype.h>
-
-#ifdef BSD
-#include <strings.h>
-#else
-#ifdef VMS
-	extern int strlen(), strncmp();
-#else
-#include <string.h>
-#endif
-#endif
-
-/* malloc and free should be declared in stdlib.h, */
-/* but if you've got a K&R compiler, they probably aren't. */
-#ifdef MSDOS
-#include <malloc.h>
-#else
-#ifdef VMS
-     extern char *malloc();
-     extern void free();
-#else
-     extern char *malloc();
-     extern int free();
-#endif
-#endif
-
-/* Usage:
-	ansi2knr input_file [output_file]
- * If no output_file is supplied, output goes to stdout.
- * There are no error messages.
- *
- * ansi2knr recognizes functions by seeing a non-keyword identifier
- * at the left margin, followed by a left parenthesis,
- * with a right parenthesis as the last character on the line.
- * It will recognize a multi-line header provided that the last character
- * of the last line of the header is a right parenthesis,
- * and no intervening line ends with a left brace or a semicolon.
- * These algorithms ignore whitespace and comments, except that
- * the function name must be the first thing on the line.
- * The following constructs will confuse it:
- *	- Any other construct that starts at the left margin and
- *	    follows the above syntax (such as a macro or function call).
- *	- Macros that tinker with the syntax of the function header.
- */
-
-/* Scanning macros */
-#define isidchar(ch) (isalnum(ch) || (ch) == '_')
-#define isidfirstchar(ch) (isalpha(ch) || (ch) == '_')
-
-/* Forward references */
-char *skipspace();
-int writeblanks();
-int test1();
-int convert1();
-
-/* The main program */
-main(argc, argv)
-    int argc;
-    char *argv[];
-{	FILE *in, *out;
-#define bufsize 5000			/* arbitrary size */
-	char *buf;
-	char *line;
-	switch ( argc )
-	   {
-	default:
-		printf("Usage: ansi2knr input_file [output_file]\n");
-		exit(0);
-	case 2:
-		out = stdout; break;
-	case 3:
-		out = fopen(argv[2], "w");
-		if ( out == NULL )
-		   {	fprintf(stderr, "Cannot open %s\n", argv[2]);
-			exit(1);
-		   }
-	   }
-	in = fopen(argv[1], "r");
-	if ( in == NULL )
-	   {	fprintf(stderr, "Cannot open %s\n", argv[1]);
-		exit(1);
-	   }
-	fprintf(out, "#line 1 \"%s\"\n", argv[1]);
-	buf = malloc(bufsize);
-	line = buf;
-	while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
-	   {	switch ( test1(buf) )
-		   {
-		case 1:			/* a function */
-			convert1(buf, out);
-			break;
-		case -1:		/* maybe the start of a function */
-			line = buf + strlen(buf);
-			if ( line != buf + (bufsize - 1) ) /* overflow check */
-				continue;
-			/* falls through */
-		default:		/* not a function */
-			fputs(buf, out);
-			break;
-		   }
-		line = buf;
-	   }
-	if ( line != buf ) fputs(buf, out);
-	free(buf);
-	fclose(out);
-	fclose(in);
-	return 0;
-}
-
-/* Skip over space and comments, in either direction. */
-char *
-skipspace(p, dir)
-    register char *p;
-    register int dir;			/* 1 for forward, -1 for backward */
-{	for ( ; ; )
-	   {	while ( isspace(*p) ) p += dir;
-		if ( !(*p == '/' && p[dir] == '*') ) break;
-		p += dir;  p += dir;
-		while ( !(*p == '*' && p[dir] == '/') )
-		   {	if ( *p == 0 ) return p;	/* multi-line comment?? */
-			p += dir;
-		   }
-		p += dir;  p += dir;
-	   }
-	return p;
-}
-
-/*
- * Write blanks over part of a string.
- */
-int
-writeblanks(start, end)
-    char *start;
-    char *end;
-{	char *p;
-	for ( p = start; p < end; p++ ) *p = ' ';
-	return 0;
-}
-
-/*
- * Test whether the string in buf is a function definition.
- * The string may contain and/or end with a newline.
- * Return as follows:
- *	0 - definitely not a function definition;
- *	1 - definitely a function definition;
- *	-1 - may be the beginning of a function definition,
- *		append another line and look again.
- */
-int
-test1(buf)
-    char *buf;
-{	register char *p = buf;
-	char *bend;
-	char *endfn;
-	int contin;
-	if ( !isidfirstchar(*p) )
-		return 0;		/* no name at left margin */
-	bend = skipspace(buf + strlen(buf) - 1, -1);
-	switch ( *bend )
-	   {
-	case ')': contin = 1; break;
-	case '{':
-	case ';': return 0;		/* not a function */
-	default: contin = -1;
-	   }
-	while ( isidchar(*p) ) p++;
-	endfn = p;
-	p = skipspace(p, 1);
-	if ( *p++ != '(' )
-		return 0;		/* not a function */
-	p = skipspace(p, 1);
-	if ( *p == ')' )
-		return 0;		/* no parameters */
-	/* Check that the apparent function name isn't a keyword. */
-	/* We only need to check for keywords that could be followed */
-	/* by a left parenthesis (which, unfortunately, is most of them). */
-	   {	static char *words[] =
-		   {	"asm", "auto", "case", "char", "const", "double",
-			"extern", "float", "for", "if", "int", "long",
-			"register", "return", "short", "signed", "sizeof",
-			"static", "switch", "typedef", "unsigned",
-			"void", "volatile", "while", 0
-		   };
-		char **key = words;
-		char *kp;
-		int len = endfn - buf;
-		while ( (kp = *key) != 0 )
-		   {	if ( strlen(kp) == len && !strncmp(kp, buf, len) )
-				return 0;	/* name is a keyword */
-			key++;
-		   }
-	   }
-	return contin;
-}
-
-int
-convert1(buf, out)
-    char *buf;
-    FILE *out;
-{	char *endfn;
-	register char *p;
-	char **breaks;
-	unsigned num_breaks = 2;	/* for testing */
-	char **btop;
-	char **bp;
-	char **ap;
-	/* Pre-ANSI implementations don't agree on whether strchr */
-	/* is called strchr or index, so we open-code it here. */
-	for ( endfn = buf; *(endfn++) != '('; ) ;
-top:	p = endfn;
-	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
-	if ( breaks == 0 )
-	   {	/* Couldn't allocate break table, give up */
-		fprintf(stderr, "Unable to allocate break table!\n");
-		fputs(buf, out);
-		return -1;
-	   }
-	btop = breaks + num_breaks * 2 - 2;
-	bp = breaks;
-	/* Parse the argument list */
-	do
-	   {	int level = 0;
-		char *end = NULL;
-		if ( bp >= btop )
-		   {	/* Filled up break table. */
-			/* Allocate a bigger one and start over. */
-			free((char *)breaks);
-			num_breaks <<= 1;
-			goto top;
-		   }
-		*bp++ = p;
-		/* Find the end of the argument */
-		for ( ; end == NULL; p++ )
-		   {	switch(*p)
-			   {
-			case ',': if ( !level ) end = p; break;
-			case '(': level++; break;
-			case ')': if ( --level < 0 ) end = p; break;
-			case '/': p = skipspace(p, 1) - 1; break;
-			default: ;
-			   }
-		   }
-		p--;			/* back up over terminator */
-		/* Find the name being declared. */
-		/* This is complicated because of procedure and */
-		/* array modifiers. */
-		for ( ; ; )
-		   {	p = skipspace(p - 1, -1);
-			switch ( *p )
-			   {
-			case ']':	/* skip array dimension(s) */
-			case ')':	/* skip procedure args OR name */
-			   {	int level = 1;
-				while ( level )
-				 switch ( *--p )
-				   {
-				case ']': case ')': level++; break;
-				case '[': case '(': level--; break;
-				case '/': p = skipspace(p, -1) + 1; break;
-				default: ;
-				   }
-			   }
-				if ( *p == '(' && *skipspace(p + 1, 1) == '*' )
-				   {	/* We found the name being declared */
-					while ( !isidfirstchar(*p) )
-						p = skipspace(p, 1) + 1;
-					goto found;
-				   }
-				break;
-			default: goto found;
-			   }
-		   }
-found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
-		   {	p++;
-			if ( bp == breaks + 1 )	/* sole argument */
-				writeblanks(breaks[0], p);
-			else
-				writeblanks(bp[-1] - 1, p);
-			bp--;
-		   }
-		else
-		   {	while ( isidchar(*p) ) p--;
-			*bp++ = p+1;
-		   }
-		p = end;
-	   }
-	while ( *p++ == ',' );
-	*bp = p;
-	/* Make a special check for 'void' arglist */
-	if ( bp == breaks+2 )
-	   {	p = skipspace(breaks[0], 1);
-		if ( !strncmp(p, "void", 4) )
-		   {	p = skipspace(p+4, 1);
-			if ( p == breaks[2] - 1 )
-			   {	bp = breaks;	/* yup, pretend arglist is empty */
-				writeblanks(breaks[0], p + 1);
-			   }
-		   }
-	   }
-	/* Put out the function name */
-	p = buf;
-	while ( p != endfn ) putc(*p, out), p++;
-	/* Put out the declaration */
-	for ( ap = breaks+1; ap < bp; ap += 2 )
-	   {	p = *ap;
-		while ( isidchar(*p) ) putc(*p, out), p++;
-		if ( ap < bp - 1 ) fputs(", ", out);
-	   }
-	fputs(")  ", out);
-	/* Put out the argument declarations */
-	for ( ap = breaks+2; ap <= bp; ap += 2 ) (*ap)[-1] = ';';
-	fputs(breaks[0], out);
-	free((char *)breaks);
-	return 0;
-}

example.c

@@ -1,3 +1,4 @@
+
 /* example.c - an example of using libpng */
 
 /* This is an example of how to use libpng to read and write PNG files.
@@ -12,10 +13,13 @@
  * working PNG reader/writer, see pngtest.c, included in this distribution.
  */
 
-#include <png.h>
+#include "png.h"
 
-/* Check to see if a file is a PNG file using png_check_sig().  Returns
- * non-zero if the image is a PNG, and 0 if it isn't a PNG.
+/* Check to see if a file is a PNG file using png_sig_cmp().  png_sig_cmp()
+ * returns zero if the image is a PNG and nonzero if it isn't a PNG.
+ *
+ * The function check_if_png() shown here, but not used, returns nonzero (true)
+ * if the file can be opened and is a PNG, 0 (false) otherwise.
  *
  * If this call is successful, and you are going to keep the file open,
  * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
@@ -28,7 +32,7 @@
  *
  * Many applications already read the first 2 or 4 bytes from the start
  * of the image to determine the file type, so it would be easiest just
- * to pass the bytes to png_check_sig() or even skip that if you know
+ * to pass the bytes to png_sig_cmp() or even skip that if you know
  * you have a PNG file, and call png_set_sig_bytes().
  */
 #define PNG_BYTES_TO_CHECK 4
@@ -40,12 +44,14 @@ int check_if_png(char *file_name, FILE **fp)
    if ((*fp = fopen(file_name, "rb")) != NULL);
       return 0;
 
-   /* Read in the signature bytes */
+   /* Read in some of the signature bytes */
    if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
       return 0;
 
-   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. */
-   return(png_check_sig(buf, PNG_BYTES_TO_CHECK));
+   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
+      Return nonzero (true) if they match */
+
+   return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
 }
 
 /* Read a PNG file.  You may want to return an error code if the read
@@ -54,7 +60,7 @@ int check_if_png(char *file_name, FILE **fp)
  * file, and the other where we are given an open file (possibly with
  * some or all of the magic bytes read - see comments above).
  */
-**** prototype 1 ****
+#ifdef open_file /* prototype 1 */
 void read_png(char *file_name)  /* We need to open the file */
 {
    png_structp png_ptr;
@@ -66,14 +72,14 @@ void read_png(char *file_name)  /* We need to open the file */
 
    if ((fp = fopen(file_name, "rb")) == NULL)
       return;
-**** prototype 2 ****
+#else no_open_file /* prototype 2 */
 void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
 {
    png_structp png_ptr;
    png_infop info_ptr;
    png_uint_32 width, height;
    int bit_depth, color_type, interlace_type;
-**** only use one prototype! ****
+#endif no_open_file /* only use one prototype! */
 
    /* Create and initialize the png_struct with the desired error handler
     * functions.  If you want to use the default stderr and longjump method,
@@ -82,7 +88,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)
    {
@@ -91,7 +97,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
    }
 
    /* Allocate/initialize the memory for image information.  REQUIRED. */
-   info_ptr = png_create_info_struct();
+   info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == NULL)
    {
       fclose(fp);
@@ -113,20 +119,20 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
    }
 
    /* One of the following I/O initialization methods is REQUIRED */
-**** PNG file I/O method 1 ****
+#ifdef streams /* PNG file I/O method 1 */
    /* Set up the input control if you are using standard C streams */
    png_init_io(png_ptr, fp);
 
-**** PNG file I/O method 2 ****
+#else no_streams /* PNG file I/O method 2 */
    /* If you are using replacement read functions, instead of calling
     * png_init_io() here you would call:
     */
    png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
    /* where user_io_ptr is a structure you want available to the callbacks */
-**** Use only one I/O method! ****
+#endif no_streams /* Use only one I/O method! */
 
    /* If we have already read some of the signature */
-   png_set_sig_bytes_read(png_ptr, sig_read);
+   png_set_sig_bytes(png_ptr, sig_read);
 
    /* The call to png_read_info() gives us all of the information from the
     * PNG file before the first IDAT (image data chunk).  REQUIRED
@@ -145,7 +151,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
    /* tell libpng to strip 16 bit/color files down to 8 bits/color */
    png_set_strip_16(png_ptr);
 
-   /* Strip alpha bytes from the input data without combining with th
+   /* Strip alpha bytes from the input data without combining with the
     * background (not recommended).
     */
    png_set_strip_alpha(png_ptr);
@@ -180,29 +186,33 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
     * use it - you should use the (solid) application background if it has one.
     */
 
-   png_color_16 my_background, *image_background);
+   png_color_16 my_background, *image_background;
 
-   if (png_get_bKGD(png_ptr, info_ptr, &image_background);
-      png_set_background(png_ptr, 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);
    else
       png_set_background(png_ptr, &my_background,
                          PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
 
    /* Some suggestions as to how to get a screen gamma value */
+
+   /* Note that screen gamma is the display_exponent, which includes
+    * the CRT_exponent and any correction for viewing conditions */
    if (/* We have a user-defined screen gamma value */)
    {
       screen_gamma = user-defined screen_gamma;
    }
    /* This is one way that applications share the same screen gamma value */
-   else if ((gamma_str = getenv("DISPLAY_GAMMA")) != NULL)
+   else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)
    {
       screen_gamma = atof(gamma_str);
    }
    /* If we don't have another value */
    else
    {
-      screen_gamma = 2.2;  /* A good guess for PC monitors */
+      screen_gamma = 2.2;  /* A good guess for a PC monitors in a dimly
+                              lit room */
       screen_gamma = 1.7 or 1.0;  /* A good guess for Mac systems */
    }
 
@@ -211,13 +221,19 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
     * by the user at run time by the user.  It is strongly suggested that
     * your application support gamma correction.
     */
-   if (png_get_sRGB(png_ptr, info_ptr, &srgb_intent)
-      png_set_sRGB(png_ptr, srgb_intent, 0);
-   else 
-      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)
+
+   int intent;
+
+   if (png_get_sRGB(png_ptr, info_ptr, &intent))
+      png_set_sRGB(png_ptr, intent, 0);
+   else
+   {
+      double image_gamma;
+      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma))
          png_set_gamma(png_ptr, screen_gamma, image_gamma);
       else
-         png_set_gamma(png_ptr, screen_gamma, 0.45);
+         png_set_gamma(png_ptr, screen_gamma, 0.45455);
+   }
 
    /* Dither RGB files down to 8 bit palette or reduce palettes
     * to the number of colors available on your screen.
@@ -228,7 +244,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
       png_colorp palette;
 
       /* This reduces the image to the application supplied palette */
-      if (we have our own palette)
+      if (/* we have our own palette */)
       {
          /* An array of colors to which the image should be dithered */
          png_color std_color_cube[MAX_SCREEN_COLORS];
@@ -237,7 +253,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
             MAX_SCREEN_COLORS, NULL, 0);
       }
       /* This reduces the image to the palette supplied in the file */
-      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)))
+      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))
       {
          png_color16p histogram;
 
@@ -249,7 +265,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
    }
 
    /* invert monocrome files to have 0 as white and 1 as black */
-   png_set_invert(png_ptr);
+   png_set_invert_mono(png_ptr);
 
    /* If you want to shift the pixel values from the range [0,255] or
     * [0,65535] to the original [0,7] or [0,31], or whatever range the
@@ -298,37 +314,37 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
    }
 
    /* Now it's time to read the image.  One of these methods is REQUIRED */
-**** Read the entire image in one go ****
+#ifdef entire /* Read the entire image in one go */
    png_read_image(png_ptr, row_pointers);
 
-**** Read the image one or more scanlines at a time ****
+#else no_entire /* Read the image one or more scanlines at a time */
    /* The other way to read images - deal with interlacing: */
 
    for (pass = 0; pass < number_passes; pass++)
    {
-[[[[[[[ Read the image a single row at a time ]]]]]]]
+#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);
       }
 
-[[[[[[[ Read the image several rows at a time ]]]]]]]
+#else no_single /* Read the image several rows at a time */
       for (y = 0; y < height; y += number_of_rows)
       {
-<<<<<<<<<< Read the image using the "sparkle" effect. >>>>>>>>>>
-         png_read_rows(png_ptr, row_pointers, NULL, number_of_rows);
-        
-<<<<<<<<<< Read the image using the "rectangle" effect >>>>>>>>>>
-         png_read_rows(png_ptr, NULL, row_pointers, number_of_rows);
-<<<<<<<<<< use only one of these two methods >>>>>>>>>>
+#ifdef sparkle /* Read the image using the "sparkle" effect. */
+         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[y], number_of_rows);
+#endif no_sparkle /* use only one of these two methods */
       }
-     
+
       /* if you want to display the image after every pass, do
          so here */
-[[[[[[[ use only one of these two methods ]]]]]]]
+#endif no_single /* use only one of these two methods */
    }
-**** use only one of these two methods ****
+#endif no_entire /* use only one of these two methods */
 
    /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
    png_read_end(png_ptr, info_ptr);
@@ -355,7 +371,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)
    {
@@ -377,8 +393,11 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
       return ERROR;
    }
 
-   /* this one's new.  You will need to provide all three
+   /* This one's new.  You will need to provide all three
     * function callbacks, even if you aren't using them all.
+    * If you aren't using all functions, you can specify NULL
+    * parameters.  Even when all three functions are NULL,
+    * you need to call png_set_progressive_read_fn().
     * These functions shouldn't be dependent on global or
     * static variables if you are decoding several images
     * simultaneously.  You should store stream specific data
@@ -473,7 +492,7 @@ end_callback(png_structp png_ptr, png_infop info)
 }
 
 /* write a png file */
-void write_png(char *file_name, ... other image information ...)
+void write_png(char *file_name /* , ... other image information ... */)
 {
    FILE *fp;
    png_structp png_ptr;
@@ -491,7 +510,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)
    {
@@ -520,16 +539,16 @@ void write_png(char *file_name, ... other image information ...)
    }
 
    /* One of the following I/O initialization functions is REQUIRED */
-**** I/O initialization method 1 ****
+#ifdef streams /* I/O initialization method 1 */
    /* set up the output control if you are using standard C streams */
    png_init_io(png_ptr, fp);
-**** I/O initialization method 2 ****
+#else no_streams /* I/O initialization method 2 */
    /* If you are using replacement read functions, instead of calling
     * png_init_io() here you would call */
    png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
       user_IO_flush_function);
    /* where user_io_ptr is a structure you want available to the callbacks */
-**** only use 1 initialization method ****
+#endif no_streams /* only use one initialization method */
 
    /* Set the image information here.  Width and height are up to 2^31,
     * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
@@ -543,8 +562,8 @@ void write_png(char *file_name, ... other image information ...)
       PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 
    /* set the palette if there is one.  REQUIRED for indexed-color images */
-   palette = png_malloc(png_ptr, 256 * sizeof (png_color));
-   ... set palette colors ...
+   palette = (png_colorp)png_malloc(png_ptr, 256 * sizeof (png_color));
+   /* ... set palette colors ... */
    png_set_PLTE(png_ptr, info_ptr, palette, 256);
 
    /* optional significant bit chunk */
@@ -558,7 +577,7 @@ void write_png(char *file_name, ... other image information ...)
    sig_bit.alpha = true_alpha_bit_depth;
    png_set_sBIT(png_ptr, info_ptr, sig_bit);
 
-  
+
    /* Optional gamma chunk is strongly suggested if you have any guess
     * as to the correct gamma of the image.
     */
@@ -574,7 +593,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
@@ -594,7 +613,7 @@ void write_png(char *file_name, ... other image information ...)
     */
 
    /* invert monocrome pixels */
-   png_set_invert(png_ptr);
+   png_set_invert_mono(png_ptr);
 
    /* Shift the pixels up to a legal bit depth and fill in
     * as appropriate to correctly scale the image.
@@ -631,31 +650,34 @@ 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 */
-**** write out the entire image data in one call ***
+#ifdef entire /* write out the entire image data in one call */
    png_write_image(png_ptr, row_pointers);
 
    /* the other way to write the image - deal with interlacing */
 
-**** write out the image data by one or more scanlines ****
+#else no_entire /* write out the image data by one or more scanlines */
    /* The number of passes is either 1 for non-interlaced images,
     * or 7 for interlaced images.
     */
    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);
       }
    }
-**** use only one output method ****
+#endif no_entire /* use only one output method */
 
    /* You can write optional chunks like tEXt, zTXt, and tIME at the end
     * as well.

libpngpf.3

@@ -0,0 +1,505 @@
+.TH LIBPNGPF 3 October 10, 1999
+.SH NAME
+libpng \- Portable Network Graphics (PNG) Reference Library 1.0.4e - October 10, 1999
+(private functions)
+.SH SYNOPSIS
+\fB#include <png.h>\fP
+
+\fI\fB
+
+\fBvoid png_build_gamma_table (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_build_grayscale_palette (int \fP\fIbit_depth\fP\fB, png_colorp \fIpalette\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_calculate_crc (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIptr\fP\fB, png_size_t \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_check_chunk_name (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIchunk_name\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_size_t png_check_keyword (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIkey\fP\fB, png_charpp \fInew_key\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_combine_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIrow\fP\fB, int \fImask\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_correct_palette (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fInum_palette\fP\fB);\fP
+
+\fI\fB
+
+\fBint png_crc_error (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBint png_crc_finish (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIskip\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_crc_read (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuf\fP\fB, png_size_t \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_voidp png_create_struct (int \fP\fItype\fP\fB, png_malloc_ptr \fImalloc_fn\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_voidp png_create_struct_2 (int \fItype\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_destroy_struct (png_voidp \fIstruct_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_destroy_struct_2 (png_voidp \fP\fIstruct_ptr\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_background (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_16p \fP\fItrans_values\fP\fB, png_color_16p \fP\fIbackground\fP\fB, png_color_16p \fP\fIbackground_1\fP\fB, png_bytep \fP\fIgamma_table\fP\fB, png_bytep \fP\fIgamma_from_1\fP\fB, png_bytep \fP\fIgamma_to_1\fP\fB, png_uint_16pp \fP\fIgamma_16\fP\fB, png_uint_16pp \fP\fIgamma_16_from_1\fP\fB, png_uint_16pp \fP\fIgamma_16_to_1\fP\fB, int \fIgamma_shift\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_bgr (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_chop (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_dither (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fP\fIpalette_lookup\fP\fB, png_bytep \fIdither_lookup\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_expand (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_16p \fItrans_value\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_expand_palette (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_colorp \fP\fIpalette\fP\fB, png_bytep \fP\fItrans\fP\fB, int \fInum_trans\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_gamma (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fP\fIgamma_table\fP\fB, png_uint_16pp \fP\fIgamma_16_table\fP\fB, int \fIgamma_shift\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_gray_to_rgb (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_invert (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_pack (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_uint_32 \fIbit_depth\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_packswap (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_read_filler (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_uint_32 \fP\fIfiller\fP\fB, png_uint_32 \fIflags\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_read_interlace (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, int \fP\fIpass\fP\fB, png_uint_32 \fItransformations\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_read_invert_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_read_swap_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_read_transformations (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBint png_do_rgb_to_gray (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_shift (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_8p \fIbit_depth\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_strip_filler (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_uint_32 \fIflags\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_swap (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_unpack (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_unshift (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_8p \fIsig_bits\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_write_interlace (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, int \fIpass\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_write_invert_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_write_swap_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_do_write_transformations (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid *png_far_to_near (png_structp png_ptr,png_voidp \fP\fIptr\fP\fB, int \fIcheck\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_flush (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_int_32 png_get_int_32 (png_bytep \fIbuf\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_uint_16 png_get_uint_16 (png_bytep \fIbuf\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_uint_32 png_get_uint_32 (png_bytep \fIbuf\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_gAMA (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_IEND (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_unknown (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_handle_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_info_destroy (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_init_read_transformations (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_process_IDAT_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_length\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_process_some_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_check_crc (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_crc_finish (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_crc_skip (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_fill_buffer (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_handle_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_handle_unknown (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_handle_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_have_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_have_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_have_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIrow\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_process_row (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_read_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_read_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_read_IDAT (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_read_sig (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_read_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_read_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_restore_buffer (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_length\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_push_save_buffer (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_filter_row (png_structp \fP\fIpng_ptr\fP\fB, png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fP\fIprev_row\fP\fB, int \fIfilter\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_finish_row (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_init (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_push_finish_row (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_start_row (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_read_transform_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_reset_crc (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_save_int_32 (png_bytep \fP\fIbuf\fP\fB, png_int_32 \fIi\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_save_uint_16 (png_bytep \fP\fIbuf\fP\fB, unsigned int \fIi\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_save_uint_32 (png_bytep \fP\fIbuf\fP\fB, png_uint_32 \fIi\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_color_16p \fP\fIvalues\fP\fB, int \fIcolor_type\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_cHRM (png_structp \fP\fIpng_ptr\fP\fB, double \fP\fIwhite_x\fP\fB, double \fP\fIwhite_y\fP\fB, double \fP\fIred_x\fP\fB, double \fP\fIred_y\fP\fB, double \fP\fIgreen_x\fP\fB, double \fP\fIgreen_y\fP\fB, double \fP\fIblue_x\fP\fB, double \fIblue_y\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP
+
+\fBvoid png_write_filtered_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIfiltered_row\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_find_filter (png_structp \fP\fIpng_ptr\fP\fB, png_row_infop \fIrow_info\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_finish_row (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_gAMA (png_structp \fP\fIpng_ptr\fP\fB, double \fIfile_gamma\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_uint_16p \fP\fIhist\fP\fB, int \fInum_hist\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_init (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_IDAT (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_IEND (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIwidth\fP\fB, png_uint_32 \fP\fIheight\fP\fB, int \fP\fIbit_depth\fP\fB, int \fP\fIcolor_type\fP\fB, int \fP\fIcompression_type\fP\fB, int \fP\fIfilter_type\fP\fB, int \fIinterlace_type\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIx_offset\fP\fB, png_uint_32 \fP\fIy_offset\fP\fB, int \fIunit_type\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIpurpose\fP\fB, png_int_32 \fP\fIX0\fP\fB, png_int_32 \fP\fIX1\fP\fB, int \fP\fItype\fP\fB, int \fP\fInparams\fP\fB, png_charp \fP\fIunits\fP\fB, png_charpp \fIparams\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIx_pixels_per_unit\fP\fB, png_uint_32 \fP\fIy_pixels_per_unit\fP\fB, int \fIunit_type\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, png_uint_32 \fInum_pal\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_color_8p \fP\fIsbit\fP\fB, int \fIcolor_type\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_sig (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_sRGB (png_structp \fP\fIpng_ptr\fP\fB, int \fIintent\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_start_row (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIkey\fP\fB, png_charp \fP\fItext\fP\fB, png_size_t \fItext_len\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_timep \fImod_time\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fItrans\fP\fB, png_color_16p \fP\fIvalues\fP\fB, int \fP\fInumber\fP\fB, int \fIcolor_type\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_write_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIkey\fP\fB, png_charp \fP\fItext\fP\fB, png_size_t \fP\fItext_len\fP\fB, int \fIcompression\fP\fB);\fP
+
+\fI\fB
+
+\fBvoidpf png_zalloc (voidpf \fP\fIpng_ptr\fP\fB, uInt \fP\fIitems\fP\fB, uInt \fIsize\fP\fB);\fP
+
+\fI\fB
+
+\fBvoid png_zfree (voidpf \fP\fIpng_ptr\fP\fB, voidpf \fIptr\fP\fB);\fP
+
+\fI\fB
+
+.SH DESCRIPTION
+The functions listed above are used privately by libpng
+and are not recommended for use by applications.  They
+are listed alphabetically here as an aid to libpng maintainers.
+See png.h for more information on these functions.
+
+.SH SEE ALSO
+libpng(3), png(5)
+.SH AUTHOR
+Glenn Randers-Pehrson

makefile.aco

@@ -1,221 +0,0 @@
-# Project:   libpng
-
-
-# Toolflags:
-CCflags = -c -depend !Depend -IC:,Zlib: -g -throwback  -DRISCOS  -fnah 
-C++flags = -c -depend !Depend -IC: -throwback
-Linkflags = -aif -c++ -o $@
-ObjAsmflags = -throwback -NoCache -depend !Depend
-CMHGflags = 
-LibFileflags = -c -l -o $@ 
-Squeezeflags = -o $@
-
-
-# Final targets:
-@.libpng-lib:   @.o.png @.o.pngerror @.o.pngrio @.o.pngwio @.o.pngmem \
-        @.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngrtran \
-        @.o.pngrutil @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil 
-        LibFile $(LibFileflags) @.o.png @.o.pngerror @.o.pngrio @.o.pngrtran \
-        @.o.pngmem @.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngwio \
-        @.o.pngrutil @.o.pngtrans  @.o.pngwrite @.o.pngwtran @.o.pngwutil 
-@.mm-libpng-lib:   @.mm.png @.mm.pngerror @.mm.pngrio @.mm.pngwio @.mm.pngmem \
-        @.mm.pngpread @.mm.pngset @.mm.pngget @.mm.pngread @.mm.pngrtran \
-        @.mm.pngrutil @.mm.pngtrans @.mm.pngwrite @.mm.pngwtran @.mm.pngwutil 
-        LibFile $(LibFileflags) @.mm.png @.mm.pngerror @.mm.pngrio \
-        @.mm.pngwio @.mm.pngmem @.mm.pngpread @.mm.pngset @.mm.pngget \
-        @.mm.pngread @.mm.pngrtran @.mm.pngrutil @.mm.pngtrans @.mm.pngwrite \
-        @.mm.pngwtran @.mm.pngwutil 
-
-
-# User-editable dependencies:
-# (C) Copyright 1997 Tom Tanner
-Test: @.pngtest 
-        <Prefix$Dir>.pngtest
-        @remove <Prefix$Dir>.pngtest
-
-#It would be nice if you could stop "make" listing from here on!
-@.pngtest:   @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
-        Link $(Linkflags) @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
-
-.SUFFIXES: .o .mm .c
-
-.c.mm:
-        MemCheck.CC cc $(ccflags) -o $@ LibPng:$<
-.c.o:
-        cc $(ccflags) -o $@ $<
-
-
-# Static dependencies:
-
-
-# Dynamic dependencies:
-o.pngtest:	c.pngtest
-o.pngtest:	h.png
-o.pngtest:	Zlib:h.zlib
-o.pngtest:	Zlib:h.zconf
-o.pngtest:	h.pngconf
-mm.png:		LibPng:c.png
-mm.png:		LibPng:h.png
-mm.png:		Zlib:h.zlib
-mm.png:		Zlib:h.zconf
-mm.png:		LibPng:h.pngconf
-mm.png:		MemCheck:ANSI.h.stdio
-mm.pngerror:	LibPng:c.pngerror
-mm.pngerror:	LibPng:h.png
-mm.pngerror:	Zlib:h.zlib
-mm.pngerror:	Zlib:h.zconf
-mm.pngerror:	LibPng:h.pngconf
-mm.pngerror:	MemCheck:ANSI.h.stdio
-mm.pngrio:	LibPng:c.pngrio
-mm.pngrio:	LibPng:h.png
-mm.pngrio:	Zlib:h.zlib
-mm.pngrio:	Zlib:h.zconf
-mm.pngrio:	LibPng:h.pngconf
-mm.pngrio:	MemCheck:ANSI.h.stdio
-mm.pngwio:	LibPng:c.pngwio
-mm.pngwio:	LibPng:h.png
-mm.pngwio:	Zlib:h.zlib
-mm.pngwio:	Zlib:h.zconf
-mm.pngwio:	LibPng:h.pngconf
-mm.pngwio:	MemCheck:ANSI.h.stdio
-mm.pngmem:	LibPng:c.pngmem
-mm.pngmem:	LibPng:h.png
-mm.pngmem:	Zlib:h.zlib
-mm.pngmem:	Zlib:h.zconf
-mm.pngmem:	LibPng:h.pngconf
-mm.pngmem:	MemCheck:ANSI.h.stdio
-mm.pngpread:	LibPng:c.pngpread
-mm.pngpread:	LibPng:h.png
-mm.pngpread:	Zlib:h.zlib
-mm.pngpread:	Zlib:h.zconf
-mm.pngpread:	LibPng:h.pngconf
-mm.pngpread:	MemCheck:ANSI.h.stdio
-mm.pngset:	LibPng:c.pngset
-mm.pngset:	LibPng:h.png
-mm.pngset:	Zlib:h.zlib
-mm.pngset:	Zlib:h.zconf
-mm.pngset:	LibPng:h.pngconf
-mm.pngset:	MemCheck:ANSI.h.stdio
-mm.pngget:	LibPng:c.pngget
-mm.pngget:	LibPng:h.png
-mm.pngget:	Zlib:h.zlib
-mm.pngget:	Zlib:h.zconf
-mm.pngget:	LibPng:h.pngconf
-mm.pngget:	MemCheck:ANSI.h.stdio
-mm.pngread:	LibPng:c.pngread
-mm.pngread:	LibPng:h.png
-mm.pngread:	Zlib:h.zlib
-mm.pngread:	Zlib:h.zconf
-mm.pngread:	LibPng:h.pngconf
-mm.pngread:	MemCheck:ANSI.h.stdio
-mm.pngrtran:	LibPng:c.pngrtran
-mm.pngrtran:	LibPng:h.png
-mm.pngrtran:	Zlib:h.zlib
-mm.pngrtran:	Zlib:h.zconf
-mm.pngrtran:	LibPng:h.pngconf
-mm.pngrtran:	MemCheck:ANSI.h.stdio
-mm.pngrutil:	LibPng:c.pngrutil
-mm.pngrutil:	LibPng:h.png
-mm.pngrutil:	Zlib:h.zlib
-mm.pngrutil:	Zlib:h.zconf
-mm.pngrutil:	LibPng:h.pngconf
-mm.pngrutil:	MemCheck:ANSI.h.stdio
-mm.pngtrans:	LibPng:c.pngtrans
-mm.pngtrans:	LibPng:h.png
-mm.pngtrans:	Zlib:h.zlib
-mm.pngtrans:	Zlib:h.zconf
-mm.pngtrans:	LibPng:h.pngconf
-mm.pngtrans:	MemCheck:ANSI.h.stdio
-mm.pngwrite:	LibPng:c.pngwrite
-mm.pngwrite:	LibPng:h.png
-mm.pngwrite:	Zlib:h.zlib
-mm.pngwrite:	Zlib:h.zconf
-mm.pngwrite:	LibPng:h.pngconf
-mm.pngwrite:	MemCheck:ANSI.h.stdio
-mm.pngwtran:	LibPng:c.pngwtran
-mm.pngwtran:	LibPng:h.png
-mm.pngwtran:	Zlib:h.zlib
-mm.pngwtran:	Zlib:h.zconf
-mm.pngwtran:	LibPng:h.pngconf
-mm.pngwtran:	MemCheck:ANSI.h.stdio
-mm.pngwutil:	LibPng:c.pngwutil
-mm.pngwutil:	LibPng:h.png
-mm.pngwutil:	Zlib:h.zlib
-mm.pngwutil:	Zlib:h.zconf
-mm.pngwutil:	LibPng:h.pngconf
-mm.pngwutil:	MemCheck:ANSI.h.stdio
-o.png:		c.png
-o.png:		h.png
-o.png:		Zlib:h.zlib
-o.png:		Zlib:h.zconf
-o.png:		h.pngconf
-o.pngerror:	c.pngerror
-o.pngerror:	h.png
-o.pngerror:	Zlib:h.zlib
-o.pngerror:	Zlib:h.zconf
-o.pngerror:	h.pngconf
-o.pngrio:	c.pngrio
-o.pngrio:	h.png
-o.pngrio:	Zlib:h.zlib
-o.pngrio:	Zlib:h.zconf
-o.pngrio:	h.pngconf
-o.pngwio:	c.pngwio
-o.pngwio:	h.png
-o.pngwio:	Zlib:h.zlib
-o.pngwio:	Zlib:h.zconf
-o.pngwio:	h.pngconf
-o.pngmem:	c.pngmem
-o.pngmem:	h.png
-o.pngmem:	Zlib:h.zlib
-o.pngmem:	Zlib:h.zconf
-o.pngmem:	h.pngconf
-o.pngpread:	c.pngpread
-o.pngpread:	h.png
-o.pngpread:	Zlib:h.zlib
-o.pngpread:	Zlib:h.zconf
-o.pngpread:	h.pngconf
-o.pngset:	c.pngset
-o.pngset:	h.png
-o.pngset:	Zlib:h.zlib
-o.pngset:	Zlib:h.zconf
-o.pngset:	h.pngconf
-o.pngget:	c.pngget
-o.pngget:	h.png
-o.pngget:	Zlib:h.zlib
-o.pngget:	Zlib:h.zconf
-o.pngget:	h.pngconf
-o.pngread:	c.pngread
-o.pngread:	h.png
-o.pngread:	Zlib:h.zlib
-o.pngread:	Zlib:h.zconf
-o.pngread:	h.pngconf
-o.pngrtran:	c.pngrtran
-o.pngrtran:	h.png
-o.pngrtran:	Zlib:h.zlib
-o.pngrtran:	Zlib:h.zconf
-o.pngrtran:	h.pngconf
-o.pngrutil:	c.pngrutil
-o.pngrutil:	h.png
-o.pngrutil:	Zlib:h.zlib
-o.pngrutil:	Zlib:h.zconf
-o.pngrutil:	h.pngconf
-o.pngtrans:	c.pngtrans
-o.pngtrans:	h.png
-o.pngtrans:	Zlib:h.zlib
-o.pngtrans:	Zlib:h.zconf
-o.pngtrans:	h.pngconf
-o.pngwrite:	c.pngwrite
-o.pngwrite:	h.png
-o.pngwrite:	Zlib:h.zlib
-o.pngwrite:	Zlib:h.zconf
-o.pngwrite:	h.pngconf
-o.pngwtran:	c.pngwtran
-o.pngwtran:	h.png
-o.pngwtran:	Zlib:h.zlib
-o.pngwtran:	Zlib:h.zconf
-o.pngwtran:	h.pngconf
-o.pngwutil:	c.pngwutil
-o.pngwutil:	h.png
-o.pngwutil:	Zlib:h.zlib
-o.pngwutil:	Zlib:h.zconf
-o.pngwutil:	h.pngconf

png.5

@@ -0,0 +1,58 @@
+.TH PNG 5 "October 10, 1999"
+.SH NAME
+png \- Portable Network Graphics (PNG) format
+.SH DESCRIPTION
+PNG (Portable Network Graphics) is an extensible file format for the
+lossless, portable, well-compressed storage of raster images. PNG provides
+a patent-free replacement for GIF and can also replace many
+common uses of TIFF. Indexed-color, grayscale, and truecolor images are
+supported, plus an optional alpha channel. Sample depths range from
+1 to 16 bits.
+.br
+
+PNG is designed to work well in online viewing applications, such as the
+World Wide Web, so it is fully streamable with a progressive display
+option. PNG is robust, providing both full file integrity checking and
+fast, simple detection of common transmission errors. Also, PNG can store
+gamma and chromaticity data for improved color matching on heterogeneous
+platforms.
+
+.SH "SEE ALSO"
+.IR libpng(3), zlib(3), deflate(5), and zlib(5)
+.LP
+PNG 1.1 specification, January 1999:
+.IP
+.br
+http://www.cdrom.com/pub/png
+.LP
+PNG 1.0 specification, October 1996:
+.IP
+.br
+RFC 2083
+.IP
+.br
+ftp://ds.internic.net/rfc/rfc2083.txt
+.br
+or (as a W3C Recommendation) at
+.br
+http://www.w3.org/TR/REC-png.html
+.SH AUTHORS
+This man page: Glenn Randers-Pehrson
+.LP
+Portable Network Graphics (PNG) Specification Version 1.2 (July 8, 1999):
+Glenn Randers-Pehrson and others (png-list@ccrc.wustl.edu).
+.LP
+Portable Network Graphics (PNG) Specification Version 1.0 (October 1, 1996):
+Thomas Boutell and others (png-list@ccrc.wustl.edu).
+.LP
+
+
+.SH COPYRIGHT NOTICE
+The PNG-1.2 specification is copyright (c) 1999 Glenn Randers-Pehrson.
+See the specification for conditions of use and distribution.
+.LP
+The PNG-1.0 specification is copyright (c) 1996 Massachussets Institute of
+Technology.  See the specification for conditions of use and distribution.
+.LP
+.\" end of man page
+

png.c

@@ -1,12 +1,11 @@
 
 /* png.c - location for general purpose libpng functions
  *
- * libpng 0.97
- * For conditions of distribution and use, see copyright notice in png.h
+ * libpng version 1.0.4e - October 10, 1999
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
- * Copyright (c) 1998, Glenn Randers-Pehrson
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ * 
  */
 
 #define PNG_INTERNAL
@@ -16,9 +15,10 @@
 /* Version information for C files.  This had better match the version
  * string defined in png.h.
  */
-char png_libpng_ver[] = "0.97";
 
-/* Place to hold the signiture string for a PNG file. */
+char png_libpng_ver[12] = "1.0.4e";
+
+/* Place to hold the signature string for a PNG file. */
 png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
 
 /* Constant strings for known chunk types.  If you need to add a chunk,
@@ -73,12 +73,12 @@ int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
 /* Mask to determine which pixels to overwrite while displaying */
 int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
 
-
 /* Tells libpng that we have already handled the first "num_bytes" bytes
  * of the PNG file signature.  If the PNG data is embedded into another
  * stream we can set num_bytes = 8 so that libpng will not attempt to read
  * or write any of the magic bytes before it starts on the IHDR.
  */
+
 void
 png_set_sig_bytes(png_structp png_ptr, int num_bytes)
 {
@@ -103,37 +103,35 @@ png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
    if (num_to_check > 8)
       num_to_check = 8;
    else if (num_to_check < 1)
-      return 0;
+      return (0);
 
    if (start > 7)
-      return 0;
+      return (0);
 
    if (start + num_to_check > 8)
       num_to_check = 8 - start;
 
-   return (png_memcmp(&sig[start], &png_sig[start], num_to_check));
+   return ((int)(png_memcmp(&sig[start], &png_sig[start], num_to_check)));
 }
 
 /* (Obsolete) function to check signature bytes.  It does not allow one
- * to check a partial signature.  This function will be removed in the
- * future - use png_sig_cmp().
+ * to check a partial signature.  This function might be removed in the
+ * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
  */
 int
 png_check_sig(png_bytep sig, int num)
 {
-  return !png_sig_cmp(sig, (png_size_t)0, (png_size_t)num);
+  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
 }
 
 /* Function to allocate memory for zlib. */
 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_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,
@@ -143,7 +141,7 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
    {
       png_memset(ptr, 0, (png_size_t)num_bytes);
    }
-   return (voidpf)(ptr);
+   return ((voidpf)ptr);
 }
 
 /* function to free memory for zlib */
@@ -185,7 +183,7 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
    }
 
    if (need_crc)
-      png_ptr->crc = crc32(png_ptr->crc, ptr, length);
+      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
 }
 
 /* Allocate the memory for an info_struct for the application.  We don't
@@ -200,12 +198,18 @@ png_create_info_struct(png_structp png_ptr)
    png_infop info_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);
    }
 
-   return info_ptr;
+   return (info_ptr);
 }
 
 /* This function frees the memory associated with a single info struct.
@@ -226,7 +230,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;
    }
 }
@@ -251,11 +259,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);
@@ -268,7 +275,8 @@ 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)
    {
-      for (i = 0; i < info_ptr->pcal_nparams; i++)
+      int i;
+      for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
       {
          png_free(png_ptr, info_ptr->pcal_params[i]);
       }
@@ -286,7 +294,7 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
 png_voidp
 png_get_io_ptr(png_structp png_ptr)
 {
-   return png_ptr->io_ptr;
+   return (png_ptr->io_ptr);
 }
 
 #if !defined(PNG_NO_STDIO)
@@ -301,3 +309,60 @@ 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_charp
+png_get_copyright(png_structp png_ptr)
+{
+   if(png_ptr == NULL)
+     /* silence compiler warning about unused png_ptr */ ;
+   return("\n libpng version 1.0.4e - October 10, 1999\n\
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n\
+   Copyright (c) 1996, 1997 Andreas Dilger\n\
+   Copyright (c) 1998, 1999 Glenn Randers-Pehrson\n");
+}
+
+/* Generate a compiler error if there is an old png.h in the search path. */
+void
+png_check_version
+   (version_1_0_4e png_h_is_not_version_1_0_4e)
+{
+   if(png_h_is_not_version_1_0_4e == NULL)
+     /* silence compiler warning about unused parameter */ ;
+}

pngasmrd.h

@@ -0,0 +1,32 @@
+/* pngasmrd.h - assembler version of utilities to read a PNG file
+ *
+ * libpng 1.0.4e - October 10, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1999 Glenn Randers-Pehrson
+ *
+ */
+
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+
+/* Set this in the makefile for VC++ on Pentium, not in pngconf.h */
+#ifdef PNG_USE_PNGVCRD
+/* Platform must be Pentium.  Makefile must assemble and load pngvcrd.c .
+ * MMX will be detected at run time and used if present.
+ */
+#define PNG_HAVE_ASSEMBLER_COMBINE_ROW
+#define PNG_HAVE_ASSEMBLER_READ_INTERLACE
+#define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
+#endif
+
+/* Set this in the makefile for gcc on Pentium, not in pngconf.h */
+#ifdef PNG_USE_PNGGCCRD
+/* Platform must be Pentium.  Makefile must assemble and load pnggccrd.c
+ * (not available in libpng 1.0.4e).
+ * MMX will be detected at run time and used if present.
+ */
+#define PNG_HAVE_ASSEMBLER_COMBINE_ROW
+#define PNG_HAVE_ASSEMBLER_READ_INTERLACE
+#define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
+#endif
+
+#endif

pngconf.h

@@ -1,12 +1,11 @@
 
-/* pngconf.c - machine configurable file for libpng
+/* pngconf.h - machine configurable file for libpng
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  */
 
 /* Any machine specific code is near the front of this file, so if you
@@ -18,6 +17,7 @@
 #ifndef PNGCONF_H
 #define PNGCONF_H
 
+
 /* This is the size of the compression buffer, and thus the size of
  * an IDAT chunk.  Make this whatever size you feel is best for your
  * machine.  One of these will be allocated per png_struct.  When this
@@ -27,7 +27,7 @@
  * where it becomes significant, if you are concerned with memory
  * usage.  Note that zlib allocates at least 32Kb also.  For readers,
  * this describes the size of the buffer available to read the data in.
- * Unless this gets smaller then the size of a row (compressed),
+ * Unless this gets smaller than the size of a row (compressed),
  * it should not make much difference how big this is.
  */
 
@@ -47,19 +47,31 @@
 #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
- * prevent these from being compiled and used.
+ * in png_error() and png_warning().  #defining PNG_NO_CONSOLE_IO will
+ * prevent these from being compiled and used. #defining PNG_NO_STDIO
+ * will also prevent these, plus will prevent the entire set of stdio
+ * macros and functions (FILE *, printf, etc.) from being compiled and used,
+ * unless (PNG_DEBUG > 0) has been #defined.
+ *
+ * #define PNG_NO_CONSOLE_IO
  * #define PNG_NO_STDIO
  */
 
-/* We still need stdio.h for FILE even when PNG_NO_STDIO is defined.
- */
-#ifndef PNG_NO_STDIO 
-#include <stdio.h>
-#endif
+#  ifdef PNG_NO_STDIO
+#    ifndef PNG_NO_CONSOLE_IO
+#      define PNG_NO_CONSOLE_IO
+#    endif
+#    ifdef PNG_DEBUG
+#      if (PNG_DEBUG > 0)
+#        include <stdio.h>
+#      endif
+#    endif
+#  else
+#    include <stdio.h>
+#  endif
 
 /* This macro protects us against machines that don't have function
  * prototypes (ie K&R style headers).  If your compiler does not handle
@@ -88,10 +100,12 @@
  * just __MWERKS__ is not good enough, because the Codewarrior is now used
  * on non-Mac platforms.
  */
+#ifndef MACOS
 #if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
-    defined(THINK_C) || defined(__SC__)
+    defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
 #define MACOS
 #endif
+#endif
 
 /* enough people need this for various reasons to include it here */
 #if !defined(MACOS) && !defined(RISCOS)
@@ -157,6 +171,11 @@ __dont__ include it again
 #include <math.h>
 #endif
 
+/* Codewarrior on NT has linking problems without this. */
+#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__)
+#define PNG_ALWAYS_EXTERN
+#endif
+
 /* For some reason, Borland C++ defines memcmp, etc. in mem.h, not
  * stdlib.h like it should (I think).  Or perhaps this is a C++
  * "feature"?
@@ -191,24 +210,25 @@ __dont__ include it again
  * less then 8, and even that may not work (I haven't tested it).
  */
 
+#ifndef PNG_MAX_GAMMA_8
 #define PNG_MAX_GAMMA_8 11
+#endif
 
 /* This controls how much a difference in gamma we can tolerate before
  * we actually start doing gamma conversion.
  */
+#ifndef PNG_GAMMA_THRESHOLD
 #define PNG_GAMMA_THRESHOLD 0.05
+#endif
 
 #endif /* PNG_INTERNAL */
 
 /* The following uses const char * instead of char * for error
  * and warning message functions, so some compilers won't complain.
- * If you want to use const, define PNG_USE_CONST here.  It is not
- * normally defined to make configuration easier, as it is not a
- * critical part of the code.
+ * If you do not want to use const, define PNG_NO_CONST here.
  */
-#define PNG_USE_CONST
 
-#ifdef PNG_USE_CONST
+#ifndef PNG_NO_CONST
 #  define PNG_CONST const
 #else
 #  define PNG_CONST
@@ -230,106 +250,296 @@ __dont__ include it again
 
 /* Any transformations you will not be using can be undef'ed here */
 
-/* GR-P, 0.96a: Set "*FULLY_SUPPORTED as default but allow user
-   to turn it off with "*NOT_FULLY_SUPPORTED" on the compile line,
-   then pick and choose which ones to define without having to edit
-   this file */
+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
+   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. (PNG_NO_* form added in version
+   1.0.1c, for consistency)
+ */
 
-#ifndef PNG_READ_NOT_FULLY_SUPPORTED
-#define PNG_READ_FULLY_SUPPORTED
+
+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_TRANSFORMS)
+#define PNG_READ_TRANSFORMS_SUPPORTED
 #endif
-#ifndef PNG_WRITE_NOT_FULLY_SUPPORTED
-#define PNG_WRITE_FULLY_SUPPORTED
+#if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_TRANSFORMS)
+#define PNG_WRITE_TRANSFORMS_SUPPORTED
 #endif
 
-#ifdef PNG_READ_FULLY_SUPPORTED
-#define PNG_PROGRESSIVE_READ_SUPPORTED
-#define PNG_READ_OPT_PLTE_SUPPORTED
+#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
-#define PNG_READ_COMPOSITE_NODIV_SUPPORTED        /* well tested on Intel */
-#endif /* PNG_READ_FULLY_SUPPORTED */
-#define PNG_READ_INTERLACING_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_USER_TRANSFORM
+#define PNG_READ_USER_TRANSFORM_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_RGB_TO_GRAY
+#define PNG_READ_RGB_TO_GRAY_SUPPORTED
+#endif
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
 
-#ifdef PNG_WRITE_FULLY_SUPPORTED
-#define PNG_WRITE_INTERLACING_SUPPORTED
-#define PNG_WRITE_SHIFT_SUPPORTED
-#define PNG_WRITE_PACK_SUPPORTED
-#define PNG_WRITE_BGR_SUPPORTED
-#define PNG_WRITE_SWAP_SUPPORTED
-#define PNG_WRITE_PACKSWAP_SUPPORTED
-#define PNG_WRITE_INVERT_SUPPORTED
-#define PNG_WRITE_FILLER_SUPPORTED  /* This is the same as WRITE_STRIP_ALPHA */
-#define PNG_WRITE_FLUSH_SUPPORTED
-#define PNG_WRITE_SWAP_ALPHA_SUPPORTED
-#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
-#endif /* PNG_WRITE_FULLY_SUPPORTED */
+#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 */
 
-#if !defined(PNG_NO_STDIO)
-#define PNG_TIME_RFC1152_SUPPORTED
+#ifndef PNG_NO_READ_COMPOSITED_NODIV
+#define PNG_READ_COMPOSITE_NODIV_SUPPORTED    /* well tested on Intel and SGI */
 #endif
 
-/* These are currently experimental features */
-#undef PNG_READ_16_TO_8_ACCURATE_SHIFT_SUPPORTED /* very little testing */
+#ifndef PNG_NO_READ_EMPTY_PLTE
+#define PNG_READ_EMPTY_PLTE_SUPPORTED  /* useful for MNG applications */
+#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 */
+#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
+#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 */
+
+#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_WRITE_EMPTY_PLTE
+#define PNG_WRITE_EMPTY_PLTE_SUPPORTED  /* useful for MNG applications */
+#endif
+
+#ifndef PNG_NO_STDIO
+#define PNG_TIME_RFC1123_SUPPORTED
+#endif
+
+/* This adds extra functions in pngget.c for accessing data from the
+ * info pointer (added in version 0.99)
+ * png_get_image_width()
+ * png_get_image_height()
+ * png_get_bit_depth()
+ * png_get_color_type()
+ * png_get_compression_type()
+ * png_get_filter_type()
+ * png_get_interlace_type()
+ * png_get_pixel_aspect_ratio()
+ * png_get_pixels_per_meter()
+ * png_get_x_offset_pixels()
+ * png_get_y_offset_pixels()
+ * png_get_x_offset_microns()
+ * png_get_y_offset_microns()
+ */
+#ifndef PNG_NO_EASY_ACCESS
+#define PNG_EASY_ACCESS_SUPPORTED
+#endif
+
+#ifndef PNG_NO_ASSEMBLER_CODE
+#define PNG_ASSEMBLER_CODE_SUPPORTED
+#endif
+
+/* These are currently experimental features, define them if you want */
+
+/* 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 */
-#undef PNG_READ_BIG_ENDIAN_SUPPORTED             /* some testing */
+/* some testing */
+/*
+#define PNG_READ_BIG_ENDIAN_SUPPORTED
+*/
 
 /* These functions are turned off by default, as they will be phased out. */
-#undef  PNG_USELESS_TESTS_SUPPORTED
-#undef  PNG_CORRECT_PALETTE_SUPPORTED
+/*
+#define  PNG_USELESS_TESTS_SUPPORTED
+#define  PNG_CORRECT_PALETTE_SUPPORTED
+*/
 
 /* Any chunks you are not interested in, you can undef here.  The
  * ones that allocate memory may be expecially important (hIST,
  * tEXt, zTXt, tRNS, pCAL).  Others will just save time and make png_info
- * a bit smaller.  OPT_PLTE only disables the optional palette in RGB
- * and RGBA images.
+ * a bit smaller.
  */
 
-#ifdef PNG_READ_FULLY_SUPPORTED
-#define PNG_READ_bKGD_SUPPORTED
-#define PNG_READ_cHRM_SUPPORTED
-#define PNG_READ_gAMA_SUPPORTED
-#define PNG_READ_hIST_SUPPORTED
-#define PNG_READ_oFFs_SUPPORTED
-#define PNG_READ_pCAL_SUPPORTED
-#define PNG_READ_pHYs_SUPPORTED
-#define PNG_READ_sBIT_SUPPORTED
-#define PNG_READ_sRGB_SUPPORTED
-#define PNG_READ_tEXt_SUPPORTED
-#define PNG_READ_tIME_SUPPORTED
-#define PNG_READ_tRNS_SUPPORTED
-#define PNG_READ_zTXt_SUPPORTED
-#endif /* PNG_READ_FULLY_SUPPORTED */
+#if !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_ANCILLARY_CHUNKS)
+#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+#if !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)
+#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#endif
 
-#ifdef PNG_WRITE_FULLY_SUPPORTED
+#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 */
+#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 /* PNG_WRITE_FULLY_SUPPORTED */
+#endif
+#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */
 
 /* need the time information for reading tIME chunks */
 #if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
@@ -446,25 +656,33 @@ typedef char            FAR * FAR * FAR * png_charppp;
  */
 typedef charf *         png_zcharp;
 typedef charf * FAR *   png_zcharpp;
-typedef z_stream FAR *  png_zstreamp; 
+typedef z_stream FAR *  png_zstreamp;
 
-/* allow for compilation as dll under MS Windows */
-#ifdef __WIN32DLL__
-#define PNG_EXPORT(type,symbol) __declspec(dllexport) type symbol
-#endif
 
-/* allow for compilation as dll with BORLAND C++ 5.0 */
-#if defined(__BORLANDC__) && defined(_Windows) && defined(__DLL__)
-#   define PNG_EXPORT(t,s) t _export s
-#endif
+#ifndef PNG_EXPORT
+   /* allow for compilation as dll under MS Windows */
+#  ifdef __WIN32DLL__
+#    define PNG_EXPORT(type,symbol) __declspec(dllexport) type symbol
+#  endif
 
-/* allow for compilation as shared lib under BeOS */
-#ifdef __BEOSDLL__
-#define PNG_EXPORT(type,symbol) __declspec(export) type symbol
+   /* this variant is used in Mozilla; may correspond to MSVC++ 6.0 changes */
+#  ifdef ALT_WIN32_DLL
+#    define PNG_EXPORT(type,symbol) type __attribute__((dllexport)) symbol
+#  endif
+
+   /* allow for compilation as dll with Borland C++ 5.0 */
+#  if defined(__BORLANDC__) && defined(_Windows) && defined(__DLL__)
+#    define PNG_EXPORT(type,symbol) type _export symbol
+#  endif
+
+   /* allow for compilation as shared lib under BeOS */
+#  ifdef __BEOSDLL__
+#    define PNG_EXPORT(type,symbol) __declspec(export) type symbol
+#  endif
 #endif
 
 #ifndef PNG_EXPORT
-#define PNG_EXPORT(t,s) t s
+#  define PNG_EXPORT(type,symbol) type symbol
 #endif
 
 
@@ -476,8 +694,9 @@ typedef z_stream FAR *  png_zstreamp;
 /* use this to make far-to-near assignments */
 #   define CHECK   1
 #   define NOCHECK 0
-#   define CVT_PTR(ptr) (far_to_near(png_ptr,ptr,CHECK))
-#   define CVT_PTR_NOCHECK(ptr) (far_to_near(png_ptr,ptr,NOCHECK))
+#   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
@@ -485,6 +704,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
@@ -493,7 +713,7 @@ typedef z_stream FAR *  png_zstreamp;
 /* End of memory model independent support */
 
 /* Just a double check that someone hasn't tried to define something
- * contradictory. 
+ * contradictory.
  */
 #if (PNG_ZBUF_SIZE > 65536) && defined(PNG_MAX_MALLOC_64K)
 #undef PNG_ZBUF_SIZE

pngerror.c

@@ -1,14 +1,13 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
- * 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,14 +51,14 @@ 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 []
  * if the character is invalid.
  */
 #define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97))
-static const char png_digit[16] = {
+static PNG_CONST char png_digit[16] = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 };
 
@@ -81,7 +80,7 @@ png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp message
    }
 
    if (message == NULL)
-      buffer[iout++] = 0;
+      buffer[iout] = 0;
    else {
       buffer[iout++] = ':';
       buffer[iout++] = ' ';
@@ -114,7 +113,7 @@ png_chunk_warning(png_structp png_ptr, png_const_charp message)
 static void
 png_default_error(png_structp png_ptr, png_const_charp message)
 {
-#ifndef PNG_NO_STDIO
+#ifndef PNG_NO_CONSOLE_IO
    fprintf(stderr, "libpng error: %s\n", message);
 #endif
 
@@ -131,18 +130,17 @@ 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
 png_default_warning(png_structp png_ptr, png_const_charp message)
 {
-   if (png_ptr == NULL)
-      return;
-
-#ifndef PNG_NO_STDIO
+#ifndef PNG_NO_CONSOLE_IO
    fprintf(stderr, "libpng warning: %s\n", message);
 #endif
+   if (png_ptr == NULL)
+      return;
 }
 
 /* This function is called when the application wants to use another method
@@ -167,7 +165,7 @@ png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
 png_voidp
 png_get_error_ptr(png_structp png_ptr)
 {
-   return png_ptr->error_ptr;
+   return ((png_voidp)png_ptr->error_ptr);
 }
 
 

pngget.c

@@ -1,12 +1,11 @@
 
 /* pngget.c - retrieval of values from info struct
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  */
 
 #define PNG_INTERNAL
@@ -15,7 +14,7 @@
 png_uint_32
 png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
 {
-   if (info_ptr != NULL)
+   if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->valid & flag);
    else
       return(0);
@@ -24,28 +23,307 @@ png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
 png_uint_32
 png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
 {
-   if (info_ptr != NULL)
+   if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->rowbytes);
    else
       return(0);
 }
 
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* easy access to info, added in libpng-0.99 */
+png_uint_32
+png_get_image_width(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->width;
+   }
+   return (0);
+}
+
+png_uint_32
+png_get_image_height(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->height;
+   }
+   return (0);
+}
+
+png_byte
+png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->bit_depth;
+   }
+   return (0);
+}
+
+png_byte
+png_get_color_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->color_type;
+   }
+   return (0);
+}
+
+png_byte
+png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->filter_type;
+   }
+   return (0);
+}
+
+png_byte
+png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->interlace_type;
+   }
+   return (0);
+}
+
+png_byte
+png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->compression_type;
+   }
+   return (0);
+}
+
+png_uint_32
+png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");
+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+          return (0);
+      else return (info_ptr->x_pixels_per_unit);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");
+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+          return (0);
+      else return (info_ptr->y_pixels_per_unit);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");
+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
+         info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
+          return (0);
+      else return (info_ptr->x_pixels_per_unit);
+   }
+   else
+#endif
+   return (0);
+}
+
+float
+png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
+   {
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");
+      if (info_ptr->x_pixels_per_unit == 0)
+         return ((float)0.0);
+      else
+         return ((float)info_ptr->y_pixels_per_unit
+            /(float)info_ptr->x_pixels_per_unit);
+   }
+   else
+#endif
+      return ((float)0.0);
+}
+
+png_uint_32
+png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+          return (0);
+      else return (info_ptr->x_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+          return (0);
+      else return (info_ptr->y_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+          return (0);
+      else return (info_ptr->x_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+          return (0);
+      else return (info_ptr->y_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+#ifdef PNG_INCH_CONVERSIONS
+png_uint_32
+png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
+     *.03937 +.5)
+}
+
+png_uint_32
+png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
+     *.03937 +.5)
+}
+
+png_uint_32
+png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
+     *.03937 +.5)
+}
+
+float
+png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
+     *.03937/1000000. +.5)
+}
+
+float
+png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
+     *.03937/1000000. +.5)
+}
+
+#if defined(PNG_READ_pHYs_SUPPORTED)
+png_uint_32
+png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+   png_uint_32 retval = 0;
+
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function\n", "pHYs");
+      if (res_x != NULL)
+      {
+         *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (res_y != NULL)
+      {
+         *res_y = info_ptr->y_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (unit_type != NULL)
+      {
+         *unit_type = (int)info_ptr->phys_unit_type;
+         retval |= PNG_INFO_pHYs;
+         if(unit_type == 1)
+         {
+            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * 39.37 + .50);
+            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * 39.37 + .50);
+         }
+      }
+   }
+   return (retval);
+}
+#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
 png_get_channels(png_structp png_ptr, png_infop info_ptr)
 {
-   if (info_ptr != NULL)
+   if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->channels);
    else
-      return(0);
+      return (0);
 }
 
 png_bytep
 png_get_signature(png_structp png_ptr, png_infop info_ptr)
 {
-   if (info_ptr != NULL)
+   if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->signature);
    else
-      return(NULL);
+      return (NULL);
 }
 
 #if defined(PNG_READ_bKGD_SUPPORTED)
@@ -53,8 +331,8 @@ png_uint_32
 png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
    png_color_16p *background)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_bKGD &&
-      background != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
+      && background != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "bKGD");
       *background = &(info_ptr->background);
@@ -70,7 +348,7 @@ png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
    double *white_x, double *white_y, double *red_x, double *red_y,
    double *green_x, double *green_y, double *blue_x, double *blue_y)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_cHRM)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
    {
       png_debug1(1, "in %s retrieval function\n", "cHRM");
       if (white_x != NULL)
@@ -99,8 +377,8 @@ png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
 png_uint_32
 png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_gAMA &&
-      file_gamma != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+      && file_gamma != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "gAMA");
       *file_gamma = (double)info_ptr->gamma;
@@ -112,14 +390,13 @@ png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
 
 #if defined(PNG_READ_sRGB_SUPPORTED)
 png_uint_32
-png_get_sRGB(png_structp png_ptr, png_infop info_ptr, png_bytep
-    file_srgb_intent)
+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sRGB &&
-      file_srgb_intent != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
+      && file_srgb_intent != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "sRGB");
-      *file_srgb_intent = info_ptr->srgb_intent;
+      *file_srgb_intent = (int)info_ptr->srgb_intent;
       return (PNG_INFO_sRGB);
    }
    return (0);
@@ -130,7 +407,8 @@ png_get_sRGB(png_structp png_ptr, png_infop info_ptr, png_bytep
 png_uint_32
 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_hIST && hist != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
+      && hist != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "hIST");
       *hist = info_ptr->hist;
@@ -145,11 +423,14 @@ 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)
-   
+
 {
-   if (info_ptr != NULL && width != NULL && height != NULL &&
+   if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&
       bit_depth != NULL && color_type != NULL)
    {
+      int pixel_depth, channels;
+      png_uint_32 rowbytes_per_pixel;
+
       png_debug1(1, "in %s retrieval function\n", "IHDR");
       *width = info_ptr->width;
       *height = info_ptr->height;
@@ -161,6 +442,23 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
          *filter_type = info_ptr->filter_type;
       if (interlace_type != NULL)
          *interlace_type = info_ptr->interlace_type;
+
+      /* check for potential overflow of rowbytes */
+      if (*color_type == PNG_COLOR_TYPE_PALETTE)
+         channels = 1;
+      else if (*color_type & PNG_COLOR_MASK_COLOR)
+         channels = 3;
+      else
+         channels = 1;
+      if (*color_type & PNG_COLOR_MASK_ALPHA)
+         channels++;
+      pixel_depth = *bit_depth * channels;
+      rowbytes_per_pixel = (pixel_depth + 7) >> 3;
+      if ((*width > PNG_MAX_UINT/rowbytes_per_pixel))
+      {
+         png_warning(png_ptr,
+            "Width too large for libpng to process image data.");
+      }
       return (1);
    }
    return (0);
@@ -171,8 +469,8 @@ 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 *unit_type)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_oFFs &&
-      offset_x != NULL && offset_y != NULL && unit_type != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
+      && offset_x != NULL && offset_y != NULL && unit_type != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "oFFs");
       *offset_x = info_ptr->x_offset;
@@ -190,7 +488,7 @@ png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
    png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
    png_charp *units, png_charpp *params)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_pCAL &&
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pCAL &&
       purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
       nparams != NULL && units != NULL && params != NULL)
    {
@@ -215,12 +513,16 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
 {
    png_uint_32 retval = 0;
 
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
    {
       png_debug1(1, "in %s retrieval function\n", "pHYs");
-      if (res_x != NULL && res_y != NULL)
+      if (res_x != NULL)
       {
          *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (res_y != NULL)
+      {
          *res_y = info_ptr->y_pixels_per_unit;
          retval |= PNG_INFO_pHYs;
       }
@@ -229,9 +531,8 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
          *unit_type = (int)info_ptr->phys_unit_type;
          retval |= PNG_INFO_pHYs;
       }
-      return (retval);
    }
-   return (0);
+   return (retval);
 }
 #endif
 
@@ -239,7 +540,8 @@ png_uint_32
 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
    int *num_palette)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_PLTE && palette != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_PLTE &&
+       palette != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "PLTE");
       *palette = info_ptr->palette;
@@ -254,7 +556,8 @@ png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
 png_uint_32
 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sBIT && sig_bit != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_sBIT &&
+       sig_bit != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "sBIT");
       *sig_bit = &(info_ptr->sig_bit);
@@ -269,10 +572,11 @@ png_uint_32
 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
    int *num_text)
 {
-   if ((info_ptr != NULL) || (info_ptr->num_text > 0))
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
    {
       png_debug1(1, "in %s retrieval function\n",
-         (png_ptr->chunk_name[0] == '\0' ? "text" : png_ptr->chunk_name));
+         (png_ptr->chunk_name[0] == '\0' ? "text"
+             : (png_const_charp)png_ptr->chunk_name));
       if (text_ptr != NULL)
          *text_ptr = info_ptr->text;
       if (num_text != NULL)
@@ -287,7 +591,8 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
 png_uint_32
 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tIME && mod_time != NULL)
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_tIME &&
+       mod_time != NULL)
    {
       png_debug1(1, "in %s retrieval function\n", "tIME");
       *mod_time = &(info_ptr->mod_time);
@@ -302,25 +607,44 @@ png_uint_32
 png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
    png_bytep *trans, int *num_trans, png_color_16p *trans_values)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
+   png_uint_32 retval = 0;
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
    {
       png_debug1(1, "in %s retrieval function\n", "tRNS");
-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE && trans != NULL)
+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
-          *trans = info_ptr->trans;
+          if (trans != NULL)
+          {
+             *trans = info_ptr->trans;
+             retval |= PNG_INFO_tRNS;
+          }
+          if (trans_values != NULL)
+             *trans_values = &(info_ptr->trans_values);
       }
-      else if (trans_values != NULL)
+      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
       {
-         *trans_values = &(info_ptr->trans_values);
+          if (trans_values != NULL)
+          {
+             *trans_values = &(info_ptr->trans_values);
+             retval |= PNG_INFO_tRNS;
+          }
+          if(trans != NULL)
+             *trans = NULL;
       }
-      else
+      if(num_trans != NULL)
       {
-         return (0);
+         *num_trans = info_ptr->num_trans;
+         retval |= PNG_INFO_tRNS;
       }
-      *num_trans = info_ptr->num_trans;
-      return (PNG_INFO_tRNS);
    }
-   return (0);
+   return (retval);
 }
 #endif
 
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+png_byte
+png_get_rgb_to_gray_status (png_structp png_ptr)
+{
+   return png_ptr->rgb_to_gray_status;
+}
+#endif

pngmem.c

@@ -1,16 +1,17 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
- * 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
@@ -25,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;
 
@@ -33,13 +43,20 @@ png_create_struct(int type)
    else if (type == PNG_STRUCT_PNG)
      size = sizeof(png_struct);
    else
-     return (png_voidp)NULL;
+     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);
 }
 
@@ -48,8 +65,30 @@ 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;
+   }
 }
 
 /* Allocate memory.  For reasonable files, size should never exceed
@@ -59,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
@@ -74,9 +113,24 @@ png_destroy_struct(png_voidp struct_ptr)
 png_voidp
 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 ((voidp)NULL);
+      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)
@@ -98,11 +152,14 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
             png_byte huge * hptr;
 
             if (ret != NULL)
+            {
                farfree(ret);
-            ret = NULL;
+               ret = NULL;
+            }
 
-            num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
-            if (num_blocks < 1)
+            if(png_ptr->zlib_window_bits > 14)
+               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+            else
                num_blocks = 1;
             if (png_ptr->zlib_mem_level >= 7)
                num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
@@ -115,7 +172,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 
             if (table == NULL)
             {
-               png_error(png_ptr, "Out of Memory");
+               png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
             }
 
             if ((png_size_t)table & 0xfff0)
@@ -129,19 +186,19 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 
             if (png_ptr->offset_table_ptr == NULL)
             {
-               png_error(png_ptr, "Out of memory");
+               png_error(png_ptr, "Out Of memory.");
             }
 
             hptr = (png_byte huge *)table;
             if ((png_size_t)hptr & 0xf)
             {
                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
-               hptr += 16L;
+               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
             }
             for (i = 0; i < num_blocks; i++)
             {
                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
-               hptr += (png_uint_32)65536L;
+               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
             }
 
             png_ptr->offset_table_number = num_blocks;
@@ -151,7 +208,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
       }
 
       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
-         png_error(png_ptr, "Out of Memory");
+         png_error(png_ptr, "Out of Memory.");
 
       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
    }
@@ -160,10 +217,10 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 
    if (ret == NULL)
    {
-      png_error(png_ptr, "Out of Memory");
+      png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
    }
 
-   return ret;
+   return (ret);
 }
 
 /* free a pointer allocated by png_malloc().  In the default
@@ -175,6 +232,21 @@ 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;
@@ -198,7 +270,10 @@ png_free(png_structp png_ptr, png_voidp ptr)
    }
 
    if (ptr != NULL)
+   {
       farfree(ptr);
+      ptr = NULL;
+   }
 }
 
 #else /* Not the Borland DOS special memory handler */
@@ -209,6 +284,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;
 
@@ -217,7 +303,16 @@ png_create_struct(int type)
    else if (type == PNG_STRUCT_PNG)
       size = sizeof(png_struct);
    else
-      return (png_voidp)NULL;
+      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)
@@ -240,16 +335,40 @@ 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
+   }
 }
 
 
@@ -262,9 +381,23 @@ png_destroy_struct(png_voidp struct_ptr)
 png_voidp
 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 (NULL);
+      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)
@@ -272,12 +405,12 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 #endif
 
 #if defined(__TURBOC__) && !defined(__FLAT__)
-   ret = farmalloc((png_size_t)size);
+   ret = farmalloc(size);
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
    ret = halloc(size, 1);
 # else
-   ret = malloc(size);
+   ret = malloc((size_t)size);
 # endif
 #endif
 
@@ -286,28 +419,94 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
       png_error(png_ptr, "Out of Memory");
    }
 
-   return ret;
+   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)
 {
    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
 }
 
 #endif /* Not Borland DOS special memory handler */
 
+png_voidp
+png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
+   png_uint_32 length)
+{
+   png_size_t size;
+
+   size = (png_size_t)length;
+   if ((png_uint_32)size != length)
+      png_error(png_ptr,"Overflow in png_memcpy_check.");
+
+   return(png_memcpy (s1, s2, size));
+}
+
+png_voidp
+png_memset_check (png_structp png_ptr, png_voidp s1, int value,
+   png_uint_32 length)
+{
+   png_size_t size;
+
+   size = (png_size_t)length;
+   if ((png_uint_32)size != length)
+      png_error(png_ptr,"Overflow in png_memset_check.");
+
+   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 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  */
 
 #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)
@@ -92,7 +92,7 @@ png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
       num_to_check = png_ptr->buffer_size;
    }
 
-   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), 
+   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
       num_to_check);
    png_ptr->sig_bytes += num_to_check;
 
@@ -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;
          }
@@ -466,7 +466,8 @@ png_push_save_buffer(png_structp png_ptr)
 
       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
       old_buffer = png_ptr->save_buffer;
-      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, new_max);
+      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
+         (png_uint_32)new_max);
       png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
       png_free(png_ptr, old_buffer);
       png_ptr->save_buffer_max = new_max;
@@ -527,7 +528,12 @@ png_push_read_IDAT(png_structp png_ptr)
       png_size_t save_size;
 
       if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
-         save_size = png_ptr->idat_size;
+      {
+         save_size = (png_size_t)png_ptr->idat_size;
+         /* check for overflow */
+         if((png_uint_32)save_size != png_ptr->idat_size)
+            png_error(png_ptr, "save_size overflowed in pngpread");
+      }
       else
          save_size = png_ptr->save_buffer_size;
 
@@ -544,7 +550,12 @@ png_push_read_IDAT(png_structp png_ptr)
       png_size_t save_size;
 
       if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
-         save_size = png_ptr->idat_size;
+      {
+         save_size = (png_size_t)png_ptr->idat_size;
+         /* check for overflow */
+         if((png_uint_32)save_size != png_ptr->idat_size)
+            png_error(png_ptr, "save_size overflowed in pngpread");
+      }
       else
          save_size = png_ptr->current_buffer_size;
 
@@ -580,7 +591,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
 
    png_ptr->zstream.next_in = buffer;
    png_ptr->zstream.avail_in = (uInt)buffer_length;
-   while(1)
+   for(;;)
    {
       ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
       if (ret == Z_STREAM_END)
@@ -619,6 +630,7 @@ png_push_process_row(png_structp png_ptr)
    png_ptr->row_info.channels = png_ptr->channels;
    png_ptr->row_info.bit_depth = png_ptr->bit_depth;
    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+
    png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
       (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
 
@@ -626,7 +638,8 @@ png_push_process_row(png_structp png_ptr)
       png_ptr->row_buf + 1, png_ptr->prev_row + 1,
       (int)(png_ptr->row_buf[0]));
 
-   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
+   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
+      png_ptr->rowbytes + 1);
 
    if (png_ptr->transformations)
       png_do_read_transformations(png_ptr);
@@ -761,30 +774,31 @@ png_read_push_finish_row(png_structp png_ptr)
    if (png_ptr->interlaced)
    {
       png_ptr->row_number = 0;
-      png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+      png_memset_check(png_ptr, png_ptr->prev_row, 0,
+         png_ptr->rowbytes + 1);
       do
       {
          png_ptr->pass++;
          if (png_ptr->pass >= 7)
             break;
+
          png_ptr->iwidth = (png_ptr->width +
             png_pass_inc[png_ptr->pass] - 1 -
             png_pass_start[png_ptr->pass]) /
             png_pass_inc[png_ptr->pass];
+
          png_ptr->irowbytes = ((png_ptr->iwidth *
             png_ptr->pixel_depth + 7) >> 3) + 1;
-         if (!(png_ptr->transformations & PNG_INTERLACE))
-         {
-            png_ptr->num_rows = (png_ptr->height +
-               png_pass_yinc[png_ptr->pass] - 1 -
-               png_pass_ystart[png_ptr->pass]) /
-               png_pass_yinc[png_ptr->pass];
-            if (!(png_ptr->num_rows))
-               continue;
-         }
+
          if (png_ptr->transformations & PNG_INTERLACE)
             break;
-      } while (png_ptr->iwidth == 0);
+
+         png_ptr->num_rows = (png_ptr->height +
+            png_pass_yinc[png_ptr->pass] - 1 -
+            png_pass_ystart[png_ptr->pass]) /
+            png_pass_yinc[png_ptr->pass];
+
+      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
    }
 }
 
@@ -793,7 +807,11 @@ void
 png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 {
    if (png_ptr->mode == PNG_BEFORE_IHDR || png_ptr->mode & PNG_HAVE_IEND)
-      png_error(png_ptr, "Out of place tEXt");
+      {
+         png_error(png_ptr, "Out of place tEXt");
+         /* to quiet some compiler warnings */
+         if(info_ptr == NULL) return;
+      }
 
 #ifdef PNG_MAX_MALLOC_64K
    png_ptr->skip_length = 0;  /* This may not be necessary */
@@ -806,11 +824,12 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
    }
 #endif
 
-   png_ptr->current_text = (png_charp)png_malloc(png_ptr, length+1);
+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+         (png_uint_32)(length+1));
    png_ptr->current_text[length] = '\0';
    png_ptr->current_text_ptr = png_ptr->current_text;
-   png_ptr->current_text_size = length;
-   png_ptr->current_text_left = length;
+   png_ptr->current_text_size = (png_size_t)length;
+   png_ptr->current_text_left = (png_size_t)length;
    png_ptr->process_mode = PNG_READ_tEXt_MODE;
 }
 
@@ -857,7 +876,7 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
       if (text != key + png_ptr->current_text_size)
          text++;
 
-      text_ptr = (png_textp)png_malloc(png_ptr, sizeof(png_text));
+      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
       text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
       text_ptr->key = key;
       text_ptr->text = text;
@@ -874,7 +893,11 @@ void
 png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 {
    if (png_ptr->mode == PNG_BEFORE_IHDR || png_ptr->mode & PNG_HAVE_IEND)
-      png_error(png_ptr, "Out of place zTXt");
+      {
+         png_error(png_ptr, "Out of place zTXt");
+         /* to quiet some compiler warnings */
+         if(info_ptr == NULL) return;
+      }
 
 #ifdef PNG_MAX_MALLOC_64K
    /* We can't handle zTXt chunks > 64K, since we don't have enough space
@@ -889,11 +912,12 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
    }
 #endif
 
-   png_ptr->current_text = (png_charp)png_malloc(png_ptr, length+1);
+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+       (png_uint_32)(length+1));
    png_ptr->current_text[length] = '\0';
    png_ptr->current_text_ptr = png_ptr->current_text;
-   png_ptr->current_text_size = length;
-   png_ptr->current_text_left = length;
+   png_ptr->current_text_size = (png_size_t)length;
+   png_ptr->current_text_left = (png_size_t)length;
    png_ptr->process_mode = PNG_READ_zTXt_MODE;
 }
 
@@ -955,7 +979,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
       png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
          (text - key));
       png_ptr->zstream.next_out = png_ptr->zbuf;
-      png_ptr->zstream.avail_out = png_ptr->zbuf_size;
+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
 
       key_size = text - key;
       text_size = 0;
@@ -978,8 +1002,8 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
             if (text == NULL)
             {
                text = (png_charp)png_malloc(png_ptr,
-                  png_ptr->zbuf_size - png_ptr->zstream.avail_out +
-                     key_size + 1);
+                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out +
+                     key_size + 1));
                png_memcpy(text + key_size, png_ptr->zbuf,
                   png_ptr->zbuf_size - png_ptr->zstream.avail_out);
                png_memcpy(text, key, key_size);
@@ -992,8 +1016,9 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
                png_charp tmp;
 
                tmp = text;
-               text = png_malloc(png_ptr, text_size +
-                  png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1);
+               text = (png_charp)png_malloc(png_ptr, text_size +
+                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
+                   + 1));
                png_memcpy(text, tmp, text_size);
                png_free(png_ptr, tmp);
                png_memcpy(text + text_size, png_ptr->zbuf,
@@ -1029,9 +1054,8 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
       png_free(png_ptr, key);
       key = text;
       text += key_size;
-      text_size -= key_size;
 
-      text_ptr = (png_textp)png_malloc(png_ptr, sizeof(png_text));
+      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
       text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
       text_ptr->key = key;
       text_ptr->text = text;
@@ -1044,7 +1068,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
@@ -1058,6 +1082,8 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 len
    if (!(png_ptr->chunk_name[0] & 0x20))
    {
       png_chunk_error(png_ptr, "unknown critical chunk");
+      /* to quiet some compiler warnings */
+      if(info_ptr == NULL) return;
    }
 
    png_push_crc_skip(png_ptr, length);
@@ -1089,7 +1115,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 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
  * This file contains routines that an application calls directly to
  * read a PNG file or stream.
@@ -20,12 +19,31 @@ png_structp
 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, png_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
@@ -58,7 +81,8 @@ png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
 
    /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
-   png_ptr->zbuf = png_malloc(png_ptr, png_ptr->zbuf_size);
+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+     (png_uint_32)png_ptr->zbuf_size);
    png_ptr->zstream.zalloc = png_zalloc;
    png_ptr->zstream.zfree = png_zfree;
    png_ptr->zstream.opaque = (voidpf)png_ptr;
@@ -81,7 +105,7 @@ png_create_read_struct(png_const_charp user_png_ver, png_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)
@@ -100,7 +124,8 @@ png_read_init(png_structp png_ptr)
 
    /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
-   png_ptr->zbuf = png_malloc(png_ptr, png_ptr->zbuf_size);
+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+     (png_uint_32)png_ptr->zbuf_size);
    png_ptr->zstream.zalloc = png_zalloc;
    png_ptr->zstream.zfree = png_zfree;
    png_ptr->zstream.opaque = (voidpf)png_ptr;
@@ -121,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.
@@ -152,7 +177,7 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
       }
    }
 
-   while (1)
+   for(;;)
    {
       png_byte chunk_length[4];
       png_uint_32 length;
@@ -163,7 +188,8 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
       png_reset_crc(png_ptr);
       png_crc_read(png_ptr, png_ptr->chunk_name, 4);
 
-      png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);
+      png_debug2(0, "Reading %s chunk, length=%d.\n", png_ptr->chunk_name,
+         length);
 
       /* This should be a binary subdivision search or a hash for
        * matching the chunk name rather than a linear search.
@@ -256,7 +282,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
@@ -277,6 +303,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 */
@@ -414,7 +472,8 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
       png_ptr->row_buf + 1, png_ptr->prev_row + 1,
       (int)(png_ptr->row_buf[0]));
 
-   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
+   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
+      png_ptr->rowbytes + 1);
 
    if (png_ptr->transformations)
       png_do_read_transformations(png_ptr);
@@ -444,15 +503,18 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
          png_combine_row(png_ptr, dsp_row, 0xff);
    }
    png_read_finish_row(png_ptr);
+
+   if (png_ptr->read_row_fn != NULL)
+      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
 }
 
 /* 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.
- * 
+ *
  * "row" holds the actual image, and pixels are placed in it
  * as they arrive.  If the image is displayed after each pass, it will
  * appear to "sparkle" in.  "display_row" can be used to display a
@@ -466,6 +528,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.4e.
  */
 
 void
@@ -480,29 +544,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 && dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp++;
+         png_bytep dptr = *dp++;
 
-      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)
+         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
@@ -510,24 +577,36 @@ 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.4e.
  */
 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;
 
    png_debug(1, "in png_read_image\n");
    /* 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 */
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   pass = png_set_interlace_handling(png_ptr);
+#else
+   if (png_ptr->interlaced)
+      png_error(png_ptr,
+        "Cannot read interlaced image -- interlace handler disabled.");
+   pass = 1;
+#endif
+
+
+   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++;
@@ -639,6 +718,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 */
@@ -651,23 +733,46 @@ 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)
    {
+#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;
    }
 
    if (end_info_ptr != NULL)
    {
+#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;
    }
 }
@@ -680,6 +785,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 */
@@ -704,8 +812,9 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
    png_free(png_ptr, png_ptr->gamma_to_1);
 #endif
    if (png_ptr->flags & PNG_FLAG_FREE_PALETTE)
-      png_free(png_ptr, png_ptr->palette);
-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_bKGD_SUPPORTED)
+      png_zfree(png_ptr, png_ptr->palette);
+#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED) || \
+    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
    if (png_ptr->flags & PNG_FLAG_FREE_TRANS)
       png_free(png_ptr, png_ptr->trans);
 #endif
@@ -717,33 +826,39 @@ 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 defined(PNG_READ_BACKGROUND_SUPPORTED)
    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]);
       }
-   }
    png_free(png_ptr, png_ptr->gamma_16_from_1);
+   }
    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
@@ -758,12 +873,24 @@ 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));
 }
+
+void
+png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
+{
+   png_ptr->read_row_fn = read_row_fn;
+}

pngrio.c

@@ -1,17 +1,16 @@
 
 /* pngrio.c - functions for data input
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
- * 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. */
@@ -61,10 +60,10 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
    can't handle far buffers in the medium and small models, we have to copy
    the data.
 */
- 
+
 #define NEAR_BUF_SIZE 1024
 #define MIN(a,b) (a <= b ? a : b)
- 
+
 static void
 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
@@ -99,7 +98,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
       }
       while (remaining != 0);
    }
-   if (check != length)
+   if ((png_uint_32)check != (png_uint_32)length)
    {
       png_error(png_ptr, "read Error");
    }
@@ -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;

pngset.c

@@ -1,12 +1,11 @@
 
 /* pngset.c - storage of image information into info struct
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
  * The functions here are used during reads to store data from the file
  * into the info struct, and during writes to store application data
@@ -22,7 +21,7 @@ void
 png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
 {
    png_debug1(1, "in %s storage function\n", "bKGD");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    png_memcpy(&(info_ptr->background), background, sizeof(png_color_16));
@@ -37,7 +36,7 @@ png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
    double green_x, double green_y, double blue_x, double blue_y)
 {
    png_debug1(1, "in %s storage function\n", "cHRM");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->x_white = (float)white_x;
@@ -57,7 +56,7 @@ void
 png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
 {
    png_debug1(1, "in %s storage function\n", "gAMA");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->gamma = (float)file_gamma;
@@ -70,7 +69,7 @@ void
 png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
 {
    png_debug1(1, "in %s storage function\n", "hIST");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->hist = hist;
@@ -84,8 +83,9 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
    int color_type, int interlace_type, int compression_type,
    int filter_type)
 {
+   int rowbytes_per_pixel;
    png_debug1(1, "in %s storage function\n", "IHDR");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->width = width;
@@ -104,7 +104,17 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
    if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
       info_ptr->channels++;
    info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
-   info_ptr->rowbytes = ((info_ptr->width * info_ptr->pixel_depth + 7) >> 3);
+
+   /* check for overflow */
+   rowbytes_per_pixel = (info_ptr->pixel_depth + 7) >> 3;
+   if (( width > PNG_MAX_UINT/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)
@@ -113,7 +123,7 @@ png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
    png_uint_32 offset_x, png_uint_32 offset_y, int unit_type)
 {
    png_debug1(1, "in %s storage function\n", "oFFs");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->x_offset = offset_x;
@@ -129,17 +139,17 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
    png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
    png_charp units, png_charpp params)
 {
-   png_size_t length;
+   png_uint_32 length;
    int i;
 
    png_debug1(1, "in %s storage function\n", "pCAL");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    length = png_strlen(purpose) + 1;
    png_debug1(3, "allocating purpose for info (%d bytes)\n", length);
    info_ptr->pcal_purpose = (png_charp)png_malloc(png_ptr, length);
-   png_memcpy(info_ptr->pcal_purpose, purpose, length);
+   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
 
    png_debug(3, "storing X0, X1, type, and nparams in info\n");
    info_ptr->pcal_X0 = X0;
@@ -150,10 +160,10 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
    length = png_strlen(units) + 1;
    png_debug1(3, "allocating units for info (%d bytes)\n", length);
    info_ptr->pcal_units = (png_charp)png_malloc(png_ptr, length);
-   png_memcpy(info_ptr->pcal_units, units, length);
+   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
 
    info_ptr->pcal_params = (png_charpp)png_malloc(png_ptr,
-      (nparams + 1) * sizeof(png_charp));
+      (png_uint_32)((nparams + 1) * sizeof(png_charp)));
    info_ptr->pcal_params[nparams] = NULL;
 
    for (i = 0; i < nparams; i++)
@@ -161,7 +171,7 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
       length = png_strlen(params[i]) + 1;
       png_debug2(3, "allocating parameter %d for info (%d bytes)\n", i, length);
       info_ptr->pcal_params[i] = (png_charp)png_malloc(png_ptr, length);
-      png_memcpy(info_ptr->pcal_params[i], params[i], length);
+      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
    }
 
    info_ptr->valid |= PNG_INFO_pCAL;
@@ -174,7 +184,7 @@ png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
    png_uint_32 res_x, png_uint_32 res_y, int unit_type)
 {
    png_debug1(1, "in %s storage function\n", "pHYs");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->x_pixels_per_unit = res_x;
@@ -189,7 +199,7 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
    png_colorp palette, int num_palette)
 {
    png_debug1(1, "in %s storage function\n", "PLTE");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->palette = palette;
@@ -203,7 +213,7 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
    png_color_8p sig_bit)
 {
    png_debug1(1, "in %s storage function\n", "sBIT");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    png_memcpy(&(info_ptr->sig_bit), sig_bit, sizeof (png_color_8));
@@ -213,18 +223,18 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
 
 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
 void
-png_set_sRGB(png_structp png_ptr, png_infop info_ptr, png_byte intent)
+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
 {
    png_debug1(1, "in %s storage function\n", "sRGB");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
-   info_ptr->srgb_intent = intent;
+   info_ptr->srgb_intent = (png_byte)intent;
    info_ptr->valid |= PNG_INFO_sRGB;
 }
 void
 png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
-   png_byte intent)
+   int intent)
 {
 #if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
    float file_gamma;
@@ -233,13 +243,13 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
 #endif
    png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    png_set_sRGB(png_ptr, info_ptr, intent);
 
 #if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
-   file_gamma = (float).45;
+   file_gamma = (float).45455;
    png_set_gAMA(png_ptr, info_ptr, file_gamma);
 #endif
 
@@ -269,9 +279,9 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
    int i;
 
    png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?
-      "text" : png_ptr->chunk_name));
+      "text" : (png_const_charp)png_ptr->chunk_name));
 
-   if (info_ptr == NULL || num_text == 0)
+   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
       return;
 
    /* Make sure we have enough space in the "text" array in info_struct
@@ -288,8 +298,9 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
          info_ptr->max_text = info_ptr->num_text + num_text + 8;
          old_text = info_ptr->text;
          info_ptr->text = (png_textp)png_malloc(png_ptr,
-            info_ptr->max_text * sizeof (png_text));
-         png_memcpy(info_ptr->text, old_text, old_max * sizeof(png_text));
+            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));
+         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
+            sizeof(png_text)));
          png_free(png_ptr, old_text);
       }
       else
@@ -297,7 +308,7 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
          info_ptr->max_text = num_text + 8;
          info_ptr->num_text = 0;
          info_ptr->text = (png_textp)png_malloc(png_ptr,
-            info_ptr->max_text * sizeof (png_text));
+            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));
       }
       png_debug1(3, "allocated %d entries for info_ptr->text\n",
          info_ptr->max_text);
@@ -308,7 +319,7 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
       png_textp textp = &(info_ptr->text[info_ptr->num_text]);
 
       if (text_ptr[i].text == NULL)
-         text_ptr[i].text = "";
+         text_ptr[i].text = (png_charp)"";
 
       if (text_ptr[i].text[0] == '\0')
       {
@@ -333,7 +344,8 @@ void
 png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
 {
    png_debug1(1, "in %s storage function\n", "tIME");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL ||
+       (png_ptr->flags & PNG_FLAG_WROTE_tIME))
       return;
 
    png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time));
@@ -347,7 +359,7 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
    png_bytep trans, int num_trans, png_color_16p trans_values)
 {
    png_debug1(1, "in %s storage function\n", "tRNS");
-   if (info_ptr == NULL)
+   if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (trans != NULL)
@@ -367,3 +379,13 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
 }
 #endif
 
+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED)
+void
+png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
+{
+   png_debug1(1, "in png_permit_empty_plte\n", "");
+   if (png_ptr == NULL)
+      return;
+   png_ptr->empty_plte_permitted=(png_byte)empty_plte_permitted;
+}
+#endif

pngtest.c

@@ -1,12 +1,11 @@
 
 /* pngtest.c - a simple test program to test libpng
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
  * 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>
@@ -35,8 +35,33 @@
 #define PNG_DEBUG 0
 #endif
 
+/* Turn on CPU timing
+#define PNGTEST_TIMING
+*/
+
+#ifdef PNGTEST_TIMING
+static float t_start, t_stop, t_decode, t_encode, t_misc;
+#include <time.h>
+#endif
+
 #include "png.h"
 
+#ifdef PNGTEST_TIMING
+static float t_start, t_stop, t_decode, t_encode, t_misc;
+#if !defined(PNG_READ_tIME_SUPPORTED) && !defined(PNG_WRITE_tIME_SUPPORTED)
+#include <time.h>
+#endif
+#endif
+
+#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 */
+
+static int verbose = 0;
+
+int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
+
 #ifdef __TURBOC__
 #include <mem.h>
 #endif
@@ -45,11 +70,153 @@
 /*  #define STDERR stderr  */
 #define STDERR stdout   /* for DOS */
 
+/* example of using row callbacks to make a simple progress meter */
+static int status_pass=1;
+static int status_dots_requested=0;
+static int status_dots=1;
+
+void
+read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
+{
+    if(png_ptr == NULL || row_number > PNG_MAX_UINT) return;
+    if(status_pass != pass)
+    {
+       fprintf(stdout,"\n Pass %d: ",pass);
+       status_pass = pass;
+       status_dots = 31;
+    }
+    status_dots--;
+    if(status_dots == 0)
+    {
+       fprintf(stdout, "\n         ");
+       status_dots=30;
+    }
+    fprintf(stdout, "r");
+}
+
+void
+write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
+{
+    if(png_ptr == NULL || row_number > PNG_MAX_UINT || pass > 7) return;
+    fprintf(stdout, "w");
+}
+
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+/* Example of using user transform callback (we don't transform anything,
+   but merely examine the row filters.  We set this to 256 rather than
+   5 in case illegal filter values are present.) */
+static png_uint_32 filters_used[256];
+void
+count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+{
+    if(png_ptr != NULL && row_info != NULL)
+      ++filters_used[*(data-1)];
+}
+#endif
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+/* example of using user transform callback (we don't transform anything,
+   but merely count the zero samples) */
+
+static png_uint_32 zero_samples;
+
+void
+count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+{
+   png_bytep dp = data;
+   if(png_ptr == NULL)return;
+
+   /* contents of row_info:
+    *  png_uint_32 width      width of row
+    *  png_uint_32 rowbytes   number of bytes in row
+    *  png_byte color_type    color type of pixels
+    *  png_byte bit_depth     bit depth of samples
+    *  png_byte channels      number of channels (1-4)
+    *  png_byte pixel_depth   bits per pixel (depth*channels)
+    */
+
+
+    /* 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, nstop;
+       for (n=0, nstop=row_info->width; n<nstop; n++)
+       {
+          if(row_info->bit_depth == 1)
+          {
+             if(((*dp << pos++ )& 0x80) == 0) zero_samples++;
+             if(pos == 8)
+             {
+                pos = 0;
+                dp++;
+             }
+          }
+          if(row_info->bit_depth == 2)
+          {
+             if(((*dp << (pos+=2))& 0xc0) == 0) zero_samples++;
+             if(pos == 8)
+             {
+                pos = 0;
+                dp++;
+             }
+          }
+          if(row_info->bit_depth == 4)
+          {
+             if(((*dp << (pos+=4))& 0xf0) == 0) zero_samples++;
+             if(pos == 8)
+             {
+                pos = 0;
+                dp++;
+             }
+          }
+          if(row_info->bit_depth == 8)
+             if(*dp++ == 0) zero_samples++;
+          if(row_info->bit_depth == 16)
+          {
+             if((*dp | *(dp+1)) == 0) zero_samples++;
+             dp+=2;
+          }
+       }
+    }
+    else /* other color types */
+    {
+       png_uint_32 n, nstop;
+       int channel;
+       int color_channels = row_info->channels;
+       if(row_info->color_type > 3)color_channels--;
+
+       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) zero_samples++;
+             if(row_info->bit_depth == 16)
+             {
+                if((*dp | *(dp+1)) == 0) zero_samples++;
+                dp+=2;
+             }
+          }
+          if(row_info->color_type > 3)
+          {
+             dp++;
+             if(row_info->bit_depth == 16)dp++;
+          }
+       }
+    }
+}
+#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */
+
+static int wrote_question = 0;
+
+#if defined(PNG_NO_STDIO)
 /* 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. */
-#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. */
@@ -75,10 +242,10 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
    can't handle far buffers in the medium and small models, we have to copy
    the data.
 */
- 
+
 #define NEAR_BUF_SIZE 1024
 #define MIN(a,b) (a <= b ? a : b)
- 
+
 static void
 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
@@ -118,7 +285,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
       png_error(png_ptr, "read Error");
    }
 }
-#endif
+#endif /* USE_FAR_KEYWORD */
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 static void
@@ -131,7 +298,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. */
@@ -196,7 +363,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
    }
 }
 
-#endif
+#endif /* USE_FAR_KEYWORD */
 
 /* 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
@@ -221,16 +388,113 @@ 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
+#endif /* PNG_NO_STDIO */
 /* END of code to validate stdio-free compilation */
 
-/* Test one file */
-int test(PNG_CONST char *inname, PNG_CONST char *outname)
+/* START of code to validate memory allocation and deallocation */
+#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
+   it not to.  See zconf.h and png.h for more information.  zlib does
+   need to allocate exactly 64K, so whatever you call here must
+   have the ability to do that.
+
+   This piece of code can be compiled to validate max 64K allocations
+   by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */
+typedef struct memory_information {
+   png_uint_32                    size;
+   png_voidp                 pointer;
+   struct memory_information FAR *next;
+} memory_information;
+typedef memory_information FAR *memory_infop;
+
+static memory_infop pinformation = NULL;
+static int current_allocation = 0;
+static int maximum_allocation = 0;
+
+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));
+
+png_voidp
+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_malloc_default(png_ptr, sizeof *pinfo);
+      pinfo->size = size;
+      current_allocation += size;
+      if (current_allocation > maximum_allocation)
+         maximum_allocation = current_allocation;
+      pinfo->pointer = png_malloc_default(png_ptr, size);
+      pinfo->next = pinformation;
+      pinformation = pinfo;
+      /* Make sure the caller isn't assuming zeroed memory. */
+      png_memset(pinfo->pointer, 0xdd, pinfo->size);
+      return (png_voidp)(pinfo->pointer);
+   }
+}
+
+/* Free a pointer.  It is removed from the list at the same time. */
+void
+png_debug_free(png_structp png_ptr, png_voidp ptr)
 {
-   FILE *fpin, *fpout;
+   if (png_ptr == NULL)
+      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");
+#endif
+      return;
+   }
+
+   /* Unlink the element from the list. */
+   {
+      memory_infop FAR *ppinfo = &pinformation;
+      for (;;) {
+         memory_infop pinfo = *ppinfo;
+         if (pinfo->pointer == ptr) {
+            *ppinfo = pinfo->next;
+            current_allocation -= pinfo->size;
+            if (current_allocation < 0)
+               fprintf(STDERR, "Duplicate free of memory\n");
+            /* We must free the list element too, but first kill
+               the memory that is to be freed. */
+            memset(ptr, 0x55, pinfo->size);
+            png_free_default(png_ptr, pinfo);
+            break;
+         }
+         if (pinfo->next == NULL) {
+            fprintf(STDERR, "Pointer %x not found\n", ptr);
+            break;
+         }
+         ppinfo = &pinfo->next;
+      }
+   }
+
+   /* Finally free the data. */
+   png_free_default(png_ptr, ptr);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */
+/* END of code to test memory allocation/deallocation */
+
+/* Test one file */
+int
+test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
+{
+   static FILE *fpin, *fpout;  /* "static" prevents setjmp corruption */
    png_structp read_ptr, write_ptr;
    png_infop read_info_ptr, write_info_ptr, end_info_ptr;
    png_bytep row_buf;
@@ -241,7 +505,7 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
 #ifdef USE_FAR_KEYWORD
    jmp_buf jmpbuf;
 #endif   
-   
+
    char inbuf[256], outbuf[256];
 
    row_buf = (png_bytep)NULL;
@@ -249,31 +513,47 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
    if ((fpin = fopen(inname, "rb")) == NULL)
    {
       fprintf(STDERR, "Could not find input file %s\n", inname);
-      return 1;
+      return (1);
    }
 
    if ((fpout = fopen(outname, "wb")) == NULL)
    {
       fprintf(STDERR, "Could not open output file %s\n", outname);
       fclose(fpin);
-      return 1;
+      return (1);
    }
 
    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);
-#if defined(PNG_NO_STDIO)
-   png_set_error_fn(read_ptr, (png_voidp)inname, png_default_error, png_default_warning);
 #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);
+   png_set_error_fn(write_ptr, (png_voidp)inname, png_default_error,
+       png_default_warning);
 #endif
    png_debug(0, "Allocating read_info, write_info and end_info structures\n");
    read_info_ptr = png_create_info_struct(read_ptr);
-   write_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
@@ -287,12 +567,14 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
       png_destroy_write_struct(&write_ptr, &write_info_ptr);
       fclose(fpin);
       fclose(fpout);
-      return 1;
+      return (1);
    }
+#ifdef USE_FAR_KEYWORD
+   png_memcpy(read_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
+#endif
 
    png_debug(0, "Setting jmpbuf for write struct\n");
 #ifdef USE_FAR_KEYWORD
-   png_memcpy(read_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
    if (setjmp(jmpbuf))
 #else
    if (setjmp(write_ptr->jmpbuf))
@@ -303,12 +585,12 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
       png_destroy_write_struct(&write_ptr, &write_info_ptr);
       fclose(fpin);
       fclose(fpout);
-      return 1;
+      return (1);
    }
-
 #ifdef USE_FAR_KEYWORD
    png_memcpy(write_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
 #endif
+
    png_debug(0, "Initializing input and output streams\n");
 #if !defined(PNG_NO_STDIO)
    png_init_io(read_ptr, fpin);
@@ -321,6 +603,29 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
 #else
       NULL);
 #endif
+#endif
+   if(status_dots_requested == 1)
+   {
+      png_set_write_status_fn(write_ptr, write_row_callback);
+      png_set_read_status_fn(read_ptr, read_row_callback);
+   }
+   else
+   {
+      png_set_write_status_fn(write_ptr, NULL);
+      png_set_read_status_fn(read_ptr, NULL);
+   }
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+   {
+     int i;
+     for(i=0; i<256; i++)
+        filters_used[i]=0;
+     png_set_read_user_transform_fn(read_ptr, count_filters);
+   }
+#endif
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+   zero_samples=0;
+   png_set_write_user_transform_fn(write_ptr, count_zero_samples);
 #endif
 
    png_debug(0, "Reading info struct\n");
@@ -334,7 +639,11 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
           &color_type, &interlace_type, &compression_type, &filter_type))
       {
          png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
             color_type, interlace_type, compression_type, filter_type);
+#else
+            color_type, PNG_INTERLACE_NONE, compression_type, filter_type);
+#endif
       }
    }
 #if defined(PNG_READ_bKGD_SUPPORTED) && defined(PNG_WRITE_bKGD_SUPPORTED)
@@ -371,7 +680,7 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
 #endif
 #if defined(PNG_READ_sRGB_SUPPORTED) && defined(PNG_WRITE_sRGB_SUPPORTED)
    {
-      png_byte intent;
+      int intent;
 
       if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
       {
@@ -465,6 +774,13 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
       if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
       {
          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
@@ -486,7 +802,8 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
    png_debug(0, "\nWriting info struct\n");
    png_write_info(write_ptr, write_info_ptr);
 
-   row_buf = (png_bytep)png_malloc(read_ptr, 
+   png_debug(0, "\nAllocating row buffer \n");
+   row_buf = (png_bytep)png_malloc(read_ptr,
       png_get_rowbytes(read_ptr, read_info_ptr));
    if (row_buf == NULL)
    {
@@ -495,18 +812,40 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
       png_destroy_write_struct(&write_ptr, &write_info_ptr);
       fclose(fpin);
       fclose(fpout);
-      return 1;
+      return (1);
    }
+   png_debug(0, "Writing row data\n");
 
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+  defined(PNG_WRITE_INTERLACING_SUPPORTED)
    num_pass = png_set_interlace_handling(read_ptr);
    png_set_interlace_handling(write_ptr);
+#else
+   num_pass=1;
+#endif
 
+#ifdef PNGTEST_TIMING
+   t_stop = (float)clock();
+   t_misc += (t_stop - t_start);
+   t_start = t_stop;
+#endif
    for (pass = 0; pass < num_pass; pass++)
    {
+      png_debug1(0, "Writing row data for pass %d\n",pass);
       for (y = 0; y < height; y++)
       {
          png_read_rows(read_ptr, (png_bytepp)&row_buf, (png_bytepp)NULL, 1);
+#ifdef PNGTEST_TIMING
+         t_stop = (float)clock();
+         t_decode += (t_stop - t_start);
+         t_start = t_stop;
+#endif
          png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
+#ifdef PNGTEST_TIMING
+         t_stop = (float)clock();
+         t_encode += (t_stop - t_start);
+         t_start = t_stop;
+#endif
       }
    }
 
@@ -514,30 +853,40 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
    png_read_end(read_ptr, end_info_ptr);
    png_write_end(write_ptr, end_info_ptr);
 
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+   if(verbose)
+   {
+      png_uint_32 iwidth, iheight;
+      iwidth = png_get_image_width(write_ptr, write_info_ptr);
+      iheight = png_get_image_height(write_ptr, write_info_ptr);
+      fprintf(STDERR, "Image width = %lu, height = %lu\n",
+         iwidth, iheight);
+   }
+#endif
+
    png_debug(0, "Destroying data structs\n");
+   png_free(read_ptr, row_buf);
    png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
    png_destroy_write_struct(&write_ptr, &write_info_ptr);
 
    fclose(fpin);
    fclose(fpout);
 
-   png_free(read_ptr, row_buf);
-
    png_debug(0, "Opening files for comparison\n");
    if ((fpin = fopen(inname, "rb")) == NULL)
    {
       fprintf(STDERR, "Could not find file %s\n", inname);
-      return 1;
+      return (1);
    }
 
    if ((fpout = fopen(outname, "rb")) == NULL)
    {
       fprintf(STDERR, "Could not find file %s\n", outname);
       fclose(fpin);
-      return 1;
+      return (1);
    }
 
-   while (1)
+   for(;;)
    {
       png_size_t num_in, num_out;
 
@@ -548,9 +897,20 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
       {
          fprintf(STDERR, "Files %s and %s are of a different size\n",
                  inname, outname);
+         if(wrote_question == 0)
+         {
+            fprintf(STDERR,
+              "   Was %s written with the same chunk size (8k),",inname);
+            fprintf(STDERR,
+              " filtering\n   heuristic (libpng default), compression");
+            fprintf(STDERR,
+              " level (zlib default)\n   and zlib version (%s)?\n\n",
+              ZLIB_VERSION);
+            wrote_question=1;
+         }
          fclose(fpin);
          fclose(fpout);
-         return 1;
+         return (0);
       }
 
       if (!num_in)
@@ -558,26 +918,37 @@ int test(PNG_CONST char *inname, PNG_CONST char *outname)
 
       if (png_memcmp(inbuf, outbuf, num_in))
       {
-         fprintf(STDERR, "Files %s and %s are different\n", inname, outname);
+         fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);
+         if(wrote_question == 0)
+         {
+            fprintf(STDERR,
+              "   Was %s written with the same chunk size (8k),",inname);
+            fprintf(STDERR,
+              " filtering\n   heuristic (libpng default), compression");
+            fprintf(STDERR,
+              " level (zlib default)\n   and zlib version (%s)?\n\n",
+              ZLIB_VERSION);
+            wrote_question=1;
+         }
          fclose(fpin);
          fclose(fpout);
-         return 1;
+         return (0);
       }
    }
 
    fclose(fpin);
    fclose(fpout);
 
-   return 0;
+   return (0);
 }
 
 /* input and output filenames */
 #ifdef RISCOS
-PNG_CONST char *inname = "pngtest_png";
-PNG_CONST char *outname = "pngout_png";
+static PNG_CONST char *inname = "pngtest/png";
+static PNG_CONST char *outname = "pngout/png";
 #else
-PNG_CONST char *inname = "pngtest.png";
-PNG_CONST char *outname = "pngout.png";
+static PNG_CONST char *inname = "pngtest.png";
+static PNG_CONST char *outname = "pngout.png";
 #endif
 
 int
@@ -587,6 +958,20 @@ main(int argc, char *argv[])
    int ierror = 0;
 
    fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
+   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);
+   fprintf(STDERR,"%s",png_get_copyright(NULL));
+
+   /* Do some consistency checking on the memory allocation settings, I'm
+      not sure this matters, but it is nice to know, the first of these
+      tests should be impossible because of the way the macros are set
+      in pngconf.h */
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
+      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
+#endif
+   /* I think the following can happen. */
+#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
+      fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");
+#endif
 
    if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
    {
@@ -599,41 +984,195 @@ main(int argc, char *argv[])
 
    if (argc > 1)
    {
-   if (strcmp(argv[1], "-m") == 0)
-      multiple = 1;
-   else
-      inname = argv[1];
+      if (strcmp(argv[1], "-m") == 0)
+      {
+         multiple = 1;
+         status_dots_requested = 0;
+      }
+      else if (strcmp(argv[1], "-mv") == 0 ||
+               strcmp(argv[1], "-vm") == 0 )
+      {
+         multiple = 1;
+         verbose = 1;
+         status_dots_requested = 1;
+      }
+      else if (strcmp(argv[1], "-v") == 0)
+      {
+         verbose = 1;
+         status_dots_requested = 1;
+         inname = argv[2];
+      }
+      else
+      {
+         inname = argv[1];
+         status_dots_requested = 0;
+      }
    }
 
-   if (!multiple && argc == 3)
-     outname = argv[2];
+   if (!multiple && argc == 3+verbose)
+     outname = argv[2+verbose];
 
-   if (!multiple && argc > 3 || multiple && argc < 2)
+   if ((!multiple && argc > 3+verbose) || (multiple && argc < 2))
    {
-     fprintf(STDERR, "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
+     fprintf(STDERR,
+       "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
         argv[0], argv[0]);
-     fprintf(STDERR, "  reads/writes one PNG file (without -m) or multiple files (-m)\n");
-     fprintf(STDERR, "  with -m %s is used as a temporary file\n", outname);
+     fprintf(STDERR,
+       "  reads/writes one PNG file (without -m) or multiple files (-m)\n");
+     fprintf(STDERR,
+       "  with -m %s is used as a temporary file\n", outname);
      exit(1);
    }
 
    if (multiple)
    {
       int i;
+#ifdef PNG_USER_MEM_SUPPORTED
+      int allocation_now = current_allocation;
+#endif
       for (i=2; i<argc; ++i)
+      {
+         int k, kerror;
+         fprintf(STDERR, "Testing %s:",argv[i]);
+         kerror = test_one_file(argv[i], outname);
+         if (kerror == 0)
          {
-         fprintf(STDERR, "Testing %s:\n",argv[i]);
-         ierror += test(argv[i], outname);
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+            fprintf(STDERR, " PASS (%lu zero samples)\n",zero_samples);
+#else
+            fprintf(STDERR, " PASS\n");
+#endif
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+            for (k=0; k<256; k++)
+               if(filters_used[k])
+                  fprintf(STDERR, " Filter %d was used %lu times\n",
+                     k,filters_used[k]);
+#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 PNG_USER_MEM_SUPPORTED
+         if (allocation_now != current_allocation)
+            fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
+               current_allocation-allocation_now);
+         if (current_allocation != 0) {
+            memory_infop pinfo = pinformation;
+
+            fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
+               current_allocation);
+            while (pinfo != NULL) {
+               fprintf(STDERR, " %d bytes at %x\n", pinfo->size, pinfo->pointer);
+               pinfo = pinfo->next;
+               }
+         }
+#endif
+      }
+#ifdef PNG_USER_MEM_SUPPORTED
+         fprintf(STDERR, " Current memory allocation: %d bytes\n",
+            current_allocation);
+         fprintf(STDERR, " Maximum memory allocation: %d bytes\n",
+            maximum_allocation);
+#endif
    }
    else
    {
-      ierror += test(inname, outname);
+      int i;
+      for (i=0; i<3; ++i) {
+         int kerror;
+#ifdef PNG_USER_MEM_SUPPORTED
+         int allocation_now = current_allocation;
+#endif
+         if (i == 1) status_dots_requested = 1;
+         else if(verbose == 0)status_dots_requested = 0;
+         if (i == 0 || verbose == 1 || ierror != 0)
+            fprintf(STDERR, "Testing %s:",inname);
+         kerror = test_one_file(inname, outname);
+         if(kerror == 0)
+         {
+            if(verbose == 1 || i == 2)
+            {
+                int k;
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+                fprintf(STDERR, " PASS (%lu zero samples)\n",zero_samples);
+#else
+                fprintf(STDERR, " PASS\n");
+#endif
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+                for (k=0; k<256; k++)
+                   if(filters_used[k])
+                      fprintf(STDERR, " Filter %d was used %lu times\n",
+                         k,filters_used[k]);
+#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
+         {
+            if(verbose == 0 && i != 2)
+               fprintf(STDERR, "Testing %s:",inname);
+            fprintf(STDERR, " FAIL\n");
+            ierror += kerror;
+         }
+#ifdef PNG_USER_MEM_SUPPORTED
+         if (allocation_now != current_allocation)
+             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
+               current_allocation-allocation_now);
+         if (current_allocation != 0) {
+             memory_infop pinfo = pinformation;
+
+             fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
+                current_allocation);
+             while (pinfo != NULL) {
+                fprintf(STDERR, " %d bytes at %x\n", pinfo->size, pinfo->pointer);
+                pinfo = pinfo->next;
+             }
+          }
+#endif
+       }
+#ifdef PNG_USER_MEM_SUPPORTED
+       fprintf(STDERR, " Current memory allocation: %d bytes\n",
+          current_allocation);
+       fprintf(STDERR, " Maximum memory allocation: %d bytes\n",
+          maximum_allocation);
+#endif
    }
 
+#ifdef PNGTEST_TIMING
+   t_stop = (float)clock();
+   t_misc += (t_stop - t_start);
+   t_start = t_stop;
+   fprintf(STDERR," CPU time used = %.3f seconds",
+      (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);
+   fprintf(STDERR," (decoding %.3f,\n",
+      t_decode/(float)CLOCKS_PER_SEC);
+   fprintf(STDERR,"        encoding %.3f ,",
+      t_encode/(float)CLOCKS_PER_SEC);
+   fprintf(STDERR," other %.3f seconds)\n\n",
+      t_misc/(float)CLOCKS_PER_SEC);
+#endif
+
    if (ierror == 0)
       fprintf(STDERR, "libpng passes test\n");
    else
       fprintf(STDERR, "libpng FAILS test\n");
-   return ierror != 0;
+   return (int)(ierror != 0);
+}
+
+/* Generate a compiler error if there is an old png.h in the search path. */
+void
+png_check_pngtest_version
+   (version_1_0_4e png_h_is_not_version_1_0_4e)
+{
+   if(png_h_is_not_version_1_0_4e == NULL) return;
 }

pngtrans.c

@@ -1,19 +1,18 @@
 
 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  */
 
 #define PNG_INTERNAL
 #include "png.h"
 
 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
-/* turn on bgr to rgb mapping */
+/* turn on BGR-to-RGB mapping */
 void
 png_set_bgr(png_structp png_ptr)
 {
@@ -68,7 +67,8 @@ png_set_shift(png_structp png_ptr, png_color_8p true_bits)
 }
 #endif
 
-#if defined(PNG_READ_INTERLACING_SUPPORTED) || defined(PNG_WRITE_INTERLACING_SUPPORTED)
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+    defined(PNG_WRITE_INTERLACING_SUPPORTED)
 int
 png_set_interlace_handling(png_structp png_ptr)
 {
@@ -76,18 +76,18 @@ png_set_interlace_handling(png_structp png_ptr)
    if (png_ptr->interlaced)
    {
       png_ptr->transformations |= PNG_INTERLACE;
-      return 7;
+      return (7);
    }
 
-   return 1;
+   return (1);
 }
 #endif
 
 #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,11 +100,23 @@ png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
    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)
+   /* This should probably go in the "do_filler" routine.
+    * I attempted to do that in libpng-1.0.1a but that caused problems
+    * so I restored it in libpng-1.0.2a
+   */
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
    {
       png_ptr->usr_channels = 4;
    }
+
+   /* Also I added this in libpng-1.0.2a (what happens when we expand
+    * a less-than-8-bit grayscale to GA? */
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
+   {
+      png_ptr->usr_channels = 2;
+   }
 }
 #endif
 
@@ -118,6 +130,16 @@ png_set_swap_alpha(png_structp png_ptr)
 }
 #endif
 
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void
+png_set_invert_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_invert_alpha\n");
+   png_ptr->transformations |= PNG_INVERT_ALPHA;
+}
+#endif
+
 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 void
 png_set_invert_mono(png_structp png_ptr)
@@ -126,7 +148,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)
 {
@@ -137,12 +159,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++;
       }
    }
 }
@@ -160,15 +184,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;
       }
@@ -289,7 +311,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
    png_debug(1, "in png_do_packswap\n");
    if (
 #if defined(PNG_USELESS_TESTS_SUPPORTED)
-       row != NULL && row_info != NULL
+       row != NULL && row_info != NULL &&
 #endif
        row_info->bit_depth < 8)
    {
@@ -327,6 +349,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)
@@ -334,10 +361,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++;
@@ -348,10 +373,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++;
@@ -360,17 +382,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);
@@ -388,17 +408,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++;
@@ -408,9 +426,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 ||
@@ -423,10 +442,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++;
@@ -435,27 +451,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++;
@@ -464,11 +475,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++;
@@ -476,9 +484,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;
       }
    }
 }
@@ -496,17 +505,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;
             }
@@ -514,12 +523,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;
             }
@@ -530,33 +538,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;
             }
          }
       }
@@ -564,3 +570,26 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
 }
 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
 
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+void
+png_set_user_transform_info(png_structp png_ptr, png_voidp
+   user_transform_ptr, int user_transform_depth, int user_transform_channels)
+{
+   png_debug(1, "in png_set_user_transform_info\n");
+   png_ptr->user_transform_ptr = user_transform_ptr;
+   png_ptr->user_transform_depth = (png_byte)user_transform_depth;
+   png_ptr->user_transform_channels = (png_byte)user_transform_channels;
+}
+
+/* This function returns a pointer to the user_transform_ptr associated with
+ * the user transform 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_user_transform_ptr(png_structp png_ptr)
+{
+   return ((png_voidp)png_ptr->user_transform_ptr);
+}
+#endif

pngwio.c

@@ -1,17 +1,16 @@
 
 /* pngwio.c - functions for data output
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  *
- * 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,14 +174,21 @@ 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) 
-#if defined(_MSC_VER)   
-void *far_to_near(png_structp png_ptr,png_voidp ptr, int check)
+#if defined(USE_FAR_KEYWORD)
+#if defined(_MSC_VER)
+void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)
 {
-   void *near_ptr;   
+   void *near_ptr;
    void FAR *far_ptr;
    FP_OFF(near_ptr) = FP_OFF(ptr);
    far_ptr = (void FAR *)near_ptr;
@@ -192,9 +198,9 @@ void *far_to_near(png_structp png_ptr,png_voidp ptr, int check)
    return(near_ptr);
 }
 #  else
-void *far_to_near(png_structp png_ptr,png_voidp ptr, int check)
+void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)
 {
-   void *near_ptr;   
+   void *near_ptr;
    void FAR *far_ptr;
    near_ptr = (void FAR *)ptr;
    far_ptr = (void FAR *)near_ptr;

pngwrite.c

@@ -1,12 +1,11 @@
-   
+
 /* pngwrite.c - general routines to write a PNG file
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  */
 
 /* 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
@@ -34,7 +33,12 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
    /* write IHDR information. */
    png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
       info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
-      info_ptr->filter_type, info_ptr->interlace_type);
+      info_ptr->filter_type,
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+      info_ptr->interlace_type);
+#else
+      0);
+#endif
    /* the rest of these check to see if the valid field has the appropriate
       flag set, and if it does, writes the chunk. */
 #if defined(PNG_WRITE_gAMA_SUPPORTED)
@@ -43,7 +47,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
 #endif
 #if defined(PNG_WRITE_sRGB_SUPPORTED)
    if (info_ptr->valid & PNG_INFO_sRGB)
-      png_write_sRGB(png_ptr, info_ptr->srgb_intent);
+      png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
 #endif
 #if defined(PNG_WRITE_sBIT_SUPPORTED)
    if (info_ptr->valid & PNG_INFO_sBIT)
@@ -62,10 +66,23 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
          (png_uint_32)info_ptr->num_palette);
    else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       png_error(png_ptr, "Valid palette required for paletted images\n");
+
 #if defined(PNG_WRITE_tRNS_SUPPORTED)
    if (info_ptr->valid & PNG_INFO_tRNS)
+      {
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+         /* invert the alpha channel (in tRNS) */
+         if (png_ptr->transformations & PNG_INVERT_ALPHA &&
+            info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+         {
+            int j;
+            for (j=0; j<(int)info_ptr->num_trans; j++)
+               info_ptr->trans[j] = 255 - info_ptr->trans[j];
+         }
+#endif
       png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),
          info_ptr->num_trans, info_ptr->color_type);
+      }
 #endif
 #if defined(PNG_WRITE_bKGD_SUPPORTED)
    if (info_ptr->valid & PNG_INFO_bKGD)
@@ -200,41 +217,6 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
    png_write_IEND(png_ptr);
 }
 
-#if defined(PNG_TIME_RFC1152_SUPPORTED)
-/* Convert the supplied time into an RFC 1152 string suitable for use in
- * a "Creation Time" or other text-based time string.
- */
-png_charp
-png_convert_to_rfc1152(png_structp png_ptr, png_timep ptime)
-{
-   const char *short_months[12] = {"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, 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_ptr->time_buffer;
-}
-#endif /* PNG_TIME_RFC1152_SUPPORTED */
-
 #if defined(PNG_WRITE_tIME_SUPPORTED)
 void
 png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
@@ -261,17 +243,34 @@ 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;
+      return ((png_structp)NULL);
    }
 #ifdef USE_FAR_KEYWORD
    if (setjmp(jmpbuf))
@@ -281,11 +280,14 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
    {
       png_free(png_ptr, png_ptr->zbuf);
       png_destroy_struct(png_ptr);
-      return (png_structp)NULL;
+      return ((png_structp)NULL);
    }
 #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
@@ -302,7 +304,8 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
 
    /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
-   png_ptr->zbuf = png_malloc(png_ptr, png_ptr->zbuf_size);
+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+      (png_uint_32)png_ptr->zbuf_size);
 
    png_set_write_fn(png_ptr, NULL, NULL, NULL);
 
@@ -311,10 +314,9 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
       1, NULL, NULL);
 #endif
 
-   return (png_ptr);
+   return ((png_structp)png_ptr);
 }
 
-
 /* Initialize png_ptr structure, and allocate any memory needed */
 void
 png_write_init(png_structp png_ptr)
@@ -333,7 +335,8 @@ png_write_init(png_structp png_ptr)
 
    /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
-   png_ptr->zbuf = png_malloc(png_ptr, png_ptr->zbuf_size);
+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+      (png_uint_32)png_ptr->zbuf_size);
    png_set_write_fn(png_ptr, NULL, NULL, NULL);
 
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
@@ -373,9 +376,13 @@ png_write_image(png_structp png_ptr, png_bytepp image)
    png_bytepp rp; /* points to current row */
 
    png_debug(1, "in png_write_image\n");
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
    /* intialize interlace handling.  If image is not interlaced,
       this will set pass to 1 */
    num_pass = png_set_interlace_handling(png_ptr);
+#else
+   num_pass = 1;
+#endif
    /* loop through passes */
    for (pass = 0; pass < num_pass; pass++)
    {
@@ -396,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);
    }
 
@@ -465,6 +502,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
    png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
    png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
       png_ptr->row_info.channels);
+
    png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
       (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
 
@@ -476,7 +514,8 @@ png_write_row(png_structp png_ptr, png_bytep row)
    png_debug1(3, "row_info->rowbytes = %d\n", png_ptr->row_info.rowbytes);
 
    /* Copy user's row into buffer, leaving room for filter byte. */
-   png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);
+   png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,
+      png_ptr->row_info.rowbytes);
 
 #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
    /* handle interlacing */
@@ -500,6 +539,9 @@ png_write_row(png_structp png_ptr, png_bytep row)
 
    /* Find a filter if necessary, filter the row and write it out. */
    png_write_find_filter(png_ptr, &(png_ptr->row_info));
+
+   if (png_ptr->write_row_fn != NULL)
+      (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
 }
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
@@ -570,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;
@@ -583,14 +633,35 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
 #ifdef PNG_WRITE_tEXt_SUPPORTED
       png_free(png_ptr, info_ptr->text);
 #endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+      png_free(png_ptr, info_ptr->pcal_purpose);
+      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]);
+         }
+         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;
    }
 }
@@ -604,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 */
@@ -617,9 +691,9 @@ png_write_destroy(png_structp png_ptr)
    png_free(png_ptr, png_ptr->up_row);
    png_free(png_ptr, png_ptr->avg_row);
    png_free(png_ptr, png_ptr->paeth_row);
-#if defined(PNG_TIME_RFC1152_SUPPORTED)
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
    png_free(png_ptr, png_ptr->time_buffer);
-#endif /* PNG_TIME_RFC1152_SUPPORTED */
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
    png_free(png_ptr, png_ptr->prev_filters);
    png_free(png_ptr, png_ptr->filter_weights);
@@ -634,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));
 }
@@ -679,7 +759,7 @@ png_set_filter(png_structp png_ptr, int method, int filters)
          if (png_ptr->do_filter & PNG_FILTER_SUB && png_ptr->sub_row == NULL)
          {
             png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
-               png_ptr->rowbytes + 1);
+              (png_ptr->rowbytes + 1));
             png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
          }
 
@@ -693,7 +773,7 @@ png_set_filter(png_structp png_ptr, int method, int filters)
             else
             {
                png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
-                  png_ptr->rowbytes + 1);
+                  (png_ptr->rowbytes + 1));
                png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
             }
          }
@@ -708,7 +788,7 @@ png_set_filter(png_structp png_ptr, int method, int filters)
             else
             {
                png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
-                  png_ptr->rowbytes + 1);
+                  (png_ptr->rowbytes + 1));
                png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
             }
          }
@@ -723,8 +803,8 @@ png_set_filter(png_structp png_ptr, int method, int filters)
             }
             else
             {
-               png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr,
-                  png_ptr->rowbytes + 1);
+               png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
+                  (png_ptr->rowbytes + 1));
                png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
             }
          }
@@ -750,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)
@@ -780,7 +858,7 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
       if (png_ptr->prev_filters == NULL)
       {
          png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
-            sizeof(png_byte) * num_weights);
+            (png_uint_32)(sizeof(png_byte) * num_weights));
 
          /* To make sure that the weighting starts out fairly */
          for (i = 0; i < num_weights; i++)
@@ -791,11 +869,11 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
 
       if (png_ptr->filter_weights == NULL)
       {
-         png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
-            sizeof(png_uint_16) * num_weights);
+         png_ptr->filter_weights = (png_uint_16p) png_malloc(png_ptr,
+            (png_uint_32)(sizeof(png_uint_16) * num_weights));
 
-         png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
-            sizeof(png_uint_16) * num_weights);
+         png_ptr->inv_filter_weights = (png_uint_16p) png_malloc(png_ptr,
+            (png_uint_32)(sizeof(png_uint_16) * num_weights));
 
          for (i = 0; i < num_weights; i++)
          {
@@ -826,11 +904,11 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
     */
    if (png_ptr->filter_costs == NULL)
    {
-      png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
-         sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST);
+      png_ptr->filter_costs = (png_uint_16p) png_malloc(png_ptr,
+         (png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
 
-      png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
-         sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST);
+      png_ptr->inv_filter_costs = (png_uint_16p) png_malloc(png_ptr,
+         (png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
 
       for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
       {
@@ -893,6 +971,8 @@ png_set_compression_window_bits(png_structp png_ptr, int window_bits)
 {
    if (window_bits > 15)
       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
+   else if (window_bits < 8)
+      png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
    png_ptr->zlib_window_bits = window_bits;
 }
@@ -907,3 +987,19 @@ png_set_compression_method(png_structp png_ptr, int method)
    png_ptr->zlib_method = method;
 }
 
+void
+png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
+{
+   png_ptr->write_row_fn = write_row_fn;
+}
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+void
+png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
+   write_user_transform_fn)
+{
+   png_debug(1, "in png_set_write_user_transform_fn\n");
+   png_ptr->transformations |= PNG_USER_TRANSFORM;
+   png_ptr->write_user_transform_fn = write_user_transform_fn;
+}
+#endif

pngwtran.c

@@ -1,42 +1,64 @@
 
 /* pngwtran.c - transforms the data in a row for PNG writers
  *
- * libpng 0.97
+ * libpng 1.0.4e - October 10, 1999
  * 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
- * January 7, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
  */
 
 #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
 png_do_write_transformations(png_structp png_ptr)
 {
    png_debug(1, "in png_do_write_transformations\n");
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+      if(png_ptr->write_user_transform_fn != NULL)
+        (*(png_ptr->write_user_transform_fn)) /* user write transform function */
+          (png_ptr,                    /* png_ptr */
+           &(png_ptr->row_info),       /* row_info:     */
+             /*  png_uint_32 width;          width of row */
+             /*  png_uint_32 rowbytes;       number of bytes in row */
+             /*  png_byte color_type;        color type of pixels */
+             /*  png_byte bit_depth;         bit depth of samples */
+             /*  png_byte channels;          number of channels (1-4) */
+             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
+           png_ptr->row_buf + 1);      /* start of pixel data for row */
+#endif
 #if defined(PNG_WRITE_FILLER_SUPPORTED)
    if (png_ptr->transformations & PNG_FILLER)
       png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
          png_ptr->flags);
 #endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
 #if defined(PNG_WRITE_PACK_SUPPORTED)
    if (png_ptr->transformations & PNG_PACK)
       png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
          (png_uint_32)png_ptr->bit_depth);
 #endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
 #if defined(PNG_WRITE_SHIFT_SUPPORTED)
    if (png_ptr->transformations & PNG_SHIFT)
       png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
          &(png_ptr->shift));
 #endif
-#if defined(PNG_WRITE_SWAP_SUPPORTED)
-   if (png_ptr->transformations & PNG_SWAP_BYTES)
-      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_ALPHA)
+      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
 #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
    if (png_ptr->transformations & PNG_SWAP_ALPHA)
@@ -74,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;
@@ -103,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;
 
@@ -134,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;
 
@@ -191,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;
@@ -219,12 +244,13 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
          channels++;
       }
 
-      /* with low row dephts, could only be grayscale, so one channel */
+      /* 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;
@@ -233,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;
@@ -251,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);
             }
          }
       }
@@ -279,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);
          }
       }
    }
@@ -322,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++);
@@ -338,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++);
@@ -362,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;
             }
@@ -376,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++);
@@ -394,3 +416,82 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
 }
 #endif
 
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void
+png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_write_invert_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+   if (row != NULL && row_info != NULL)
+#endif
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This inverts the alpha channel in RGBA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+         /* This inverts the alpha channel in RRGGBBAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This inverts the alpha channel in GA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+         /* This inverts the alpha channel in GGAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+      }
+   }
+}
+#endif

scripts/SCOPTIONS.ppc

@@ -0,0 +1,7 @@
+OPTIMIZE
+OPTPEEP
+OPTTIME
+OPTSCHED
+AUTOREGISTER
+PARMS=REGISTERS
+INCLUDEDIR=hlp:ppc/include

scripts/makefile.acorn

@@ -0,0 +1,51 @@
+# Project:   libpng
+
+
+# Toolflags:
+CCflags = -c -depend !Depend -IC:,Zlib: -g -throwback  -DRISCOS  -fnah 
+C++flags = -c -depend !Depend -IC: -throwback
+Linkflags = -aif -c++ -o $@
+ObjAsmflags = -throwback -NoCache -depend !Depend
+CMHGflags = 
+LibFileflags = -c -l -o $@ 
+Squeezeflags = -o $@
+
+
+# Final targets:
+@.libpng-lib:   @.o.png @.o.pngerror @.o.pngrio @.o.pngwio @.o.pngmem \
+	@.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngrtran \
+	@.o.pngrutil @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil 
+	LibFile $(LibFileflags) @.o.png @.o.pngerror @.o.pngrio @.o.pngrtran \
+	@.o.pngmem @.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngwio \
+	@.o.pngrutil @.o.pngtrans  @.o.pngwrite @.o.pngwtran @.o.pngwutil 
+@.mm-libpng-lib:   @.mm.png @.mm.pngerror @.mm.pngrio @.mm.pngwio @.mm.pngmem \
+	@.mm.pngpread @.mm.pngset @.mm.pngget @.mm.pngread @.mm.pngrtran \
+	@.mm.pngrutil @.mm.pngtrans @.mm.pngwrite @.mm.pngwtran @.mm.pngwutil 
+	LibFile $(LibFileflags) @.mm.png @.mm.pngerror @.mm.pngrio \
+	@.mm.pngwio @.mm.pngmem @.mm.pngpread @.mm.pngset @.mm.pngget \
+	@.mm.pngread @.mm.pngrtran @.mm.pngrutil @.mm.pngtrans @.mm.pngwrite \
+	@.mm.pngwtran @.mm.pngwutil 
+
+
+# User-editable dependencies:
+# (C) Copyright 1997 Tom Tanner
+Test: @.pngtest 
+	<Prefix$Dir>.pngtest
+	@remove <Prefix$Dir>.pngtest
+
+#It would be nice if you could stop "make" listing from here on!
+@.pngtest:   @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
+	Link $(Linkflags) @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
+
+.SUFFIXES: .o .mm .c
+
+.c.mm:
+	MemCheck.CC cc $(ccflags) -o $@ LibPng:$<
+.c.o:
+	cc $(ccflags) -o $@ $<
+
+
+# Static dependencies:
+
+
+# Dynamic dependencies:

scripts/makefile.amiga

@@ -8,7 +8,7 @@ CC=sc
 # WARNING: a bug in V6.51 causes bad code with OPTGO
 #          So use V6.55 or set NOOPTGO!!!!!!!!!
 CFLAGS= NOSTKCHK PARMS=REG OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL\
-        OPTLOOP OPTRDEP=4 OPTDEP=4 OPTCOMP=4 DEFINE=PNG_INTERNAL
+	OPTLOOP OPTRDEP=4 OPTDEP=4 OPTCOMP=4 DEFINE=PNG_INTERNAL
 #linker flags
 LDFLAGS= SD ND BATCH
 #link libs

scripts/makefile.atari

@@ -9,6 +9,7 @@ LBR = png.lib
 LDFLAGS=-lpng -lz -lm
 
 # where make install puts libpng.a and png.h
+prefix=/usr/local
 
 OBJS = $(LBR)(png.o) $(LBR)(pngset.o) $(LBR)(pngget.o) $(LBR)(pngrutil.o)\
 	$(LBR)(pngtrans.o) $(LBR)(pngwutil.o)\
@@ -28,4 +29,5 @@ install: libpng.a
 	-@mkdir $(prefix)/lib
 	cp png.h $(prefix)/include
 	cp pngconf.h $(prefix)/include
-	chmod 644 $(prefix)/include/p
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h

scripts/makefile.beos

@@ -0,0 +1,104 @@
+# makefile for libpng on BeOS x86 ELF with gcc
+# modified from makefile.linux by Sander Stoks
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1999 Greg Roelofs
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=gcc
+
+# Where the zlib library and include files are located
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+ALIGN=
+# For i386:
+# ALIGN=-malign-loops=2 -malign-functions=2
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+
+# On BeOS, -O1 is actually better than -O3.  This is a known bug but it's
+# still here in R4.5
+CFLAGS=-I$(ZLIBINC) -Wall -O1 -funroll-loops \
+	$(ALIGN) # $(WARNMORE) -g -DPNG_DEBUG=5
+# LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm
+LDFLAGS=-L. -Wl,-soname=libpng.so.$(PNGMAJ) -L$(ZLIBLIB) -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.4e
+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)
+
+.SUFFIXES:      .c .o
+
+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
+	cp libpng.so* /boot/home/config/lib
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(CC) -L$(ZLIBLIB) -lz -nostart -Wl,-soname,libpng.so.$(PNGMAJ) -o
+libpng.so.$(PNGVER) \
+	 $(OBJSDLL)
+
+pngtest: pngtest.o libpng.so
+	$(CC) -L$(ZLIBLIB) -lz -lpng -o pngtest pngtest.o
+
+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.borland

@@ -2,8 +2,8 @@
 # Borland C++ 4.5 (Note: All modules are compiled in C mode)
 # Will work with C++ 4.02 also
 # To build the library, do: 
-#       "make -fmakefile.bor -DMODEL=m"
-# or:   "make -fmakefile.bor -DMODEL=l"
+#       "make -fmakefile.borland -DMODEL=m"
+# or:   "make -fmakefile.borland -DMODEL=l"
 #
 # ------------- Borland C++ 4.5 -------------
 
@@ -70,38 +70,38 @@ O=obj
 
 ## variables
 OBJS = \
- png.$(O) \
- pngerror.$(O) \
- pngmem.$(O) \
- pngpread.$(O) \
- pngset.$(O) \
- pngget.$(O) \
- pngread.$(O) \
- pngrio.$(O) \
- pngrtran.$(O) \
- pngrutil.$(O) \
- pngtrans.$(O) \
- pngwrite.$(O) \
- pngwtran.$(O) \
- pngwio.$(O) \
- pngwutil.$(O)
+	png.$(O) \
+	pngerror.$(O) \
+	pngmem.$(O) \
+	pngpread.$(O) \
+	pngset.$(O) \
+	pngget.$(O) \
+	pngread.$(O) \
+	pngrio.$(O) \
+	pngrtran.$(O) \
+	pngrutil.$(O) \
+	pngtrans.$(O) \
+	pngwrite.$(O) \
+	pngwtran.$(O) \
+	pngwio.$(O) \
+	pngwutil.$(O)
 
 LIBOBJS = \
- +png.$(O) \
- +pngerror.$(O) \
- +pngmem.$(O) \
- +pngpread.$(O) \
- +pngread.$(O) \
- +pngset.$(O) \
- +pngget.$(O) \
- +pngrio.$(O) \
- +pngrtran.$(O) \
- +pngrutil.$(O) \
- +pngtrans.$(O) \
- +pngwrite.$(O) \
- +pngwtran.$(O) \
- +pngwio.$(O)
- +pngwutil.$(O)
+	+png.$(O) \
+	+pngerror.$(O) \
+	+pngmem.$(O) \
+	+pngpread.$(O) \
+	+pngread.$(O) \
+	+pngset.$(O) \
+	+pngget.$(O) \
+	+pngrio.$(O) \
+	+pngrtran.$(O) \
+	+pngrutil.$(O) \
+	+pngtrans.$(O) \
+	+pngwrite.$(O) \
+	+pngwtran.$(O) \
+	+pngwio.$(O) \
+	+pngwutil.$(O)
 
 LIBNAME=libpng$(MODEL).lib
 
@@ -121,7 +121,7 @@ libpng: $(LIBNAME)
 
 pngtest: pngtest$(MODEL).exe
 
-test:
+test: pngtest$(MODEL).exe
 	pngtest$(MODEL)
 
 
@@ -146,7 +146,7 @@ pngwutil.obj: pngwutil.c
 
 $(LIBNAME): $(OBJS)
 	-del $(LIBNAME)
-        $(LIB) $(LIBNAME) @&&|
+	$(LIB) $(LIBNAME) @&&|
 $(LIBOBJS), libpng$(MODEL)
 |
 

scripts/makefile.dec

@@ -0,0 +1,89 @@
+# makefile for libpng on DEC Alpha Unix
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
+PNGMAJ = 2
+PNGMIN = 1.0.4e
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+CC=cc
+CFLAGS=-std -w1 -I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+#RANLIB=echo
+RANLIB=ranlib
+
+
+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
+
+all: libpng.so libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+libpng.so: libpng.so.$(PNGMAJ)
+	ln -f -s libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -f -s libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJS)
+	$(CC) -shared -o $@ $(OBJS) -L$(ZLIBLIB) -lz -lm
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a libpng.so.$(PNGVER)
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	cp libpng.so.$(PNGVER) $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+	chmod 644 $(prefix)/lib/libpng.so.$(PNGVER)
+	-@/bin/rm -f $(LIBPATH)/libpng.so.$(PNGMAJ) $(LIBPATH)/libpng.so
+	(cd $(LIBPATH); ln -f -s libpng.so.$(PNGVER) libpng.so.$(PNGMAJ); \
+	 ln -f -s libpng.so.$(PNGMAJ) libpng.so)
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png libpng.so*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+

scripts/makefile.dj2

@@ -2,16 +2,16 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
+# where make install puts libpng.a and png.h
+#prefix=/usr/local
+prefix=.
+
 CC=gcc
 CFLAGS=-I../zlib -O
 LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
 
 RANLIB=ranlib
 
-# where make install puts libpng.a and png.h
-#prefix=/usr/local
-prefix=.
-
 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
@@ -23,7 +23,7 @@ libpng.a: $(OBJS)
 	$(RANLIB) $@
 
 pngtest: pngtest.o libpng.a
-	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
 	coff2exe pngtest
 
 test: pngtest

scripts/makefile.hpux

@@ -0,0 +1,67 @@
+# makefile for libpng, HPUX (10.20 and 11.00)
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42
+# Copyright (C) 1999 Glenn Randers-Pehrson
+# contributed by Jim Rice, Hewlett Packard
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Where the zlib library and include files are located
+ZLIBLIB=/opt/zlib/lib
+ZLIBINC=/opt/zlib/include
+
+CC=cc
+CFLAGS=-I$(ZLIBINC) -O -Ae +DA1.1 +DS2.0
+CCFLAGS=-I$(ZLIBINC) -O -Ae +DA1.1 +DS2.0
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+RANLIB=ranlib
+
+# where make install puts libpng.a and png.h
+prefix=/opt/libpng
+
+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
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h

scripts/makefile.knr

@@ -2,6 +2,14 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
+# This makefile requires file file ansi2knr.c, which you can get
+# from the Ghostscript ftp site at ftp://ftp.cs.wisc.edu/ghost/
+# If you have libjpeg, you probably already have ansi2knr.c in the jpeg
+# source distribution.
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
 CC=cc
 CFLAGS=-I../zlib -O
 LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
@@ -11,9 +19,6 @@ ANSI2KNRFLAGS=
 RANLIB=ranlib
 #RANLIB=echo
 
-# where make install puts libpng.a and png.h
-prefix=/usr/local
-
 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
@@ -34,8 +39,8 @@ libpng.a: ansi2knr $(OBJS)
 	ar rc $@  $(OBJS)
 	$(RANLIB) $@
 
-pngtest: pngtest.o libpng.a ansi2knr
-	cc -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
 
 test: pngtest
 	./pngtest

scripts/makefile.linux

@@ -1,38 +1,48 @@
 # makefile for libpng on Linux ELF with gcc
 # Copyright (C) 1996, 1997 Andreas Dilger
-# Copyright (C) 1998 Glenn Randers-Pehrson
+# Copyright (C) 1998, 1999 Greg Roelofs
 # For conditions of distribution and use, see copyright notice in png.h
 
 CC=gcc
 
+# where "make install" puts libpng.a, libpng.so*, png.h and pngconf.h
+prefix=/usr/local
+
 # Where the zlib library and include files are located
 #ZLIBLIB=/usr/local/lib
 #ZLIBINC=/usr/local/include
 ZLIBLIB=../zlib
 ZLIBINC=../zlib
 
+ALIGN=
+# for i386:
+#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
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+
+# for pgcc version 2.95.1, -O3 is buggy; don't us it.
+
+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
 #RANLIB=echo
 
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
 PNGMAJ = 2
-PNGMIN = 0.97
+PNGMIN = 1.0.4e
 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
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
 
 OBJSDLL = $(OBJS:.o=.pic.o)
 
@@ -54,8 +64,8 @@ libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
 	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
 
 libpng.so.$(PNGVER): $(OBJSDLL)
-	gcc -shared -Wl,-soname,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) \
-	 $(OBJSDLL)
+	$(CC) -shared -Wl,-soname,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) \
+	 $(OBJSDLL) -L$(ZLIBLIB) -lz -lm -lc
 
 pngtest: pngtest.o libpng.so
 	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)

scripts/makefile.mips

@@ -2,6 +2,9 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
 CC=cc
 CFLAGS=-I../zlib -O -systype sysv -DSYSV -w -Dmips
 #CFLAGS=-O
@@ -10,9 +13,6 @@ LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
 #RANLIB=ranlib
 RANLIB=echo
 
-# where make install puts libpng.a and png.h
-prefix=/usr/local
-
 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
@@ -24,7 +24,7 @@ libpng.a: $(OBJS)
 	$(RANLIB) $@
 
 pngtest: pngtest.o libpng.a
-	cc -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
 
 test: pngtest
 	./pngtest

scripts/makefile.msc

@@ -3,9 +3,9 @@
 # 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
 
-# ------------- Microsoft C 5.1 and later -------------
+# -------- Microsoft C 5.1 and later, does not use assembler code -----
 MODEL=-AL
-CFLAGS=-Oait -Gs -nologo -W2 $(MODEL) -I..\zlib
+CFLAGS=-Oait -Gs -nologo -W3 $(MODEL) -I..\zlib
 #-Ox generates bad code with MSC 5.1
 CC=cl
 LD=link
@@ -26,52 +26,52 @@ png$(O): png.h pngconf.h
 		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngset$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngget$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngread$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(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)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngrutil$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngerror$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngmem$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngrio$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngwio$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngtest$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngtrans$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngwrite$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngwtran$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 pngwutil$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
 
 libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
-        del libpng.lib
+	del libpng.lib
 	lib libpng $(OBJS1);
 	lib libpng $(OBJS2);
 	lib libpng $(OBJS3);

scripts/makefile.os2

@@ -0,0 +1,69 @@
+# makefile for libpng on OS/2 with gcc
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Related files: pngos2.def
+
+CC=gcc -Zomf -s
+
+# Where the zlib library and include files are located
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CFLAGS=-I$(ZLIBINC) -Wall -O6 -funroll-loops -malign-loops=2 \
+	-malign-functions=2 #$(WARNMORE) -g -DPNG_DEBUG=5
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lzdll -Zcrtdll
+AR=emxomfar
+
+PNGLIB=png.lib
+IMPLIB=emximp
+SHAREDLIB=png.dll
+SHAREDLIBIMP=pngdll.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
+
+.SUFFIXES:      .c .o
+
+all: $(PNGLIB) $(SHAREDLIB) $(SHAREDLIBIMP)
+
+$(PNGLIB): $(OBJS)
+	$(AR) rc $@ $(OBJS)
+
+$(SHAREDLIB): $(OBJS) pngos2.def
+	$(CC) $(LDFLAGS) -Zdll -o $@ $^
+
+$(SHAREDLIBIMP): pngos2.def
+	$(IMPLIB) -o $@ $^
+
+pngtest.exe: pngtest.o png.dll pngdll.lib
+	$(CC) -o $@ $(CFLAGS) $< $(LDFLAGS)
+
+test: pngtest.exe
+	./pngtest.exe
+
+clean:
+	rm -f *.o $(PNGLIB) png.dll pngdll.lib pngtest.exe 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.sco

@@ -0,0 +1,98 @@
+# 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 make install puts libpng.a, libpng.so*, and png.h
+prefix=/usr/local
+
+# 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.4e
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+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 -f -s libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -f -s 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 -f -s libpng.so.$(PNGVER) libpng.so.$(PNGMAJ); \
+	 ln -f -s 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

@@ -1,7 +1,10 @@
-# makefile for libpng on DEC Alpha Unix
+# makefile for libpng
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
 # Where the zlib library and include files are located
 #ZLIBLIB=/usr/local/lib
 #ZLIBINC=/usr/local/include
@@ -9,14 +12,14 @@ ZLIBLIB=../zlib
 ZLIBINC=../zlib
 
 CC=cc
-CFLAGS=-std -w1 -I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+
+WARNMORE=-fullwarn
+# You can add the -n32 option; then zlib must also be compiled with -n32
+CFLAGS=-I$(ZLIBINC) -O $(WARNMORE) # -g -DPNG_DEBUG=5
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 
-#RANLIB=echo
-RANLIB=ranlib
-
-# where make install puts libpng.a and png.h
-prefix=/usr/local
+RANLIB=echo
+#RANLIB=ranlib
 
 OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
 	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
@@ -29,7 +32,7 @@ libpng.a: $(OBJS)
 	$(RANLIB) $@
 
 pngtest: pngtest.o libpng.a
-	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
 
 test: pngtest
 	./pngtest

scripts/makefile.solaris

@@ -0,0 +1,109 @@
+# makefile for libpng on Solaris 2.x with gcc
+# Contributed by William L. Sebok, based on makefile.linux
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1998 Greg Roelofs
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=gcc
+
+# The commands "CC" and "LD" must NOT refer to /usr/ucb/cc and /usr/ucb/ld.
+# If they do, you need to adjust your PATH environment variable.
+# The environment variable LD_LIBRARY_PATH should not be set at all.  If
+# it is, things are likely to break.
+
+# Where make install puts libpng.a, libpng.so*, and png.h
+prefix=/usr/local
+
+# 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
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(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.4e
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+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) -fPIC -o $@ $*.c
+
+all: libpng.a libpng.so pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.so: libpng.so.$(PNGMAJ)
+	ln -f -s libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -f -s libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(LD) -G -L$(ZLIBLIB) -R$(ZLIBLIB) -h libpng.so.$(PNGMAJ) \
+	 -o libpng.so.$(PNGVER) $(OBJSDLL) -lz
+
+pngtest: pngtest.o libpng.so
+	$(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 -f -s libpng.so.$(PNGVER) libpng.so.$(PNGMAJ); \
+	 ln -f -s 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.std

@@ -2,6 +2,9 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
 # Where the zlib library and include files are located
 #ZLIBLIB=/usr/local/lib
 #ZLIBINC=/usr/local/include
@@ -9,15 +12,12 @@ 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
 RANLIB=ranlib
 
-# where make install puts libpng.a and png.h
-prefix=/usr/local
-
 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
@@ -29,7 +29,7 @@ libpng.a: $(OBJS)
 	$(RANLIB) $@
 
 pngtest: pngtest.o libpng.a
-	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
 
 test: pngtest
 	./pngtest

scripts/makefile.sunos

@@ -2,6 +2,9 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
 # Where the zlib library and include files are located
 #ZLIBLIB=/usr/local/lib
 #ZLIBINC=/usr/local/include
@@ -10,18 +13,15 @@ ZLIBINC=../zlib
 
 
 WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow -Wconversion \
-         -Wmissing-declarations -Wtraditional -Wcast-align \
-         -Wstrict-prototypes -Wmissing-prototypes
+	-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
 #RANLIB=echo
 
-# where make install puts libpng.a and png.h
-prefix=/usr/local
-
 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
@@ -33,7 +33,7 @@ libpng.a: $(OBJS)
 	$(RANLIB) $@
 
 pngtest: pngtest.o libpng.a
-	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
 
 test: pngtest
 	./pngtest

scripts/makefile.turboc3

@@ -1,7 +1,7 @@
 # Makefile for libpng
 # TurboC++ 3.0 (Note: All modules are compiled in C mode)
 
-# To use, do "make -fmakefile.tc"
+# To use, do "make -fmakefile.turboc3"
 
 # ------------- Turbo C++ 3.0 -------------
 MODEL=-ml
@@ -9,8 +9,9 @@ CFLAGS=-O2 -Z $(MODEL) -I..\zlib
 CC=tcc
 LD=tcc
 LIB=tlib
-LDFLAGS=$(MODEL)
+LDFLAGS=$(MODEL) -L..\zlib
 O=.obj
+E=.exe
 
 # variables
 OBJS1 = png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O)
@@ -20,7 +21,7 @@ OBJSL1 = +png$(O) +pngset$(O) +pngget$(O) +pngrutil$(O) +pngtrans$(O)
 OBJSL2 = +pngwutil$(O) +pngmem$(O) +pngpread$(O) +pngread$(O) +pngerror$(O)
 OBJSL3 = +pngwrite$(O) +pngrtran$(O) +pngwtran$(O) +pngrio$(O) +pngwio$(O)
 
-all: libpng.lib
+all: libpng.lib pngtest.exe
 
 png$(O): png.h pngconf.h
 		  $(CC) -c $(CFLAGS) $*.c
@@ -44,35 +45,38 @@ pngrutil$(O): png.h pngconf.h
 		  $(CC) -c $(CFLAGS) $*.c
 
 pngerror$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngmem$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngrio$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngwio$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngtest$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngtrans$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngwrite$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngwtran$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 pngwutil$(O): png.h pngconf.h
-        $(CC) -c $(CFLAGS) $*.c
+	$(CC) -c $(CFLAGS) $*.c
 
 libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
-        $(LIB) libpng +$(OBJSL1)
-        $(LIB) libpng +$(OBJSL2)
-        $(LIB) libpng +$(OBJSL3)
+	$(LIB) libpng +$(OBJSL1)
+	$(LIB) libpng +$(OBJSL2)
+	$(LIB) libpng +$(OBJSL3)
+
+pngtest$(E): pngtest$(O) libpng.lib
+	$(CC) $(LDFLAGS) pngtest.obj libpng.lib zlib.lib
 
 # End of makefile for libpng

scripts/makefile.vcawin32

@@ -0,0 +1,94 @@
+# 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.vcawin32"
+
+# ---------- Microsoft Visual C++ 5.0 and later, uses assembler code------
+
+# Caution: the assembler code was introduced at libpng version 1.0.4 and has
+# not yet been thoroughly tested.
+
+# If you don't want to use assembler code, use makefile.vcwin32 instead.
+
+MODEL=- 
+CFLAGS=-DPNG_USE_PNGVCRD -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) pngvcrd$(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 pngasmrd.h
+	$(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngvcrd$(O): png.h pngconf.h pngasmrd.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.vcwin32

@@ -0,0 +1,87 @@
+# 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.vcwin32"
+
+# ---------- Microsoft Visual C++ 4.0 and later, no assembler code------
+# If you want to use assembler code, use makefile.vcawin32 instead.
+
+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 pngasmrd.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.watcom

@@ -0,0 +1,88 @@
+# Makefile for libpng
+# Watcom 10.0 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
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+
+# To use, do "wmake /f scripts\makefile.watcom"
+
+# ------------- Watcom 10.0 and later -------------
+MODEL=-mf
+CFLAGS= $(MODEL) -5r -fp5 -fpi87 -oneatx -i=..\zlib
+CC=wcc386
+LD=wcl386
+LIB=wlib -b -c
+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: test
+
+png$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngset$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngget$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtest$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+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)
+
+pngtest.exe: pngtest.obj libpng.lib
+	$(LD) $(LDFLAGS) pngtest.obj libpng.lib ..\zlib\zlib.lib
+
+test: pngtest.exe .symbolic
+	pngtest
+
+# End of makefile for libpng

scripts/makevms.com

@@ -35,45 +35,45 @@ $ if f$search("SYS$SYSTEM:MMS.EXE").eqs.""
 $  then
 $   dele pngtest.obj;*
 $   CALL MAKE png.OBJ "cc ''CCOPT' png" -
-                png.c png.h pngconf.h   
+	png.c png.h pngconf.h   
 $   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
 					 pngpread.c png.h pngconf.h
 $   CALL MAKE pngset.OBJ "cc ''CCOPT' pngset" -
-                pngset.c png.h pngconf.h
+	pngset.c png.h pngconf.h
 $   CALL MAKE pngget.OBJ "cc ''CCOPT' pngget" -
-                pngget.c png.h pngconf.h
+	pngget.c png.h pngconf.h
 $   CALL MAKE pngread.OBJ "cc ''CCOPT' pngread" -
-                pngread.c png.h pngconf.h
+	pngread.c png.h pngconf.h
 $   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
 					 pngpread.c png.h pngconf.h
 $   CALL MAKE pngrtran.OBJ "cc ''CCOPT' pngrtran" -
-                pngrtran.c png.h pngconf.h
+	pngrtran.c png.h pngconf.h
 $   CALL MAKE pngrutil.OBJ "cc ''CCOPT' pngrutil" -
-                pngrutil.c png.h pngconf.h
+	pngrutil.c png.h pngconf.h
 $   CALL MAKE pngerror.OBJ "cc ''CCOPT' pngerror" -
-                pngerror.c png.h pngconf.h
+	pngerror.c png.h pngconf.h
 $   CALL MAKE pngmem.OBJ "cc ''CCOPT' pngmem" -
-                pngmem.c png.h pngconf.h
+	pngmem.c png.h pngconf.h
 $   CALL MAKE pngrio.OBJ "cc ''CCOPT' pngrio" -
-                pngrio.c png.h pngconf.h
+	pngrio.c png.h pngconf.h
 $   CALL MAKE pngwio.OBJ "cc ''CCOPT' pngwio" -
-                pngwio.c png.h pngconf.h
+	pngwio.c png.h pngconf.h
 $   CALL MAKE pngtrans.OBJ "cc ''CCOPT' pngtrans" -
-                pngtrans.c png.h pngconf.h
+	pngtrans.c png.h pngconf.h
 $   CALL MAKE pngwrite.OBJ "cc ''CCOPT' pngwrite" -
-                pngwrite.c png.h pngconf.h
+	pngwrite.c png.h pngconf.h
 $   CALL MAKE pngwtran.OBJ "cc ''CCOPT' pngwtran" -
-                pngwtran.c png.h pngconf.h
+	pngwtran.c png.h pngconf.h
 $   CALL MAKE pngwutil.OBJ "cc ''CCOPT' pngwutil" -
-                pngwutil.c png.h pngconf.h
+	pngwutil.c png.h pngconf.h
 $   write sys$output "Building Libpng ..."
 $   CALL MAKE libpng.OLB "lib/crea libpng.olb *.obj" *.OBJ
 $   write sys$output "Building pngtest..."
 $   CALL MAKE pngtest.OBJ "cc ''CCOPT' pngtest" -
-                pngtest.c png.h pngconf.h
+	pngtest.c png.h pngconf.h
 $   call make pngtest.exe - 
-                "LINK pngtest,libpng.olb/lib,''zlibsrc'libgz.olb/lib" - 
-                pngtest.obj libpng.olb
+	"LINK pngtest,libpng.olb/lib,''zlibsrc'libgz.olb/lib" - 
+	pngtest.obj libpng.olb
 $   write sys$output "Testing Libpng..."
 $   run pngtest
 $  else

scripts/pngdef.pas

@@ -0,0 +1,722 @@
+unit pngdef;
+
+interface
+
+const
+  PNG_LIBPNG_VER_STRING = '1.0.4e';
+  PNG_LIBPNG_VER        =  10005;
+
+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_get_copyright(png_ptr: png_structp): png_charp;
+             stdcall;
+function png_get_header_version(png_ptr: png_structp): png_charp;
+             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_rgb_to_gray_status(png_ptr: png_structp);
+             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_1_2_4_to_8(png_ptr: png_structp);
+             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_palette_to_rgb(png_ptr: png_structp);
+             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_rgb_to_gray(png_ptr: png_structp; int: error_action);
+             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_tRNS_to_alpha(png_ptr: png_structp);
+             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

@@ -0,0 +1,296 @@
+;----------------------------------------
+; PNGLIB module definition file for OS/2
+;----------------------------------------
+
+LIBRARY		PNG
+DESCRIPTION	"PNG image compression library for OS/2"
+CODE		PRELOAD MOVEABLE DISCARDABLE
+DATA		PRELOAD MOVEABLE MULTIPLE
+
+EXPORTS
+  png_set_sig_bytes
+  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
+  png_write_chunk_end
+  png_create_info_struct
+  png_info_init
+  png_write_info
+  png_read_info
+  png_convert_to_rfc1123
+  png_convert_from_struct_tm
+  png_convert_from_time_t
+  png_set_expand
+  png_set_bgr
+  png_set_gray_to_rgb
+  png_set_rgb_to_gray
+  png_build_grayscale_palette
+  png_set_strip_alpha
+  png_set_swap_alpha
+  png_set_invert_alpha
+  png_set_filler
+  png_set_swap
+  png_set_packing
+  png_set_packswap
+  png_set_shift
+  png_set_interlace_handling
+  png_set_invert_mono
+  png_set_background
+  png_set_strip_16
+  png_set_dither
+  png_set_gamma
+  png_set_flush
+  png_write_flush
+  png_start_read_image
+  png_read_update_info
+  png_read_rows
+  png_read_row
+  png_read_image
+  png_write_row
+  png_write_rows
+  png_write_image
+  png_write_end
+  png_read_end
+  png_destroy_info_struct
+  png_destroy_read_struct
+  png_read_destroy
+  png_destroy_write_struct
+; png_write_destroy_info
+  png_write_destroy
+  png_set_crc_action
+  png_set_filter
+  png_set_filter_heuristics
+  png_set_compression_level
+  png_set_compression_mem_level
+  png_set_compression_strategy
+  png_set_compression_window_bits
+  png_set_compression_method
+  png_init_io
+  png_get_copyright
+  png_set_error_fn
+  png_get_error_ptr
+  png_get_header_version
+; png_get_mem_fn
+; png_set_mem_fn
+  png_set_write_fn
+  png_set_read_fn
+  png_set_write_status_fn
+  png_set_read_status_fn
+  png_get_io_ptr
+  png_set_progressive_read_fn
+  png_set_read_status_fn
+  png_set_read_user_transform_fn
+  png_set_write_status_fn
+  png_set_write_user_transform_fn
+  png_get_progressive_ptr
+  png_process_data
+  png_progressive_combine_row
+  png_malloc
+  png_free
+  png_memcpy_check
+  png_memset_check
+; png_malloc_default
+; png_free_default
+; png_far_to_near
+  png_error
+  png_chunk_error
+  png_warning
+  png_chunk_warning
+  png_get_valid
+  png_get_rowbytes
+  png_get_channels
+  png_get_image_width
+  png_get_image_height
+  png_get_bit_depth
+  png_get_color_type
+  png_get_filter_type
+  png_get_interlace_type
+  png_get_compression_type
+  png_get_pixels_per_meter
+  png_get_pixel_aspect_ratio
+  png_get_rgb_to_gray_status
+  png_get_x_offset_pixels
+  png_get_y_offset_pixels
+  png_get_x_offset_microns
+  png_get_y_offset_microns
+  png_get_signature
+  png_get_bKGD
+  png_set_bKGD
+  png_get_cHRM
+  png_set_cHRM
+  png_get_gAMA
+  png_set_gAMA
+  png_get_hIST
+  png_set_hIST
+  png_get_IHDR
+  png_set_IHDR
+  png_get_oFFs
+  png_set_oFFs
+  png_get_pCAL
+  png_set_pCAL
+  png_get_pHYs
+  png_set_pHYs
+  png_get_PLTE
+  png_set_PLTE
+  png_get_sBIT
+  png_set_sBIT
+  png_get_sRGB
+  png_set_sRGB
+  png_set_sRGB_gAMA_and_cHRM
+  png_get_text
+  png_set_text
+  png_get_tIME
+  png_set_tIME
+  png_get_tRNS
+  png_set_tRNS
+  png_set_gray_1_2_4_to_8
+  png_set_tRNS_to_alpha
+  png_set_palette_to_rgb
+
+  png_create_struct
+  png_destroy_struct
+  png_info_destroy
+  png_zalloc
+  png_zfree
+  png_reset_crc
+  png_write_data
+  png_read_data
+  png_crc_read
+  png_crc_finish
+  png_crc_error
+  png_calculate_crc
+  png_flush
+  png_save_uint_32
+  png_save_int_32
+  png_save_uint_16
+  png_write_sig
+  png_write_IHDR
+  png_write_PLTE
+  png_write_IDAT
+  png_write_IEND
+  png_write_gAMA
+  png_write_sBIT
+  png_write_cHRM
+  png_write_sRGB
+  png_write_tRNS
+  png_write_bKGD
+  png_write_hIST
+  png_check_keyword
+  png_write_tEXt
+  png_write_zTXt
+  png_write_oFFs
+  png_write_pCAL
+  png_write_pHYs
+  png_write_tIME
+  png_write_finish_row
+  png_write_start_row
+  png_build_gamma_table
+  png_combine_row
+  png_do_read_interlace
+  png_do_write_interlace
+  png_read_filter_row
+  png_write_find_filter
+  png_write_filtered_row
+  png_read_finish_row
+  png_read_start_row
+  png_read_transform_info
+  png_do_read_filler
+  png_do_read_swap_alpha
+  png_do_write_swap_alpha
+  png_do_read_invert_alpha
+  png_do_write_invert_alpha
+  png_do_strip_filler
+  png_do_swap
+  png_do_packswap
+  png_do_rgb_to_gray
+  png_do_gray_to_rgb
+  png_do_unpack
+  png_do_unshift
+  png_do_invert
+  png_do_chop
+  png_do_dither
+; png_correct_palette
+  png_do_bgr
+  png_do_pack
+  png_do_shift
+  png_do_background
+  png_do_gamma
+  png_do_expand_palette
+  png_do_expand
+  png_handle_IHDR
+  png_handle_PLTE
+  png_handle_IEND
+  png_handle_gAMA
+  png_handle_sBIT
+  png_handle_cHRM
+  png_handle_sRGB
+  png_handle_tRNS
+  png_handle_bKGD
+  png_handle_hIST
+  png_handle_oFFs
+  png_handle_pCAL
+  png_handle_pHYs
+  png_handle_tIME
+  png_handle_tEXt
+  png_handle_zTXt
+  png_handle_unknown
+  png_check_chunk_name
+  png_do_read_transformations
+  png_do_write_transformations
+  png_init_read_transformations
+  png_push_read_chunk
+  png_push_read_sig
+; png_push_check_crc
+  png_push_crc_skip
+  png_push_crc_finish
+  png_push_fill_buffer
+  png_push_save_buffer
+  png_push_restore_buffer
+  png_push_read_IDAT
+  png_process_IDAT_data
+  png_push_process_row
+  png_push_handle_unknown
+  png_push_have_info
+  png_push_have_end
+  png_push_have_row
+; png_push_read_end
+  png_process_some_data
+  png_read_push_finish_row
+  png_push_handle_tEXt
+  png_push_read_tEXt
+  png_push_handle_zTXt
+  png_push_read_zTXt
+
+  png_libpng_ver
+  png_pass_start
+  png_pass_inc
+  png_pass_ystart
+  png_pass_yinc
+  png_pass_mask
+  png_pass_dsp_mask
+; png_pass_width
+; png_pass_height
+
+  png_IHDR
+  png_IDAT
+  png_IEND
+  png_PLTE
+  png_bKGD
+  png_cHRM
+  png_gAMA
+  png_hIST
+  png_oFFs
+  png_pCAL
+  png_pHYs
+  png_sBIT
+  png_sRGB
+  png_tEXt
+  png_tIME
+  png_tRNS
+  png_zTXt

scripts/smakefile.ppc

@@ -0,0 +1,29 @@
+# Amiga powerUP (TM) Makefile
+# makefile for libpng and SAS C V6.58/7.00 PPC compiler
+# Copyright (C) 1998 by Andreas R. Kleinert
+
+CC       = scppc
+CFLAGS   = NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL IDIR /zlib \
+           OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8
+LIBNAME  = libpng.a
+AR       = ppc-amigaos-ar
+AR_FLAGS = cr
+RANLIB   = ppc-amigaos-ranlib
+LDFLAGS  = -r -o
+LDLIBS   =  ../zlib/libzip.a LIB:scppc.a
+LN       = ppc-amigaos-ld
+RM       = delete quiet
+MKDIR    = makedir
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o pngread.o \
+pngerror.o pngpread.o pngwrite.o pngrtran.o pngwtran.o pngrio.o pngwio.o pngmem.o
+
+all: $(LIBNAME) pngtest
+
+$(LIBNAME): $(OBJS)
+            $(AR) $(AR_FLAGS) $@ $(OBJS)
+            $(RANLIB) $@
+
+pngtest: pngtest.o $(LIBNAME)
+        $(LN) $(LDFLAGS) pngtest LIB:c_ppc.o pngtest.o $(LIBNAME) $(LDLIBS) \
+LIB:end.o