Imported from libpng-0.99m.tar

Imported from libpng-0.99k.tar
Imported from libpng-0.99j.tar
2025-07-10 18:04:09 +02:00 · 2009-04-06 16:04:17 -05:00 · 2009-04-06 16:04:17 -05:00 · 2009-04-06 16:04:16 -05:00 · 2009-04-06 16:04:16 -05:00 · 2009-04-06 16:04:15 -05:00
51 changed files with 8332 additions and 1873 deletions
--- a/103
+++ b/103
@@ -1,4 +1,4 @@
-pngchange.txt - changes for libpng
+CHANGES - changes for libpng

 version 0.2
   added reader into png.h
@@ -167,3 +167,104 @@ version 0.96 [May, 1997]
   added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)
   added typecasts to quiet compiler errors
   added more debugging info
+version 0.97 [January, 1998]
+   removed PNG_USE_OWN_CRC capability
+   relocated png_set_crc_action from pngrutil.c to pngrtran.c
+   fixed typecasts of "new_key", etc. (Andreas Dilger)
+   added RFC 1152 [sic] date support
+   fixed bug in gamma handling of 4-bit grayscale
+   added 2-bit grayscale gamma handling (Glenn R-P)
+   added more typecasts. 65536L becomes (png_uint_32)65536L, etc. (Glenn R-P)
+   minor corrections in libpng.txt
+   added simple sRGB support (Glenn R-P)
+   easier conditional compiling, e.g. define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;
+      all configurable options can be selected from command-line instead
+      of having to edit pngconf.h (Glenn R-P)
+   fixed memory leak in pngwrite.c (free info_ptr->text) (Glenn R-P)
+   added more conditions for png_do_background, to avoid changing
+      black pixels to background when a background is supplied and
+      no pixels are transparent
+   repaired PNG_NO_STDIO behaviour
+   tested NODIV support and made it default behaviour (Greg Roelofs)
+   added "-m" option and PNGTEST_DEBUG_MEMORY to pngtest (John Bowler)
+   regularized version numbering scheme and bumped shared-library major
+      version number to 2 to avoid problems with libpng 0.89 apps (Greg Roelofs)
+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
--- a/85
+++ b/85
@@ -0,0 +1,85 @@
+
+Installing libpng version 1.00 March 7, 1998
+
+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.00 or "lpng100" and "zlib-1.1.1"
+or "zlib111") 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
+      makefile.dec  =>  DEC Alpha UNIX makefile
+      makefile.sgi  =>  Silicon Graphics IRIX makefile
+      makefile.sun  =>  Sun makefile
+      makefile.s2x  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.00)
+      makefile.lnx  =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.00)
+      makefile.mip  =>  MIPS makefile
+      makefile.aco  =>  Acorn makefile
+      makefile.ama  =>  Amiga makefile
+      makefile.atr  =>  Atari makefile
+      makefile.bor  =>  Borland makefile
+      build.bat     =>  MS-DOS batch file for Borland compiler
+      makefile.dj2  =>  DJGPP 2 makefile
+      makefile.msc  =>  Microsoft C makefile
+      makefile.tc3  =>  Turbo C 3.0 makefile
+      makefile.os2  =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+      pngos2.def    =>  OS/2 module definition file used by makefile.os2
+      makefile.wat  =>  Watcom 10a+ Makefile, 32-bit flat memory model
+      makevms.com   =>  VMS build script
+
+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.
--- a/94
+++ b/94
@@ -1,16 +1,21 @@
-README for libpng 0.96
+README for libpng 1.00 (shared library 2.1)
+See the note about version numbers near the top of png.h

-This is the sixth (and hopefully last) beta release of libpng 1.0.
-The changes from libpng-0.90 include bug fixes, a C++ wrapper for
-png.h, some additions to the API, as well as internal changes to
-the library.  See "CHANGES" for a detailed list of differences.
+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 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.

 ****
 Note that some of the changes to the png_info structure render this
 version of the library binary incompatible with libpng-0.89 or
 earlier versions if you are using a shared library.  The type of the
 "filler" parameter for png_set_filler() has changed from png_byte to
-png_uint_32, which will affect shared-library applications which use
+png_uint_32, which will affect shared-library applications that use
 this function.

 To avoid problems with changes to the internals of png_info_struct,
@@ -19,6 +24,12 @@ access to info_ptr.  These functions are the png_set_<chunk> and
 png_get_<chunk> functions.  These functions should be used when
 accessing/storing the info_struct data, rather than manipulating it
 directly, to avoid such problems in the future.
+
+It is important to note that the APIs do not make current programs
+that access the info struct directly incompatible with the new
+library.  However, it is strongly suggested that new programs use
+the new APIs (as shown in example.c), and older programs be converted
+to the new format, to facilitate upgrades in the future.
 ****

 Additions since 0.90 include the ability to compile libpng as a
@@ -65,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
@@ -85,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
+randeg@alumni.rpi.edu
 png-implement@dworkin.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@dworkin.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,
@@ -105,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.
@@ -115,28 +126,20 @@ Files in this distribution:
      CHANGES       =>  Description of changes between libpng versions
      README        =>  This file
      TODO          =>  Things not implemented in the current library
+      ansi2knr.1    =>  Manual page for ansi2knr
      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
@@ -151,16 +154,39 @@ 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
+        makefile.dec  =>  DEC Alpha UNIX makefile
+        makefile.sgi  =>  Silicon Graphics IRIX makefile
+        makefile.sun  =>  Sun makefile
+        makefile.s2x  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.00)
+        makefile.lnx  =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.00)
+        makefile.mip  =>  MIPS makefile
+        makefile.aco  =>  Acorn makefile
+        makefile.ama  =>  Amiga makefile
+        makefile.atr  =>  Atari makefile
+        makefile.bor  =>  Borland makefile
+        build.bat     =>  MS-DOS batch file for Borland compiler
+        makefile.dj2  =>  DJGPP 2 makefile
+        makefile.msc  =>  Microsoft C makefile
+        makefile.tc3  =>  Turbo C 3.0 makefile
+        makefile.os2  =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+        makefile.wat  =>  Watcom 10a+ Makefile, 32-bit flat memory model
+        pngos2.def    =>  OS/2 module definition file used by makefile.os2
+        makevms.com   =>  VMS build script

 Good luck, and happy coding.

+-Glenn Randers-Pehrson
+ Internet: randeg@alumni.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
--- a/6
+++ b/6
@@ -1,10 +1,12 @@
-pngtodo.txt - list of things to do for libpng
+TODO - list of things to do for libpng

+fix problem with C++ and EXTERN "C"
 add "grayscale->palette" transformation and "palette->grayscale" detection
 improved dithering
 multi-lingual error and warning message support
+sPLT chunk handling
 cHRM transformation
-sRGB chunk handling
+complete sRGB transformation (presently it simply uses gamma=0.45)
 man pages for function calls
 high-level API for reading images
 final bug fixes
--- a/ansi2knr.1
+++ b/ansi2knr.1
@@ -0,0 +1,36 @@
+.TH ANSI2KNR 1 "19 Jan 1996"
+.SH NAME
+ansi2knr \- convert ANSI C to Kernighan & Ritchie C
+.SH SYNOPSIS
+.I ansi2knr
+[--varargs] input_file [output_file]
+.SH DESCRIPTION
+If no output_file is supplied, output goes to stdout.
+.br
+There are no error messages.
+.sp
+.I ansi2knr
+recognizes function definitions 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, and with a left brace as the first token on the
+following line (ignoring possible intervening comments).  It will recognize a
+multi-line header provided that no intervening line ends with a left or right
+brace or a semicolon.  These algorithms ignore whitespace and comments, except
+that the function name must be the first thing on the line.
+.sp
+The following constructs will confuse it:
+.br
+     - Any other construct that starts at the left margin and follows the
+above syntax (such as a macro or function call).
+.br
+     - Some macros that tinker with the syntax of the function header.
+.sp
+The --varargs switch is obsolete, and is recognized only for
+backwards compatibility.  The present version of
+.I ansi2knr
+will always attempt to convert a ... argument to va_alist and va_dcl.
+.SH AUTHOR
+L. Peter Deutsch <ghost@aladdin.com> wrote the original ansi2knr and
+continues to maintain the current version; most of the code in the current
+version is his work.  ansi2knr also includes contributions by Francois
+Pinard <pinard@iro.umontreal.ca> and Jim Avera <jima@netcom.com>.
--- a/ansi2knr.c
+++ b/ansi2knr.c
@@ -1,26 +1,32 @@
-/* Copyright (C) 1989, 1991, 1993 Aladdin Enterprises. All rights reserved. */
-
 /* ansi2knr.c */
-/* Convert ANSI function declarations to K&R syntax */
+/* Convert ANSI C function definitions to K&R ("traditional C") 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.
+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 (the "GPL") 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.
+Everyone is granted permission to copy, modify and redistribute ansi2knr,
+but only under the conditions described in the GPL.  A copy of this license
+is supposed to have been given to you along with ansi2knr so you can know
+your rights and responsibilities.  It should be in a file named COPYLEFT.
+[In the IJG distribution, the GPL appears below, not in a separate file.]
+Among other things, the copyright notice and this notice must be preserved
+on all copies.
+
+We explicitly state here what we believe is already implied by the GPL: if
+the ansi2knr program is distributed as a separate set of sources and a
+separate executable file which are aggregated on a storage medium together
+with another program, this in itself does not bring the other program under
+the GPL, nor does the mere fact that such a program or the procedures for
+constructing it invoke the ansi2knr executable bring any other part of the
+program under the GPL.
 */

 /*
---------- Here is the GNU GPL file COPYING, referred to above ----------
+---------- Here is the GNU GPL file COPYLEFT, referred to above ----------
 ----- These terms do NOT apply to the JPEG software itself; see README ------

 		    GHOSTSCRIPT GENERAL PUBLIC LICENSE
@@ -166,59 +172,142 @@ 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 ------------------------------
+-------------------- End of file COPYLEFT ------------------------------
 */

-
-#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:
+/*
+ * 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.
+ * ansi2knr recognizes function definitions 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,
+ * and with a left brace as the first token on the following line
+ * (ignoring possible intervening comments).
+ * It will recognize a multi-line header provided that no intervening
+ * line ends with a left or right 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.
+ *	- Some macros that tinker with the syntax of the function header.
 */

+/*
+ * The original and principal author of ansi2knr is L. Peter Deutsch
+ * <ghost@aladdin.com>.  Other authors are noted in the change history
+ * that follows (in reverse chronological order):
+	lpd 96-01-21 added code to cope with not HAVE_CONFIG_H and with
+		compilers that don't understand void, as suggested by
+		Tom Lane
+	lpd 96-01-15 changed to require that the first non-comment token
+		on the line following a function header be a left brace,
+		to reduce sensitivity to macros, as suggested by Tom Lane
+		<tgl@sss.pgh.pa.us>
+	lpd 95-06-22 removed #ifndefs whose sole purpose was to define
+		undefined preprocessor symbols as 0; changed all #ifdefs
+		for configuration symbols to #ifs
+	lpd 95-04-05 changed copyright notice to make it clear that
+		including ansi2knr in a program does not bring the entire
+		program under the GPL
+	lpd 94-12-18 added conditionals for systems where ctype macros
+		don't handle 8-bit characters properly, suggested by
+		Francois Pinard <pinard@iro.umontreal.ca>;
+		removed --varargs switch (this is now the default)
+	lpd 94-10-10 removed CONFIG_BROKETS conditional
+	lpd 94-07-16 added some conditionals to help GNU `configure',
+		suggested by Francois Pinard <pinard@iro.umontreal.ca>;
+		properly erase prototype args in function parameters,
+		contributed by Jim Avera <jima@netcom.com>;
+		correct error in writeblanks (it shouldn't erase EOLs)
+	lpd 89-xx-xx original version
+ */
+
+/* Most of the conditionals here are to make ansi2knr work with */
+/* or without the GNU configure machinery. */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+
+#if HAVE_CONFIG_H
+
+/*
+   For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
+   This will define HAVE_CONFIG_H and so, activate the following lines.
+ */
+
+# if STDC_HEADERS || HAVE_STRING_H
+#  include <string.h>
+# else
+#  include <strings.h>
+# endif
+
+#else /* not HAVE_CONFIG_H */
+
+/* Otherwise do it the hard way */
+
+# ifdef BSD
+#  include <strings.h>
+# else
+#  ifdef VMS
+    extern int strlen(), strncmp();
+#  else
+#   include <string.h>
+#  endif
+# endif
+
+#endif /* not HAVE_CONFIG_H */
+
+#if STDC_HEADERS
+# include <stdlib.h>
+#else
+/*
+   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
+
+#endif
+
+/*
+ * The ctype macros don't always handle 8-bit characters correctly.
+ * Compensate for this here.
+ */
+#ifdef isascii
+#  undef HAVE_ISASCII		/* just in case */
+#  define HAVE_ISASCII 1
+#else
+#endif
+#if STDC_HEADERS || !HAVE_ISASCII
+#  define is_ascii(c) 1
+#else
+#  define is_ascii(c) isascii(c)
+#endif
+
+#define is_space(c) (is_ascii(c) && isspace(c))
+#define is_alpha(c) (is_ascii(c) && isalpha(c))
+#define is_alnum(c) (is_ascii(c) && isalnum(c))
+
 /* Scanning macros */
-#define isidchar(ch) (isalnum(ch) || (ch) == '_')
-#define isidfirstchar(ch) (isalpha(ch) || (ch) == '_')
+#define isidchar(ch) (is_alnum(ch) || (ch) == '_')
+#define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_')

 /* Forward references */
 char *skipspace();
@@ -227,6 +316,7 @@ int test1();
 int convert1();

 /* The main program */
+int
 main(argc, argv)
    int argc;
    char *argv[];
@@ -234,46 +324,99 @@ main(argc, argv)
 #define bufsize 5000			/* arbitrary size */
 	char *buf;
 	char *line;
+	char *more;
+	/*
+	 * In previous versions, ansi2knr recognized a --varargs switch.
+	 * If this switch was supplied, ansi2knr would attempt to convert
+	 * a ... argument to va_alist and va_dcl; if this switch was not
+	 * supplied, ansi2knr would simply drop any such arguments.
+	 * Now, ansi2knr always does this conversion, and we only
+	 * check for this switch for backward compatibility.
+	 */
+	int convert_varargs = 1;
+
+	if ( argc > 1 && argv[1][0] == '-' )
+	  {	if ( !strcmp(argv[1], "--varargs") )
+		  {	convert_varargs = 1;
+			argc--;
+			argv++;
+		  }
+		else
+		  {	fprintf(stderr, "Unrecognized switch: %s\n", argv[1]);
+			exit(1);
+		  }
+	  }
 	switch ( argc )
 	   {
 	default:
 		printf("Usage: ansi2knr input_file [output_file]\n");
 		exit(0);
 	case 2:
-		out = stdout; break;
+		out = stdout;
+		break;
 	case 3:
 		out = fopen(argv[2], "w");
 		if ( out == NULL )
-		   {	fprintf(stderr, "Cannot open %s\n", argv[2]);
+		   {	fprintf(stderr, "Cannot open output file %s\n", argv[2]);
 			exit(1);
 		   }
 	   }
 	in = fopen(argv[1], "r");
 	if ( in == NULL )
-	   {	fprintf(stderr, "Cannot open %s\n", argv[1]);
+	   {	fprintf(stderr, "Cannot open input file %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) )
+	   {
+test:		line += strlen(line);
+		switch ( test1(buf) )
 		   {
+		case 2:			/* a function header */
+			convert1(buf, out, 1, convert_varargs);
+			break;
 		case 1:			/* a function */
-			convert1(buf, out);
+			/* Check for a { at the start of the next line. */
+			more = ++line;
+f:			if ( line >= buf + (bufsize - 1) ) /* overflow check */
+			  goto wl;
+			if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL )
+			  goto wl;
+			switch ( *skipspace(more, 1) )
+			  {
+			  case '{':
+			    /* Definitely a function header. */
+			    convert1(buf, out, 0, convert_varargs);
+			    fputs(more, out);
+			    break;
+			  case 0:
+			    /* The next line was blank or a comment: */
+			    /* keep scanning for a non-comment. */
+			    line += strlen(line);
+			    goto f;
+			  default:
+			    /* buf isn't a function header, but */
+			    /* more might be. */
+			    fputs(buf, out);
+			    strcpy(buf, more);
+			    line = buf;
+			    goto test;
+			  }
 			break;
 		case -1:		/* maybe the start of a function */
-			line = buf + strlen(buf);
 			if ( line != buf + (bufsize - 1) ) /* overflow check */
-				continue;
+			  continue;
 			/* falls through */
 		default:		/* not a function */
-			fputs(buf, out);
+wl:			fputs(buf, out);
 			break;
 		   }
 		line = buf;
 	   }
-	if ( line != buf ) fputs(buf, out);
+	if ( line != buf )
+	  fputs(buf, out);
 	free(buf);
 	fclose(out);
 	fclose(in);
@@ -286,11 +429,14 @@ 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;
+	   {	while ( is_space(*p) )
+		  p += dir;
+		if ( !(*p == '/' && p[dir] == '*') )
+		  break;
 		p += dir;  p += dir;
 		while ( !(*p == '*' && p[dir] == '/') )
-		   {	if ( *p == 0 ) return p;	/* multi-line comment?? */
+		   {	if ( *p == 0 )
+			  return p;	/* multi-line comment?? */
 			p += dir;
 		   }
 		p += dir;  p += dir;
@@ -300,13 +446,16 @@ skipspace(p, dir)

 /*
 * Write blanks over part of a string.
+ * Don't overwrite end-of-line characters.
 */
 int
 writeblanks(start, end)
    char *start;
    char *end;
 {	char *p;
-	for ( p = start; p < end; p++ ) *p = ' ';
+	for ( p = start; p < end; p++ )
+	  if ( *p != '\r' && *p != '\n' )
+	    *p = ' ';
 	return 0;
 }

@@ -316,8 +465,12 @@ writeblanks(start, end)
 * Return as follows:
 *	0 - definitely not a function definition;
 *	1 - definitely a function definition;
+ *	2 - definitely a function prototype (NOT USED);
 *	-1 - may be the beginning of a function definition,
 *		append another line and look again.
+ * The reason we don't attempt to convert function prototypes is that
+ * Ghostscript's declaration-generating macros look too much like
+ * prototypes, and confuse the algorithms.
 */
 int
 test1(buf)
@@ -326,24 +479,27 @@ test1(buf)
 	char *bend;
 	char *endfn;
 	int contin;
+
 	if ( !isidfirstchar(*p) )
-		return 0;		/* no name at left margin */
+	  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;
+	   case ';': contin = 0 /*2*/; break;
+	   case ')': contin = 1; break;
+	   case '{': return 0;		/* not a function */
+	   case '}': return 0;		/* not a function */
+	   default: contin = -1;
 	   }
-	while ( isidchar(*p) ) p++;
+	while ( isidchar(*p) )
+	  p++;
 	endfn = p;
 	p = skipspace(p, 1);
 	if ( *p++ != '(' )
-		return 0;		/* not a function */
+	  return 0;		/* not a function */
 	p = skipspace(p, 1);
 	if ( *p == ')' )
-		return 0;		/* no parameters */
+	  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). */
@@ -357,19 +513,23 @@ test1(buf)
 		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 */
+			  return 0;	/* name is a keyword */
 			key++;
 		   }
 	   }
 	return contin;
 }

+/* Convert a recognized function definition or header to K&R syntax. */
 int
-convert1(buf, out)
+convert1(buf, out, header, convert_varargs)
    char *buf;
    FILE *out;
+    int header;			/* Boolean */
+    int convert_varargs;	/* Boolean */
 {	char *endfn;
 	register char *p;
 	char **breaks;
@@ -377,9 +537,12 @@ convert1(buf, out)
 	char **btop;
 	char **bp;
 	char **ap;
+	char *vararg = 0;
+
 	/* Pre-ANSI implementations don't agree on whether strchr */
 	/* is called strchr or index, so we open-code it here. */
-	for ( endfn = buf; *(endfn++) != '('; ) ;
+	for ( endfn = buf; *(endfn++) != '('; )
+	  ;
 top:	p = endfn;
 	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
 	if ( breaks == 0 )
@@ -393,7 +556,10 @@ top:	p = endfn;
 	/* Parse the argument list */
 	do
 	   {	int level = 0;
+		char *lp = NULL;
+		char *rp;
 		char *end = NULL;
+
 		if ( bp >= btop )
 		   {	/* Filled up break table. */
 			/* Allocate a bigger one and start over. */
@@ -406,13 +572,27 @@ top:	p = endfn;
 		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: ;
+			   case ',':
+				if ( !level ) end = p;
+				break;
+			   case '(':
+				if ( !level ) lp = p;
+				level++;
+				break;
+			   case ')':
+				if ( --level < 0 ) end = p;
+				else rp = p;
+				break;
+			   case '/':
+				p = skipspace(p, 1) - 1;
+				break;
+			   default:
+				;
 			   }
 		   }
+		/* Erase any embedded prototype parameters. */
+		if ( lp )
+		  writeblanks(lp + 1, rp);
 		p--;			/* back up over terminator */
 		/* Find the name being declared. */
 		/* This is complicated because of procedure and */
@@ -421,35 +601,42 @@ top:	p = endfn;
 		   {	p = skipspace(p - 1, -1);
 			switch ( *p )
 			   {
-			case ']':	/* skip array dimension(s) */
-			case ')':	/* skip procedure args OR name */
+			   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: ;
+				   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;
+					  p = skipspace(p, 1) + 1;
 					goto found;
 				   }
 				break;
-			default: goto found;
+			   default:
+				goto found;
 			   }
 		   }
 found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
-		   {	p++;
-			if ( bp == breaks + 1 )	/* sole argument */
-				writeblanks(breaks[0], p);
+		  {	if ( convert_varargs )
+			  {	*bp++ = "va_alist";
+				vararg = p-2;
+			  }
 			else
-				writeblanks(bp[-1] - 1, p);
-			bp--;
+			  {	p++;
+				if ( bp == breaks + 1 )	/* sole argument */
+				  writeblanks(breaks[0], p);
+				else
+				  writeblanks(bp[-1] - 1, p);
+				bp--;
+			  }
 		   }
 		else
 		   {	while ( isidchar(*p) ) p--;
@@ -470,19 +657,37 @@ found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
 			   }
 		   }
 	   }
-	/* Put out the function name */
+	/* Put out the function name and left parenthesis. */
 	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);
+	/* Put out the declaration. */
+	if ( header )
+	  {	fputs(");", out);
+		for ( p = breaks[0]; *p; p++ )
+		  if ( *p == '\r' || *p == '\n' )
+		    putc(*p, out);
+	  }
+	else
+	  {	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] = ';';
+		if ( vararg != 0 )
+		  {	*vararg = 0;
+			fputs(breaks[0], out);		/* any prior args */
+			fputs("va_dcl", out);		/* the final arg */
+			fputs(bp[0], out);
+		  }
+		else
+		  fputs(breaks[0], out);
+	  }
 	free((char *)breaks);
 	return 0;
 }
--- a/example.c
+++ b/example.c
@@ -1,36 +1,37 @@
+
 /* example.c - an example of using libpng */

 /* This is an example of how to use libpng to read and write PNG files.
-   The file libpng.txt is much more verbose then this.  If you have not
-   read it, do so first.  This was designed to be a starting point of an
-   implementation.  This is not officially part of libpng, and therefore
-   does not require a copyright notice.
+ * The file libpng.txt is much more verbose then this.  If you have not
+ * read it, do so first.  This was designed to be a starting point of an
+ * implementation.  This is not officially part of libpng, and therefore
+ * does not require a copyright notice.
+ *
+ * This file does not currently compile, because it is missing certain
+ * parts, like allocating memory to hold an image.  You will have to
+ * supply these parts to get it to compile.  For an example of a minimal
+ * working PNG reader/writer, see pngtest.c, included in this distribution.
+ */

-   This file does not currently compile, because it is missing certain
-   parts, like allocating memory to hold an image.  You will have to
-   supply these parts to get it to compile.  For an example of a minimal
-   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.
-
-   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
-   you have created the png_ptr, so that libpng knows your application
-   has read that many bytes from the start of the file.  Make sure you
-   don't call png_set_sig_bytes() with more than 8 bytes read or give it
-   an incorrect number of bytes read, or you will either have read too
-   many bytes (your fault), or you are telling libpng to read the wrong
-   number of magic bytes (also your fault).
-
-   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
-   you have a PNG file, and call png_set_sig_bytes().
-*/
+ * non-zero if the image is a PNG, and 0 if it isn't a PNG.
+ *
+ * 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
+ * you have created the png_ptr, so that libpng knows your application
+ * has read that many bytes from the start of the file.  Make sure you
+ * don't call png_set_sig_bytes() with more than 8 bytes read or give it
+ * an incorrect number of bytes read, or you will either have read too
+ * many bytes (your fault), or you are telling libpng to read the wrong
+ * number of magic bytes (also your fault).
+ *
+ * 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
+ * you have a PNG file, and call png_set_sig_bytes().
+ */
 #define PNG_BYTES_TO_CHECK 4
 int check_if_png(char *file_name, FILE **fp)
 {
@@ -49,11 +50,12 @@ int check_if_png(char *file_name, FILE **fp)
 }

 /* Read a PNG file.  You may want to return an error code if the read
-   fails (depending upon the failure).  There are two "prototypes" given
-   here - one where we are given the filename, and we need to open the
-   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 ****
+ * fails (depending upon the failure).  There are two "prototypes" given
+ * here - one where we are given the filename, and we need to open the
+ * file, and the other where we are given an open file (possibly with
+ * some or all of the magic bytes read - see comments above).
+ */
+#ifdef open_file /* prototype 1 */
 void read_png(char *file_name)  /* We need to open the file */
 {
   png_structp png_ptr;
@@ -65,14 +67,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,
@@ -112,16 +114,17 @@ 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_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);
@@ -143,29 +146,31 @@ 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
-    * background (not recommended) */
+   /* Strip alpha bytes from the input data without combining with th
+    * background (not recommended).
+    */
   png_set_strip_alpha(png_ptr);

-   /* extract multiple pixels with bit depths of 1, 2, and 4 from a single
+   /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
    * byte into separate bytes (useful for paletted and grayscale images).
    */
   png_set_packing(png_ptr);

-   /* change the order of packed pixels to least significant bit first
+   /* Change the order of packed pixels to least significant bit first
    * (not useful if you are using png_set_packing). */
   png_set_packswap(png_ptr);

-   /* expand paletted colors into true RGB triplets */
+   /* Expand paletted colors into true RGB triplets */
   if (color_type == PNG_COLOR_TYPE_PALETTE)
      png_set_expand(png_ptr);

-   /* expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
+   /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
   if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
      png_set_expand(png_ptr);

-   /* expand paletted or RGB images with transparency to full alpha channels
-    * so the data will be available as RGBA quartets */
+   /* Expand paletted or RGB images with transparency to full alpha channels
+    * so the data will be available as RGBA quartets.
+    */
   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
      png_set_expand(png_ptr);

@@ -176,29 +181,32 @@ 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 (display_gamma/viewing_gamma) */
   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 */
   }

@@ -207,20 +215,27 @@ 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_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);
+
+   int intent;
+
+   if (png_get_sRGB(png_ptr, info_ptr, &intent))
+      png_set_sRGB(png_ptr, intent, 0);
+   else 
+      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.50);

   /* Dither RGB files down to 8 bit palette or reduce palettes
-      to the number of colors available on your screen */
+    * to the number of colors available on your screen.
+    */
   if (color_type & PNG_COLOR_MASK_COLOR)
   {
      png_uint_32 num_palette;
      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];
@@ -229,7 +244,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;

@@ -241,7 +256,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
@@ -269,19 +284,19 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */

   /* Turn on interlace handling.  REQUIRED if you are not using
    * png_read_image().  To see how to handle interlacing passes,
-    * see the png_read_row() method below.
+    * see the png_read_row() method below:
    */
   number_passes = png_set_interlace_handling(png_ptr);

-   /* optional call to gamma correct and add the background to the palette
+   /* Optional call to gamma correct and add the background to the palette
    * and update info structure.  REQUIRED if you are expecting libpng to
    * update the palette for you (ie you selected such a transform above).
    */
   png_read_update_info(png_ptr, info_ptr);

-   /* allocate the memory to hold the image using the fields of info_ptr. */
+   /* Allocate the memory to hold the image using the fields of info_ptr. */

-   /* the easiest way to read the image */
+   /* The easiest way to read the image: */
   png_bytep row_pointers[height];

   for (row = 0; row < height; row++)
@@ -290,37 +305,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 ****
-   /* the other way to read images - deal with interlacing */
+#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);
      }

-[[[[[[[ 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. >>>>>>>>>>
+#ifdef sparkle /* 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 >>>>>>>>>>
+#else no_sparkle /* 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 >>>>>>>>>>
+#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);
@@ -465,7 +480,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;
@@ -512,16 +527,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
@@ -535,8 +550,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 */
@@ -552,7 +567,8 @@ void write_png(char *file_name, ... other image information ...)

  
   /* Optional gamma chunk is strongly suggested if you have any guess
-    * as to the correct gamma of the image. */
+    * as to the correct gamma of the image.
+    */
   png_set_gAMA(png_ptr, info_ptr, gamma);

   /* Optionally write comments into the image */
@@ -568,6 +584,8 @@ void write_png(char *file_name, ... other image information ...)
   png_set_text(png_ptr, info_ptr, text_ptr, 2);

   /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
+   /* note that if sRGB is present the cHRM chunk must be ignored
+    * on read and must be written in accordance with the sRGB profile */

   /* Write the file header information.  REQUIRED */
   png_write_info(png_ptr, info_ptr);
@@ -579,13 +597,15 @@ void write_png(char *file_name, ... other image information ...)
    */

   /* set up the transformations you want.  Note that these are
-    * all optional.  Only call them if you want them. */
+    * all optional.  Only call them if you want them.
+    */

   /* 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 */
+    * as appropriate to correctly scale the image.
+    */
   png_set_shift(png_ptr, &sig_bit);

   /* pack pixels into bytes */
@@ -595,7 +615,8 @@ void write_png(char *file_name, ... other image information ...)
   png_set_swap_alpha(png_ptr);

   /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
-    * RGB (4 channels -> 3 channels). The second parameter is not used. */
+    * RGB (4 channels -> 3 channels). The second parameter is not used.
+    */
   png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

   /* flip BGR pixels to RGB */
@@ -620,12 +641,12 @@ void write_png(char *file_name, ... other image information ...)
   png_byte row_pointers[height][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.
    */
@@ -641,7 +662,7 @@ void write_png(char *file_name, ... other image information ...)
         png_write_rows(png_ptr, &row_pointers, 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.
--- a/libpng.3
+++ b/libpng.3
--- a/libpng.txt
+++ b/libpng.txt
--- a/libpngpf.3
+++ b/libpngpf.3
@@ -0,0 +1,342 @@
+.TH LIBPNGPF 3 "March 7, 1998"
+.SH NAME
+libpng \- Portable Network Graphics (PNG) Reference Library
+(private functions)
+.SH SYNOPSIS
+#include <png.h>
+
+void png_build_gamma_table (png_structp png_ptr);
+
+void png_build_grayscale_palette (int bit_depth, png_colorp
+palette);
+
+void png_calculate_crc (png_structp png_ptr, png_bytep ptr,
+png_size_t length);
+void png_check_chunk_name (png_structp png_ptr, png_bytep
+chunk_name);
+
+png_size_t png_check_keyword (png_structp png_ptr, png_charp
+key, png_charpp new_key);
+
+void png_combine_row (png_structp png_ptr, png_bytep row, int
+mask);
+
+void png_correct_palette (png_structp png_ptr, png_colorp
+palette, int num_palette);
+
+int png_crc_error (png_structp png_ptr);
+
+int png_crc_finish (png_structp png_ptr, png_uint_32 skip);
+
+void png_crc_read (png_structp png_ptr, png_bytep buf,
+png_size_t length);
+
+png_voidp png_create_struct (int type);
+
+void png_destroy_struct (png_voidp struct_ptr);
+
+void png_do_background (png_row_infop row_info, png_bytep row,
+png_color_16p trans_values, png_color_16p background,
+png_color_16p background_1, png_bytep gamma_table, png_bytep
+gamma_from_1, png_bytep gamma_to_1, png_uint_16pp gamma_16,
+png_uint_16pp gamma_16_from_1, png_uint_16pp gamma_16_to_1, int
+gamma_shift);
+
+void png_do_bgr (png_row_infop row_info, png_bytep row);
+
+void png_do_chop (png_row_infop row_info, png_bytep row);
+
+void png_do_dither (png_row_infop row_info, png_bytep row,
+png_bytep palette_lookup, png_bytep dither_lookup);
+
+void png_do_expand (png_row_infop row_info, png_bytep row,
+png_color_16p trans_value);
+
+void png_do_expand_palette (png_row_infop row_info, png_bytep
+row, png_colorp palette, png_bytep trans, int num_trans);
+
+void png_do_gamma (png_row_infop row_info, png_bytep row,
+png_bytep gamma_table, png_uint_16pp gamma_16_table, int
+gamma_shift);
+
+void png_do_gray_to_rgb (png_row_infop row_info, png_bytep
+row);
+
+void png_do_invert (png_row_infop row_info, png_bytep row);
+
+void png_do_pack (png_row_infop row_info, png_bytep row,
+png_uint_32 bit_depth);
+
+void png_do_packswap (png_row_infop row_info, png_bytep row);
+
+void png_do_read_filler (png_row_infop row_info, png_bytep row,
+png_uint_32 filler, png_uint_32 flags);
+
+void png_do_read_interlace (png_row_infop row_info, png_bytep
+row, int pass, png_uint_32 transformations);
+
+void png_do_read_invert_alpha (png_row_infop row_info,
+png_bytep row);
+
+void png_do_read_swap_alpha (png_row_infop row_info, png_bytep
+row);
+
+void png_do_read_transformations (png_structp png_ptr);
+
+void png_do_rgb_to_gray (png_row_infop row_info, png_bytep
+row);
+
+void png_do_shift (png_row_infop row_info, png_bytep row,
+png_color_8p bit_depth);
+
+void png_do_strip_filler (png_row_infop row_info, png_bytep
+row, png_uint_32 flags);
+
+void png_do_swap (png_row_infop row_info, png_bytep row);
+
+void png_do_unpack (png_row_infop row_info, png_bytep row);
+
+void png_do_unshift (png_row_infop row_info, png_bytep row,
+png_color_8p sig_bits);
+
+void png_do_write_interlace (png_row_infop row_info, png_bytep
+row, int pass);
+
+void png_do_write_invert_alpha (png_row_infop row_info,
+png_bytep row);
+
+void png_do_write_swap_alpha (png_row_infop row_info, png_bytep
+row);
+
+void png_do_write_transformations (png_structp png_ptr);
+
+void *png_far_to_near (png_structp png_ptr,png_voidp ptr,
+int check);
+
+void png_flush (png_structp png_ptr);
+
+png_int_32 png_get_int_32 (png_bytep buf);
+
+png_uint_16 png_get_uint_16 (png_bytep buf);
+
+png_uint_32 png_get_uint_32 (png_bytep buf);
+
+void png_handle_bKGD (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_cHRM (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_gAMA (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_hIST (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_IEND (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_IHDR (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_oFFs (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_pCAL (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_pHYs (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_PLTE (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_sBIT (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_sRGB (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_tEXt (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_tIME (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_tRNS (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_unknown (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_handle_zTXt (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_info_destroy (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_init_read_transformations (png_structp png_ptr);
+
+void png_process_IDAT_data (png_structp png_ptr, png_bytep
+buffer, png_size_t buffer_length);
+
+void png_process_some_data (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_check_crc (png_structp png_ptr);
+
+void png_push_crc_finish (png_structp png_ptr);
+
+void png_push_crc_skip (png_structp png_ptr, png_uint_32
+length);
+
+void png_push_fill_buffer (png_structp png_ptr, png_bytep
+buffer, png_size_t length);
+
+void png_push_handle_tEXt (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_push_handle_unknown (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_push_handle_zTXt (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_push_have_end (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_have_info (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_have_row (png_structp png_ptr, png_bytep row);
+
+void png_push_process_row (png_structp png_ptr);
+
+void png_push_read_chunk (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_end (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_IDAT (png_structp png_ptr);
+
+void png_push_read_sig (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_tEXt (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_zTXt (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_restore_buffer (png_structp png_ptr, png_bytep
+buffer, png_size_t buffer_length);
+
+void png_push_save_buffer (png_structp png_ptr);
+
+void png_read_data (png_structp png_ptr, png_bytep data,
+png_size_t length);
+
+void png_read_filter_row (png_structp png_ptr, png_row_infop
+row_info, png_bytep row, png_bytep prev_row, int filter);
+
+void png_read_finish_row (png_structp png_ptr);
+
+void png_read_init (png_structp png_ptr);
+
+void png_read_push_finish_row (png_structp png_ptr);
+
+void png_read_start_row (png_structp png_ptr);
+
+void png_read_transform_info (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_reset_crc (png_structp png_ptr);
+
+void png_save_int_32 (png_bytep buf, png_int_32 i);
+
+void png_save_uint_16 (png_bytep buf, unsigned int i);
+
+void png_save_uint_32 (png_bytep buf, png_uint_32 i);
+
+void png_write_bKGD (png_structp png_ptr, png_color_16p values,
+int color_type);
+
+void png_write_cHRM (png_structp png_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);
+
+void png_write_data (png_structp png_ptr, png_bytep data,
+png_size_t length);
+void png_write_filtered_row (png_structp png_ptr, png_bytep
+filtered_row);
+
+void png_write_find_filter (png_structp png_ptr, png_row_infop
+row_info);
+
+void png_write_finish_row (png_structp png_ptr);
+
+void png_write_gAMA (png_structp png_ptr, double file_gamma);
+
+void png_write_hIST (png_structp png_ptr, png_uint_16p hist,
+int num_hist);
+
+void png_write_init (png_structp png_ptr);
+
+void png_write_IDAT (png_structp png_ptr, png_bytep data,
+png_size_t length);
+
+void png_write_IEND (png_structp png_ptr);
+
+void png_write_IHDR (png_structp png_ptr, png_uint_32 width,
+png_uint_32 height, int bit_depth, int color_type, int
+compression_type, int filter_type, int interlace_type);
+
+void png_write_oFFs (png_structp png_ptr, png_uint_32 x_offset,
+png_uint_32 y_offset, int unit_type);
+
+void png_write_pCAL (png_structp png_ptr, png_charp purpose,
+png_int_32 X0, png_int_32 X1, int type, int nparams, png_charp
+units, png_charpp params);
+
+void png_write_pHYs (png_structp png_ptr, png_uint_32
+x_pixels_per_unit, png_uint_32 y_pixels_per_unit, int
+unit_type);
+
+void png_write_PLTE (png_structp png_ptr, png_colorp palette,
+png_uint_32 num_pal);
+
+void png_write_sBIT (png_structp png_ptr, png_color_8p sbit,
+int color_type);
+
+void png_write_sig (png_structp png_ptr);
+
+void png_write_sRGB (png_structp png_ptr, int intent);
+
+void png_write_start_row (png_structp png_ptr);
+
+void png_write_tEXt (png_structp png_ptr, png_charp key,
+png_charp text, png_size_t text_len);
+
+void png_write_tIME (png_structp png_ptr, png_timep mod_time);
+
+void png_write_tRNS (png_structp png_ptr, png_bytep trans,
+png_color_16p values, int number, int color_type);
+
+void png_write_zTXt (png_structp png_ptr, png_charp key,
+png_charp text, png_size_t text_len, int compression);
+
+voidpf png_zalloc (voidpf png_ptr, uInt items, uInt size);
+
+void png_zfree (voidpf png_ptr, voidpf ptr);
+
+.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
--- a/png.5
+++ b/png.5
@@ -0,0 +1,44 @@
+.TH PNG 5 "March 7, 1998"
+.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 specification:
+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.0 (October 1, 1996):
+Thomas Boutell and others (png-list@dworkin.wustl.edu).
+.LP
+
+.SH COPYRIGHT NOTICE
+The PNG specification is copyright (c) 1996 Massachussets Institute of
+Technology.  See the specification for conditions of use and distribution.
+.LP
+.\" end of man page
+
--- a/png.c
+++ b/png.c
@@ -1,27 +1,30 @@

-/* png.c - location for general purpose png functions
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+/* png.c - location for general purpose libpng functions
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 #define PNG_INTERNAL
 #define PNG_NO_EXTERN
 #include "png.h"

 /* Version information for C files.  This had better match the version
-   string defined in png.h */
-char png_libpng_ver[] = "0.95";
+ * string defined in png.h.
+ */
+char png_libpng_ver[5] = "1.00";

-/* Place to hold the signiture string for a PNG file. */
+/* 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,
-   add a string holding the name here.  If you want to make the code
-   portable to EBCDIC machines, use ASCII numbers, not characters. */
+/* Constant strings for known chunk types.  If you need to add a chunk,
+ * add a string holding the name here.  If you want to make the code
+ * portable to EBCDIC machines, use ASCII numbers, not characters.
+ */
 png_byte FARDATA png_IHDR[5] = { 73,  72,  68,  82, '\0'};
 png_byte FARDATA png_IDAT[5] = { 73,  68,  65,  84, '\0'};
 png_byte FARDATA png_IEND[5] = { 73,  69,  78,  68, '\0'};
@@ -34,6 +37,7 @@ png_byte FARDATA png_oFFs[5] = {111,  70,  70, 115, '\0'};
 png_byte FARDATA png_pCAL[5] = {112,  67,  65,  76, '\0'};
 png_byte FARDATA png_pHYs[5] = {112,  72,  89, 115, '\0'};
 png_byte FARDATA png_sBIT[5] = {115,  66,  73,  84, '\0'};
+png_byte FARDATA png_sRGB[5] = {115,  82,  71,  66, '\0'};
 png_byte FARDATA png_tEXt[5] = {116,  69,  88, 116, '\0'};
 png_byte FARDATA png_tIME[5] = {116,  73,  77,  69, '\0'};
 png_byte FARDATA png_tRNS[5] = {116,  82,  78,  83, '\0'};
@@ -53,22 +57,20 @@ int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
 /* offset to next interlace block in the y direction */
 int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};

-/* width of interlace block */
-/* this is not currently used - if you need it, uncomment it here and
-   in png.h
+/* Width of interlace block.  This is not currently used - if you need
+ * it, uncomment it here and in png.h
 int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
 */

-/* height of interlace block */
-/* this is not currently used - if you need it, uncomment it here and
-   in png.h
+/* Height of interlace block.  This is not currently used - if you need
+ * it, uncomment it here and in png.h
 int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
 */

-/* mask to determine which pixels are valid in a pass */
+/* Mask to determine which pixels are valid in a pass */
 int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

-/* mask to determine which pixels to overwrite while displaying */
+/* Mask to determine which pixels to overwrite while displaying */
 int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};


@@ -101,24 +103,25 @@ 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 will be removed in the
+ * future - use png_sig_cmp().
+ */
 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. */
@@ -129,7 +132,7 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
   png_uint_32 num_bytes;

   num_bytes = (png_uint_32)items * size;
-   ptr = png_malloc((png_structp)png_ptr, num_bytes);
+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
   if (num_bytes > (png_uint_32)0x8000)
   {
      png_memset(ptr, 0, (png_size_t)0x8000L);
@@ -140,7 +143,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 */
@@ -151,78 +154,19 @@ png_zfree(voidpf png_ptr, voidpf ptr)
 }

 /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
-   in case CRC is > 32 bits to leave the top bits 0. */
+ * in case CRC is > 32 bits to leave the top bits 0.
+ */
 void
 png_reset_crc(png_structp png_ptr)
 {
-   /* set CRC to all 1's */
-#ifdef PNG_USE_OWN_CRC
-   png_ptr->crc = 0xffffffffL;
-#else
   png_ptr->crc = crc32(0, Z_NULL, 0);
-#endif
 }

-#ifdef PNG_USE_OWN_CRC
-/* Table of CRCs of all 8-bit messages.  By default, we use the tables made
-   by zlib, to save some memory.  If you wish to png_malloc() this
-   table, turn this into a pointer, and png_malloc() it in make_crc_table().
-   You may then want to hook it into png_struct and free it with the
-   destroy functions.  Another alternative is to pre-fill the table.  */
-static png_uint_32 crc_table[256];
-
-/* Flag: has the table been computed? Initially false. */
-static int crc_table_computed = 0;
-
-/* make the table for a fast crc */
-static void
-make_crc_table(void)
-{
-  png_uint_32 c;
-  int n, k;
-
-  for (n = 0; n < 256; n++)
-  {
-   c = (png_uint_32)n;
-   for (k = 0; k < 8; k++)
-     c = c & 1 ? 0xedb88320L ^ (c >> 1) : c >> 1;
-   crc_table[n] = c;
-  }
-  crc_table_computed = 1;
-}
-
-/* Update a running CRC with the bytes buf[0..len-1] - the CRC should be
-   initialized to all 1's, and the transmitted value is the 1's complement
-   of the final running CRC. */
-static png_uint_32
-update_crc(png_uint_32 crc, png_bytep buf, png_size_t len)
-{
-  png_uint_32 c;
-  png_bytep p;
-  png_uint_32 n;
-
-  c = crc;
-  p = buf;
-  n = len;
-
-  if (!crc_table_computed)
-  {
-   make_crc_table();
-  }
-
-  if (n > 0) do
-  {
-   c = crc_table[(png_byte)((c ^ (*p++)) & 0xff)] ^ (c >> 8);
-  } while (--n);
-
-  return c;
-}
-#endif /* PNG_USE_OWN_CRC */
-
 /* Calculate the CRC over a section of data.  We can only pass as
-   much data to this routine as the largest single buffer size.  We
-   also check that this data will actually be used before going to the
-   trouble of calculating it. */
+ * much data to this routine as the largest single buffer size.  We
+ * also check that this data will actually be used before going to the
+ * trouble of calculating it.
+ */
 void
 png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
 {
@@ -241,36 +185,35 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
   }

   if (need_crc)
-#ifdef PNG_USE_OWN_CRC
-      png_ptr->crc = update_crc(png_ptr->crc, ptr, length);
-#else
-      png_ptr->crc = crc32(png_ptr->crc, ptr, length);
-#endif
+      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
 }

 /* Allocate the memory for an info_struct for the application.  We don't
-   really need the png_ptr, but it could potentially be useful in the
-   future.  This should be used in favour of malloc(sizeof(png_info))
-   and png_info_init() so that applications that want to use a shared
-   libpng don't have to be recompiled if png_info changes size. */
+ * really need the png_ptr, but it could potentially be useful in the
+ * future.  This should be used in favour of malloc(sizeof(png_info))
+ * and png_info_init() so that applications that want to use a shared
+ * libpng don't have to be recompiled if png_info changes size.
+ */
 png_infop
 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);
   if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)
   {
      png_info_init(info_ptr);
   }

-   return info_ptr;
+   return (info_ptr);
 }

 /* This function frees the memory associated with a single info struct.
-   Normally, one would use either png_destroy_read_struct() or
-   png_destroy_write_struct() to free an info struct, but this may be
-   useful for some applications. */
+ * Normally, one would use either png_destroy_read_struct() or
+ * png_destroy_write_struct() to free an info struct, but this may be
+ * useful for some applications.
+ */
 void
 png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
 {
@@ -290,8 +233,9 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
 }

 /* Initialize the info structure.  This is now an internal function (0.89)
-   and applications using it are urged to use png_create_info_struct()
-   instead. */
+ * and applications using it are urged to use png_create_info_struct()
+ * instead.
+ */
 void
 png_info_init(png_infop info_ptr)
 {
@@ -325,7 +269,7 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
   png_free(png_ptr, info_ptr->pcal_units);
   if (info_ptr->pcal_params != NULL)
   {
-      for (i = 0; i < info_ptr->pcal_nparams; i++)
+      for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
      {
         png_free(png_ptr, info_ptr->pcal_params[i]);
      }
@@ -337,18 +281,20 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
 }

 /* This function returns a pointer to the io_ptr associated with the user
-   functions.  The application should free any memory associated with this
-   pointer before png_write_destroy() or png_read_destroy() are called. */
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy() or png_read_destroy() are called.
+ */
 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)
 /* Initialize the default input/output functions for the PNG file.  If you
-   use your own read or write routines, you can call either png_set_read_fn()
-   or png_set_write_fn() instead of png_init_io(). */
+ * use your own read or write routines, you can call either png_set_read_fn()
+ * or png_set_write_fn() instead of png_init_io().
+ */
 void
 png_init_io(png_structp png_ptr, FILE *fp)
 {
--- a/png.h
+++ b/png.h
@@ -1,67 +1,90 @@

 /* png.h - header file for PNG reference library
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-
-   BETA NOTICE:
-      This is a beta version.  It reads and writes valid files on the
-      platforms I have, and has had a wide testing program.  You may
-      have to modify the includes below to get it to work on your
-      system, and you may have to supply the correct compiler flags in
-      the makefile if you can't find a makefile suitable for your
-      operating system/compiler combination.  Read libpng.txt for more
-      information, including how to contact the authors if you have any
-      problems, or if you want your compiler/platform to be supported in
-      the next official libpng release.
-
-   See libpng.txt for more information.
-
-   Contributing Authors:
-      John Bowler
-      Sam Bushell
-      Kevin Bracey
-      Andreas Dilger
-      Magnus Holmgren
-      Dave Martindale
-      Greg Roelofs
-      Guy Eric Schalnat
-      Paul Schmidt
-      Tom Tanner
-      Tim Wegner
-
-   The contributing authors would like to thank all those who helped
-   with testing, bug fixes, and patience.  This wouldn't have been
-   possible without all of you.
-
-   Thanks to Frank J. T. Wojcik for helping with the documentation.
-
-   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.
-*/
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see the COPYRIGHT NOTICE below.
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998 Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * Note about libpng version numbers:
+ *
+ *    Due to various miscommunications, unforeseen code incompatibilities
+ *    and occasional factors outside the authors' control, version numbering
+ *    on the library has not always been consistent and straightforward.
+ *    The following table summarizes matters since version 0.89c, which was
+ *    the first widely used release:
+ *
+ *      source                    png.h     shared-lib
+ *      version                   string    version
+ *      -------                   ------    ----------
+ *      0.89c ("1.0 beta 3")      0.89      1.0.89
+ *      0.90  ("1.0 beta 4")      0.90      0.90  [should have been 2.0.90]
+ *      0.95  ("1.0 beta 5")      0.95      0.95  [should have been 2.0.95]
+ *      0.96  ("1.0 beta 6")      0.96      0.96  [should have been 2.0.96]
+ *      0.97b ("1.00.97 beta 7")  1.00.97   1.0.0 [should have been 2.0.97]
+ *      0.97c                     0.97      2.0.97
+ *      0.98                      0.98      2.0.98
+ *      0.99                      0.99      2.0.99
+ *      0.99a-i                   0.99      2.0.99
+ *      1.00                      1.00      2.1.0
+ *
+ *    Henceforth the source version will match the shared-library minor
+ *    and patch numbers; the shared-library major version number will be
+ *    used for changes in backward compatibility, as it is intended.
+ *
+ * See libpng.txt for more information.  The PNG specification is available
+ * as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/>
+ * and as a W3C Recommendation <http://www.w3.org/TR/REC.png.html>
+ *
+ * Contributing Authors:
+ *    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 contributing authors would like to thank all those who helped
+ * with testing, bug fixes, and patience.  This wouldn't have been
+ * possible without all of you.
+ *
+ * Thanks to Frank J. T. Wojcik for helping with the documentation.
+ *
+ * COPYRIGHT NOTICE:
+ *
+ * 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.
+ */

 #ifndef _PNG_H
 #define _PNG_H
@@ -89,30 +112,30 @@ extern "C" {
 */

 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "0.96"
+#define PNG_LIBPNG_VER_STRING "1.00"

 /* careful here.  At one time, I wanted to use 082, but that would be octal.
 * Version 1.0 will be 100 here, etc.
 */
-#define PNG_LIBPNG_VER 96
+#define PNG_LIBPNG_VER  100

 /* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
-#ifndef PNG_NO_EXTERN
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
 /* Version information for C files, stored in png.c.  This had better match
 * the version above.
 */
-extern char png_libpng_ver[];
+extern char png_libpng_ver[5];

 /* Structures to facilitate easy interlacing.  See png.c for more details */
-extern int FARDATA png_pass_start[];
-extern int FARDATA png_pass_inc[];
-extern int FARDATA png_pass_ystart[];
-extern int FARDATA png_pass_yinc[];
-extern int FARDATA png_pass_mask[];
-extern int FARDATA png_pass_dsp_mask[];
+extern int FARDATA png_pass_start[7];
+extern int FARDATA png_pass_inc[7];
+extern int FARDATA png_pass_ystart[7];
+extern int FARDATA png_pass_yinc[7];
+extern int FARDATA png_pass_mask[7];
+extern int FARDATA png_pass_dsp_mask[7];
 /* These aren't currently used.  If you need them, see png.c for more details
-extern int FARDATA png_pass_width[];
-extern int FARDATA png_pass_height[];
+extern int FARDATA png_pass_width[7];
+extern int FARDATA png_pass_height[7];
 */
 #endif /* PNG_NO_EXTERN */

@@ -172,10 +195,11 @@ typedef png_text FAR * FAR * png_textpp;
 #define PNG_TEXT_COMPRESSION_LAST     1  /* Not a valid value */

 /* png_time is a way to hold the time in an machine independent way.
-   Two conversions are provided, both from time_t and struct tm.  There
-   is no portable way to convert to either of these structures, as far
-   as I know.  If you know of a portable way, send it to me.  As a side
-   note - PNG is Year 2000 compliant! */
+ * Two conversions are provided, both from time_t and struct tm.  There
+ * is no portable way to convert to either of these structures, as far
+ * as I know.  If you know of a portable way, send it to me.  As a side
+ * note - PNG is Year 2000 compliant!
+ */
 typedef struct png_time_struct
 {
   png_uint_16 year; /* full year, as in, 1995 */
@@ -215,7 +239,7 @@ typedef struct png_info_struct
   png_uint_32 width;       /* width of image in pixels (from IHDR) */
   png_uint_32 height;      /* height of image in pixels (from IHDR) */
   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */
-   png_size_t rowbytes;     /* bytes needed to hold an untransformed row */
+   png_uint_32 rowbytes;    /* bytes needed to hold an untransformed row */
   png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */
   png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */
   png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */
@@ -237,13 +261,21 @@ typedef struct png_info_struct
    * and initialize the appropriate fields below.
    */

-#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
+#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED) || \
+    defined(PNG_READ_GAMMA_SUPPORTED)
   /* The gAMA chunk describes the gamma characteristics of the system
    * on which the image was created, normally in the range [1.0, 2.5].
    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.
    */
   float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */
 #endif /* PNG_READ_gAMA_SUPPORTED || PNG_WRITE_gAMA_SUPPORTED */
+
+#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
+    /* GR-P, 0.96a */
+    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
+   png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */
+#endif /* PNG_READ_sRGB_SUPPORTED || PNG_WRITE_sRGB_SUPPORTED */
+
 #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
    defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
   /* The tEXt and zTXt chunks contain human-readable textual data in
@@ -285,7 +317,8 @@ typedef struct png_info_struct
   png_bytep trans; /* transparent values for paletted image */
   png_color_16 trans_values; /* transparent color for non-palette image */
 #endif /* PNG_READ_tRNS_SUPPORTED || PNG_WRITE_tRNS_SUPPORTED */
-#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED)
+#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED) || \
+    defined(PNG_READ_BACKGROUND_SUPPORTED)
   /* The bKGD chunk gives the suggested image background color if the
    * display program does not have its own background color and the image
    * is needs to composited onto a background before display.  The colors
@@ -406,6 +439,15 @@ typedef png_info FAR * FAR * png_infopp;
 #define PNG_RESOLUTION_METER      1 /* pixels/meter */
 #define PNG_RESOLUTION_LAST       2 /* Not a valid value */

+/* These are for the sRGB chunk.  These values should NOT be changed. */
+#define PNG_sRGB_INTENT_SATURATION 0
+#define PNG_sRGB_INTENT_PERCEPTUAL 1
+#define PNG_sRGB_INTENT_ABSOLUTE   2
+#define PNG_sRGB_INTENT_RELATIVE   3
+#define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */
+                        
+
+
 /* These determine if an ancillary chunk's data has been successfully read
 * from the PNG header, or if the application has filled in the corresponding
 * data in the info_struct to be written into the output file.  The values
@@ -422,6 +464,7 @@ typedef png_info FAR * FAR * png_infopp;
 #define PNG_INFO_oFFs 0x0100
 #define PNG_INFO_tIME 0x0200
 #define PNG_INFO_pCAL 0x0400
+#define PNG_INFO_sRGB 0x0800   /* GR-P, 0.96a */

 /* This is used for the transformation routines, as some of them
 * change these values for the row.  It also should enable using
@@ -430,7 +473,7 @@ typedef png_info FAR * FAR * png_infopp;
 typedef struct png_row_info_struct
 {
   png_uint_32 width; /* width of row */
-   png_size_t rowbytes; /* number of bytes in row */
+   png_uint_32 rowbytes; /* number of bytes in row */
   png_byte color_type; /* color type of row */
   png_byte bit_depth; /* bit depth of row */
   png_byte channels; /* number of channels (1, 2, 3, or 4) */
@@ -451,6 +494,8 @@ typedef png_struct FAR * png_structp;
 typedef void (*png_error_ptr) PNGARG((png_structp, png_const_charp));
 typedef void (*png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));
 typedef void (*png_flush_ptr) PNGARG((png_structp));
+typedef void (*png_read_status_ptr) PNGARG((png_structp, png_uint_32, int));
+typedef void (*png_write_status_ptr) PNGARG((png_structp, png_uint_32, int));
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 typedef void (*png_progressive_info_ptr) PNGARG((png_structp, png_infop));
 typedef void (*png_progressive_end_ptr) PNGARG((png_structp, png_infop));
@@ -458,6 +503,12 @@ typedef void (*png_progressive_row_ptr) PNGARG((png_structp, png_bytep,
   png_uint_32, int));
 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+typedef void (*png_user_transform_ptr) PNGARG((png_structp,
+    png_row_infop, png_bytep));
+#endif /* PNG_READ|WRITE_USER_TRANSFORM_SUPPORTED */
+
 /* The structure that holds the information to read and write PNG files.
 * The only people who need to care about what is inside of this are the
 * people who will be modifying the library for their own special needs.
@@ -474,9 +525,14 @@ struct png_struct_def
   png_voidp error_ptr;       /* user supplied struct for error functions */
   png_rw_ptr write_data_fn;  /* function for writing output data */
   png_rw_ptr read_data_fn;   /* function for reading input data */
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+   png_user_transform_ptr read_user_transform_fn; /* user read transform */
+   png_user_transform_ptr write_user_transform_fn; /* user write transform */
+#endif
   png_voidp io_ptr;          /* ptr to application struct for I/O functions*/

-   png_uint_32 mode;          /* tells us whre we are in the PNG file */
+   png_uint_32 mode;          /* tells us where we are in the PNG file */
   png_uint_32 flags;         /* flags indicating various things to libpng */
   png_uint_32 transformations; /* which transformations to perform */

@@ -493,8 +549,8 @@ struct png_struct_def
   png_uint_32 height;        /* height of image in pixels */
   png_uint_32 num_rows;      /* number of rows in current pass */
   png_uint_32 usr_width;     /* width of row at start of write */
-   png_size_t rowbytes;       /* size of row in bytes */
-   png_size_t irowbytes;      /* size of current interlaced row in bytes */
+   png_uint_32 rowbytes;      /* size of row in bytes */
+   png_uint_32 irowbytes;     /* size of current interlaced row in bytes */
   png_uint_32 iwidth;        /* width of current interlaced row in pixels */
   png_uint_32 row_number;    /* current row in interlace pass */
   png_bytep prev_row;        /* buffer to save previous (unfiltered) row */
@@ -524,7 +580,6 @@ struct png_struct_def
   png_byte usr_channels;     /* channels at start of write */
   png_byte sig_bytes;        /* magic bytes read/written from start of file */

-
 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
   png_byte filler;           /* filler byte for 24->32-bit pixel expansion */
 #endif /* PNG_READ_FILLER_SUPPORTED */
@@ -542,9 +597,9 @@ struct png_struct_def
   png_uint_32 flush_rows;    /* number of rows written since last flush */
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 #if defined(PNG_READ_GAMMA_SUPPORTED)
-   int gamma_shift;           /* number of "insignificant" bits 16-bit gamma */
-   float gamma;               /* file gamma value */
-   float display_gamma;       /* display gamma value */
+   int gamma_shift;      /* number of "insignificant" bits 16-bit gamma */
+   float gamma;          /* file gamma value */
+   float screen_gamma;   /* screen gamma value (display_gamma/viewing_gamma */
 #endif /* PNG_READ_GAMMA_SUPPORTED */
 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
   png_bytep gamma_table;     /* gamma table for 8 bit depth files */
@@ -564,9 +619,11 @@ struct png_struct_def
   png_bytep trans;           /* transparency values for paletted files */
   png_color_16 trans_values; /* transparency values for non-paletted files */
 #endif /* PNG_READ_tRNS_SUPPORTED || PNG_READ_BACKGROUND_SUPPORTED */
+   png_read_status_ptr read_row_fn;   /* called after each row is decoded */
+   png_write_status_ptr write_row_fn; /* called after each row is encoded */
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
   png_progressive_info_ptr info_fn; /* called after header data fully read */
-   png_progressive_row_ptr row_fn;   /* called after each row is decoded */
+   png_progressive_row_ptr row_fn;   /* called after each prog. row is decoded */
   png_progressive_end_ptr end_fn;   /* called after image is complete */
   png_bytep save_buffer_ptr;        /* current location in save_buffer */
   png_bytep save_buffer;            /* buffer for previously read data */
@@ -586,6 +643,7 @@ struct png_struct_def
   png_charp current_text;           /* current text chunk buffer */
   png_charp current_text_ptr;       /* current location in current_text */
 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_READ_tEXt/zTXt_SUPPORTED */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 /* for the Borland special 64K segment handler */
   png_bytepp offset_table_ptr;
@@ -593,13 +651,14 @@ struct png_struct_def
   png_uint_16 offset_table_number;
   png_uint_16 offset_table_count;
   png_uint_16 offset_table_count_free;
-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED&&__TURBOC__&&!_Windows&&!__FLAT__ */
-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+#endif /* __TURBOC__&&!_Windows&&!__FLAT__ */
 #if defined(PNG_READ_DITHER_SUPPORTED)
   png_bytep palette_lookup;         /* lookup table for dithering */
   png_bytep dither_index;           /* index translation for palette files */
-   png_uint_16p hist;                /* histogram */
 #endif /* PNG_READ_DITHER_SUPPORTED */
+#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_READ_hIST_SUPPORTED)
+   png_uint_16p hist;                /* histogram */
+#endif
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
   png_byte heuristic_method;        /* heuristic for row filter selection */
   png_byte num_prev_filters;        /* number of weights for previous rows */
@@ -609,6 +668,9 @@ struct png_struct_def
   png_uint_16p filter_costs;        /* relative filter calculation cost */
   png_uint_16p inv_filter_costs;    /* 1/relative filter calculation cost */
 #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+   png_charp time_buffer;            /* String to hold RFC 1123 time text */
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
 };

 typedef png_struct FAR * FAR * png_structpp;
@@ -640,14 +702,29 @@ extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num));

 /* Allocate and initialize png_ptr struct for reading, and any other memory. */
 extern PNG_EXPORT(png_structp,png_create_read_struct)
-   PNGARG((png_charp user_png_ver, voidp error_ptr, png_error_ptr error_fn,
-   png_error_ptr warn_fn));
+   PNGARG((png_const_charp user_png_ver, voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn));

 /* Allocate and initialize png_ptr struct for reading, and any other memory */
 extern PNG_EXPORT(png_structp,png_create_write_struct)
   PNGARG((png_const_charp user_png_ver, voidp error_ptr,
   png_error_ptr error_fn, png_error_ptr warn_fn));

+/* Write a PNG chunk - size, type, (optional) data, CRC. */
+extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,
+   png_bytep chunk_name, png_bytep data, png_size_t length));
+
+/* Write the start of a PNG chunk - length and chunk name. */
+extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,
+   png_bytep chunk_name, png_uint_32 length));
+
+/* Write the data of a PNG chunk started with png_write_chunk_start(). */
+extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,
+   png_bytep data, png_size_t length));
+
+/* Finish a chunk started with png_write_chunk_start() (includes CRC). */
+extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));
+
 /* Allocate and initialize the info structure */
 extern PNG_EXPORT(png_infop,png_create_info_struct)
   PNGARG((png_structp png_ptr));
@@ -663,6 +740,11 @@ extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,
 extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,
   png_infop info_ptr));

+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)
+   PNGARG((png_structp png_ptr, png_timep ptime));
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
 #if defined(PNG_WRITE_tIME_SUPPORTED)
 /* convert from a struct tm to png_time */
 extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,
@@ -705,6 +787,11 @@ extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));
 extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));
 #endif /* PNG_READ_SWAP_ALPHA_SUPPORTED || PNG_WRITE_SWAP_ALPHA_SUPPORTED */

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));
+#endif /* PNG_READ_INVERT_ALPHA_SUPPORTED || PNG_WRITE_INVERT_ALPHA_SUPPORTED */
+
 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
 /* Add a filler byte to 24-bit RGB images. */
 extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,
@@ -771,7 +858,7 @@ extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,
 #endif /* PNG_READ_DITHER_SUPPORTED */

 #if defined(PNG_READ_GAMMA_SUPPORTED)
-/* Handle gamma correction. */
+/* Handle gamma correction. Screen_gamma=(display_gamma/viewing_gamma) */
 extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,
   double screen_gamma, double default_file_gamma));
 #endif /* PNG_READ_GAMMA_SUPPORTED */
@@ -840,6 +927,9 @@ extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,
 extern PNG_EXPORT(void,png_destroy_write_struct)
   PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));

+/* free any memory used in info_ptr struct (old method - NOT DLL EXPORTED) */
+extern void png_write_destroy_info PNGARG((png_infop info_ptr));
+
 /* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */
 extern void png_write_destroy PNGARG((png_structp png_ptr));

@@ -868,10 +958,12 @@ extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,
 * mainly useful for testing, as the defaults should work with most users.
 * Those users who are tight on memory or want faster performance at the
 * expense of compression can modify them.  See the compression library
- * header file (zlib.h) for an explination of the compression functions. */
+ * header file (zlib.h) for an explination of the compression functions.
+ */

 /* set the filtering method(s) used by libpng.  Currently, the only valid
- * value for "method" is 0 */
+ * value for "method" is 0.
+ */
 extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
   int filters));

@@ -972,8 +1064,10 @@ extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,
 * more information.
 */

+#if !defined(PNG_NO_STDIO)
 /* Initialize the input/output for the PNG file to the default functions. */
 extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, FILE *fp));
+#endif

 /* Replace the (error and abort), and warning functions with user
 * supplied functions.  If no messages are to be printed you must still
@@ -1003,6 +1097,22 @@ extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,
 /* Return the user pointer associated with the I/O functions */
 extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,
+   png_read_status_ptr read_row_fn));
+
+extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,
+   png_write_status_ptr write_row_fn));
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp
+   png_ptr, png_user_transform_ptr read_user_transform_fn));
+#endif
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp
+   png_ptr, png_user_transform_ptr write_user_transform_fn));
+#endif
+
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 /* Sets the function callbacks for the push reader, and a pointer to a
 * user-defined structure available to the callback functions.
@@ -1030,21 +1140,43 @@ extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,
 extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,
   png_uint_32 size));

-/* free's a pointer allocated by png_malloc() */
+/* frees a pointer allocated by png_malloc() */
 extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));

+extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,
+   png_voidp s1, png_voidp s2, png_uint_32 size));
+
+extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,
+   png_voidp s1, int value, png_uint_32 size));
+
+#ifdef PNGTEST_MEMORY_DEBUG
+/* debugging versions of png_malloc() and png_free() */
+extern PNG_EXPORT(png_voidp,png_debug_malloc) PNGARG((png_structp png_ptr,
+   png_uint_32 size));
+extern PNG_EXPORT(void,png_debug_free) PNGARG((png_structp png_ptr,
+   png_voidp ptr));
+#endif
 #if defined(USE_FAR_KEYWORD)  /* memory model conversion function */
-extern void *far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,int check));
+extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
+   int check));
 #endif /* USE_FAR_KEYWORD */

 /* Fatal error in PNG image of libpng - can't continue */
 extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,
   png_const_charp error));

+/* The same, but the chunk name is prepended to the error string. */
+extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,
+   png_const_charp error));
+
 /* Non-fatal error in libpng.  Can continue, but may have a problem. */
 extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,
   png_const_charp message));

+/* Non-fatal error in libpng, chunk name is prepended to message. */
+extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,
+   png_const_charp message));
+
 /* The png_set_<chunk> functions are for storing values in the png_info_struct.
 * Similarly, the png_get_<chunk> calls are used to read values from the
 * png_info_struct, either storing the parameters in the passed variables, or
@@ -1057,18 +1189,71 @@ extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,
 * to avoid problems with future changes in the size and internal layout of
 * png_info_struct.
 */
-/* Returns "flag" if chunk data is valid in info_ptr */
+/* Returns "flag" if chunk data is valid in info_ptr. */
 extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,
 png_infop info_ptr, png_uint_32 flag));

-/* Returns number of bytes needed to hold a transformed row */
+/* Returns number of bytes needed to hold a transformed row. */
 extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr,
 png_infop info_ptr));

-/* Returns number of color channels in image */
+/* Returns number of color channels in image. */
 extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,
 png_infop info_ptr));

+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* Returns image width in pixels. */
+extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image height in pixels. */
+extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image bit_depth. */
+extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image color_type. */
+extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image filter_type. */
+extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image interlace_type. */
+extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image compression_type. */
+extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image resolution in pixels per meter, from pHYs chunk data. */
+extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns pixel aspect ratio, computed from pHYs chunk data.  */
+extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
+extern PNG_EXPORT(png_uint_32, png_get_x_offset_pixels) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_y_offset_pixels) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_x_offset_microns) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_y_offset_microns) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+#endif /* PNG_EASY_ACCESS_SUPPORTED */
+
 /* Returns pointer to signature string read from PNG header */
 extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,
 png_infop info_ptr));
@@ -1175,6 +1360,18 @@ extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,
   png_infop info_ptr, png_color_8p sig_bit));
 #endif /* PNG_READ_sBIT_SUPPORTED || PNG_WRITE_sBIT_SUPPORTED */

+#if defined(PNG_READ_sRGB_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int *intent));
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
+extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int intent));
+extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int intent));
+#endif /* PNG_READ_sRGB_SUPPORTED || PNG_WRITE_sRGB_SUPPORTED */
+
 #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
 /* png_get_text also returns the number of text chunks in text_ptr */
 extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,
@@ -1216,6 +1413,9 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 * libpng yet, but more support will be added as needed.
 */
 #if (PNG_DEBUG > 0)
+#ifdef PNG_NO_STDIO
+#include <stdio.h>
+#endif
 #ifndef PNG_DEBUG_FILE
 #define PNG_DEBUG_FILE stderr
 #endif /* PNG_DEBUG_FILE */
@@ -1244,13 +1444,17 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 #if defined(PNG_INTERNAL)

 /* Various modes of operation.  Note that after an init, mode is set to
-   zero automatically when the structure is created. */
+ * zero automatically when the structure is created.
+ */
 #define PNG_BEFORE_IHDR       0x00
 #define PNG_HAVE_IHDR         0x01
 #define PNG_HAVE_PLTE         0x02
 #define PNG_HAVE_IDAT         0x04
 #define PNG_AFTER_IDAT        0x08
 #define PNG_HAVE_IEND         0x10
+#define PNG_HAVE_gAMA         0x20
+#define PNG_HAVE_cHRM         0x40
+#define PNG_HAVE_sRGB         0x80

 /* push model modes */
 #define PNG_READ_SIG_MODE   0
@@ -1279,9 +1483,11 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 #define PNG_GAMMA              0x2000
 #define PNG_GRAY_TO_RGB        0x4000
 #define PNG_FILLER             0x8000
-#define PNG_PACKSWAP          0x10000
-#define PNG_SWAP_ALPHA        0x20000
-#define PNG_STRIP_ALPHA       0x40000
+#define PNG_PACKSWAP          0x10000L
+#define PNG_SWAP_ALPHA        0x20000L
+#define PNG_STRIP_ALPHA       0x40000L
+#define PNG_INVERT_ALPHA      0x80000L
+#define PNG_USER_TRANSFORM   0x100000L

 /* flags for png_create_struct */
 #define PNG_STRUCT_PNG   0x0001
@@ -1309,8 +1515,8 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 #define PNG_FLAG_FREE_PALETTE             0x1000
 #define PNG_FLAG_FREE_TRANS               0x2000
 #define PNG_FLAG_FREE_HIST                0x4000
-#define PNG_FLAG_HAVE_CHUNK_HEADER        0x8000
-#define PNG_FLAG_WROTE_tIME              0x10000
+#define PNG_FLAG_HAVE_CHUNK_HEADER        0x8000L
+#define PNG_FLAG_WROTE_tIME              0x10000L

 #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
                                     PNG_FLAG_CRC_ANCILLARY_NOWARN)
@@ -1327,30 +1533,32 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
   abs((int)((c1).blue) - (int)((c2).blue)))

 /* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
-#ifndef PNG_NO_EXTERN
-/* place to hold the signiture string for a PNG file. */
-extern png_byte FARDATA png_sig[];
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
+/* place to hold the signature string for a PNG file. */
+extern png_byte FARDATA png_sig[8];

-/* constant strings for known chunk types.  If you need to add a chunk,
-   add a string holding the name here.  See png.c for more details.  We
-   can't selectively include these, since we still check for chunk in the
-   wrong locations with these labels. */
-extern png_byte FARDATA png_IHDR[];
-extern png_byte FARDATA png_IDAT[];
-extern png_byte FARDATA png_IEND[];
-extern png_byte FARDATA png_PLTE[];
-extern png_byte FARDATA png_bKGD[];
-extern png_byte FARDATA png_cHRM[];
-extern png_byte FARDATA png_gAMA[];
-extern png_byte FARDATA png_hIST[];
-extern png_byte FARDATA png_oFFs[];
-extern png_byte FARDATA png_pCAL[];
-extern png_byte FARDATA png_pHYs[];
-extern png_byte FARDATA png_sBIT[];
-extern png_byte FARDATA png_tEXt[];
-extern png_byte FARDATA png_tIME[];
-extern png_byte FARDATA png_tRNS[];
-extern png_byte FARDATA png_zTXt[];
+/* Constant strings for known chunk types.  If you need to add a chunk,
+ * add a string holding the name here.  See png.c for more details.  We
+ * can't selectively include these, since we still check for chunk in the
+ * wrong locations with these labels.
+ */
+extern png_byte FARDATA png_IHDR[5];
+extern png_byte FARDATA png_IDAT[5];
+extern png_byte FARDATA png_IEND[5];
+extern png_byte FARDATA png_PLTE[5];
+extern png_byte FARDATA png_bKGD[5];
+extern png_byte FARDATA png_cHRM[5];
+extern png_byte FARDATA png_gAMA[5];
+extern png_byte FARDATA png_hIST[5];
+extern png_byte FARDATA png_oFFs[5];
+extern png_byte FARDATA png_pCAL[5];
+extern png_byte FARDATA png_pHYs[5];
+extern png_byte FARDATA png_sBIT[5];
+extern png_byte FARDATA png_sRGB[5];
+extern png_byte FARDATA png_tEXt[5];
+extern png_byte FARDATA png_tIME[5];
+extern png_byte FARDATA png_tRNS[5];
+extern png_byte FARDATA png_zTXt[5];

 #endif /* PNG_NO_EXTERN */

@@ -1376,12 +1584,14 @@ PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf));
 PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf));
 #endif /* PNG_BIG_ENDIAN_GET_SUPPORTED */

-/* Initialize png_ptr struct for reading, and allocate any other memory
- * (old interface - NOT DLL EXPORTED) */
+/* Initialize png_ptr struct for reading, and allocate any other memory.
+ * (old interface - NOT DLL EXPORTED).
+ */
 extern void png_read_init PNGARG((png_structp png_ptr));

-/* Initialize png_ptr struct for writing, and allocate any other memory
- * (old interface - NOT DLL EXPORTED) */
+/* Initialize png_ptr struct for writing, and allocate any other memory.
+ * (old interface - NOT DLL EXPORTED).
+ */
 extern void png_write_init PNGARG((png_structp png_ptr));

 /* allocate memory for an internal libpng struct */
@@ -1433,7 +1643,7 @@ PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
 #endif

 /* Place a 32-bit number into a buffer in PNG byte order (big-endian).
- * The only currently known PNG chunk that uses unsigned numbers is
+ * The only currently known PNG chunk that uses signed numbers is
 * the ancillary extension chunk, pCAL.
 */
 PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i));
@@ -1442,31 +1652,20 @@ PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i));
 PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i));
 #endif

-/* place a 16 bit number into a buffer in PNG byte order */
-PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, png_uint_16 i));
+/* Place a 16 bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
+PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i));

-/* Write a PNG chunk - size, type, (optional) data, CRC. */
-PNG_EXTERN void png_write_chunk PNGARG((png_structp png_ptr,
-   png_bytep chunk_name, png_bytep data, png_size_t length));
-
-/* Write the start of a PNG chunk - length and chunk name. */
-PNG_EXTERN void png_write_chunk_start PNGARG((png_structp png_ptr,
-   png_bytep chunk_name, png_uint_32 length));
-
-/* Write the data of a PNG chunk started with png_write_chunk_start(). */
-PNG_EXTERN void png_write_chunk_data PNGARG((png_structp png_ptr,
-   png_bytep data, png_size_t length));
-
-/* Finish a chunk started with png_write_chunk_start() (includes CRC). */
-PNG_EXTERN void png_write_chunk_end PNGARG((png_structp png_ptr));
-
-/* simple function to write the signiture */
+/* simple function to write the signature */
 PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));

 /* write various chunks */

 /* Write the IHDR chunk, and update the png_struct with the necessary
-   information. */
+ * information.
+ */
 PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
   png_uint_32 height,
   int bit_depth, int color_type, int compression_type, int filter_type,
@@ -1496,6 +1695,11 @@ PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
   double blue_x, double blue_y));
 #endif

+#if defined(PNG_WRITE_sRGB_SUPPORTED)
+PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
+   int intent));
+#endif
+
 #if defined(PNG_WRITE_tRNS_SUPPORTED)
 PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,
   png_color_16p values, int number, int color_type));
@@ -1508,12 +1712,12 @@ PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,

 #if defined(PNG_WRITE_hIST_SUPPORTED)
 PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
-   png_uint_32 num_hist));
+   int num_hist));
 #endif

 #if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
 PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
-   png_charp key, png_bytepp new_key));
+   png_charp key, png_charpp new_key));
 #endif

 #if defined(PNG_WRITE_tEXt_SUPPORTED)
@@ -1610,6 +1814,16 @@ PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
   png_bytep row));
 #endif

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
+   png_bytep row));
+#endif
+
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
+   png_bytep row));
+#endif
+
 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
 PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
@@ -1698,7 +1912,8 @@ PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
 #endif

 /* The following decodes the appropriate chunks, and does error correction,
- * then calls the appropriate callback for the chunk if it is valid */
+ * then calls the appropriate callback for the chunk if it is valid.
+ */

 /* decode the IHDR chunk */
 PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
@@ -1723,6 +1938,11 @@ PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
   png_uint_32 length));
 #endif

+#if defined(PNG_READ_sRGB_SUPPORTED)
+PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 length));
+#endif
+
 #if defined(PNG_READ_tRNS_SUPPORTED)
 PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
   png_uint_32 length));
--- a/pngconf.h
+++ b/pngconf.h
@@ -1,66 +1,71 @@

-/* pngconf.c - machine configurable file for libpng
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+/* pngconf.h - machine configurable file for libpng
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 /* Any machine specific code is near the front of this file, so if you
-   are configuring libpng for a machine, you may want to read the section
-   starting here down to where it starts to typedef png_color, png_text,
-   and png_info */
+ * are configuring libpng for a machine, you may want to read the section
+ * starting here down to where it starts to typedef png_color, png_text,
+ * and png_info.
+ */

 #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
-   is full, it writes the data to the disk, and does some other
-   calculations.  Making this an extreamly small size will slow
-   the library down, but you may want to experiment to determine
-   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),
-   it should not make much difference how big this is.  */
+ * 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
+ * is full, it writes the data to the disk, and does some other
+ * calculations.  Making this an extremely small size will slow
+ * the library down, but you may want to experiment to determine
+ * 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 than the size of a row (compressed),
+ * it should not make much difference how big this is.
+ */

+#ifndef PNG_ZBUF_SIZE
 #define PNG_ZBUF_SIZE 8192
+#endif

 /* If you are running on a machine where you cannot allocate more
-   than 64K of memory at once, uncomment this.  While libpng will not
-   normally need that much memory in a chunk (unless you load up a very
-   large file), zlib needs to know how big of a chunk it can use, and
-   libpng thus makes sure to check any memory allocation to verify it
-   will fit into memory.
+ * than 64K of memory at once, uncomment this.  While libpng will not
+ * normally need that much memory in a chunk (unless you load up a very
+ * large file), zlib needs to know how big of a chunk it can use, and
+ * libpng thus makes sure to check any memory allocation to verify it
+ * will fit into memory.
 #define PNG_MAX_MALLOC_64K
-*/
+ */
 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
 #define PNG_MAX_MALLOC_64K
 #endif

 /* This protects us against compilers which 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. */
+ * 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.
+ * #define PNG_NO_STDIO
+ */

-/* #define PNG_NO_STDIO */
-
-/* for FILE.  If you are not using standard io, you don't need this */
-#ifndef PNG_NO_STDIO
+#ifndef PNG_NO_STDIO 
 #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
-   function prototypes, define this macro and use the included ansi2knr.
-   I've always been able to use _NO_PROTO as the indicator, but you may
-   need to drag the empty declaration out in front of here, or change the
-   ifdef to suit your own needs. */
+ * prototypes (ie K&R style headers).  If your compiler does not handle
+ * function prototypes, define this macro and use the included ansi2knr.
+ * I've always been able to use _NO_PROTO as the indicator, but you may
+ * need to drag the empty declaration out in front of here, or change the
+ * ifdef to suit your own needs.
+ */
 #ifndef PNGARG

 #ifdef OF /* zlib prototype munger */
@@ -77,10 +82,16 @@

 #endif /* PNGARG */

-/* Try to determine if we are compiling on a Mac */
-#if defined(__MWERKS__) ||defined(applec) ||defined(THINK_C) ||defined(__SC__)
+/* Try to determine if we are compiling on a Mac.  Note that testing for
+ * 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(TARGET_OS_MAC)
 #define MACOS
 #endif
+#endif

 /* enough people need this for various reasons to include it here */
 #if !defined(MACOS) && !defined(RISCOS)
@@ -88,27 +99,28 @@
 #endif

 /* This is an attempt to force a single setjmp behaviour on Linux.  If
-   the X config stuff didn't define _BSD_SOURCE we wouldn't need this. */
-#ifdef linux
+ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
+ */
+#ifdef __linux__
 #ifdef _BSD_SOURCE
 #define _PNG_SAVE_BSD_SOURCE
 #undef _BSD_SOURCE
 #endif
 #ifdef _SETJMP_H
-#error  __png_h_already_includes_setjmp_h__
-#error  __dont_include_it_again__
+__png.h__ already includes setjmp.h
+__dont__ include it again
 #endif
-#endif /* linux */
+#endif /* __linux__ */

 /* include setjmp.h for error handling */
 #include <setjmp.h>

-#ifdef linux
+#ifdef __linux__
 #ifdef _PNG_SAVE_BSD_SOURCE
 #define _BSD_SOURCE
 #undef _PNG_SAVE_BSD_SOURCE
 #endif
-#endif /* linux */
+#endif /* __linux__ */

 #ifdef BSD
 #include <strings.h>
@@ -119,9 +131,6 @@
 /* Other defines for things like memory and the like can go here.  */
 #ifdef PNG_INTERNAL
 #include <stdlib.h>
-/* Where do we need this???
-#include <ctype.h>
-*/

 /* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which
 * aren't usually used outside the library (as far as I know), so it is
@@ -133,12 +142,14 @@
 #define PNG_EXTERN

 /* Other defines specific to compilers can go here.  Try to keep
-   them inside an appropriate ifdef/endif pair for portability */
+ * them inside an appropriate ifdef/endif pair for portability.
+ */

 #if defined(MACOS)
 /* We need to check that <math.h> hasn't already been included earlier
-   as it seems it doesn't agree with <fp.h>, yet we should really use
-   <fp.h> if possible. */
+ * as it seems it doesn't agree with <fp.h>, yet we should really use
+ * <fp.h> if possible.
+ */
 #if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
 #include <fp.h>
 #endif
@@ -146,9 +157,15 @@
 #include <math.h>
 #endif

+/* Codewarrior on NT has linking problems without this. */
+#if defined(__MWERKS__) && defined(WIN32)
+#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"? */
+ * stdlib.h like it should (I think).  Or perhaps this is a C++
+ * "feature"?
+ */
 #ifdef __TURBOC__
 #include <mem.h>
 #include "alloc.h"
@@ -159,58 +176,84 @@
 #endif

 /* This controls how fine the dithering gets.  As this allocates
-   a largish chunk of memory (32K), those who are not as concerned
-   with dithering quality can decrease some or all of these. */
+ * a largish chunk of memory (32K), those who are not as concerned
+ * with dithering quality can decrease some or all of these.
+ */
+#ifndef PNG_DITHER_RED_BITS
 #define PNG_DITHER_RED_BITS 5
+#endif
+#ifndef PNG_DITHER_GREEN_BITS
 #define PNG_DITHER_GREEN_BITS 5
+#endif
+#ifndef PNG_DITHER_BLUE_BITS
 #define PNG_DITHER_BLUE_BITS 5
+#endif

 /* This controls how fine the gamma correction becomes when you
-   are only interested in 8 bits anyway.  Increasing this value
-   results in more memory being used, and more pow() functions
-   being called to fill in the gamma tables.  Don't set this
-   value less then 8, and even that may not work (I haven't tested
-   it). */
+ * are only interested in 8 bits anyway.  Increasing this value
+ * results in more memory being used, and more pow() functions
+ * being called to fill in the gamma tables.  Don't set this value
+ * 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.  */
+ * 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.
-   */
-#undef PNG_USE_CONST
+ * and warning message functions, so some compilers won't complain.
+ * If you do not want to use const, define PNG_NO_CONST here.
+ */

-#ifdef PNG_USE_CONST
+#ifndef PNG_NO_CONST
 #  define PNG_CONST const
 #else
 #  define PNG_CONST
 #endif

 /* The following defines give you the ability to remove code from the
-   library that you will not be using.  I wish I could figure out how to
-   automate this, but I can't do that without making it seriously hard
-   on the users.  So if you are not using an ability, change the #define
-   to and #undef, and that part of the library will not be compiled.  If
-   your linker can't find a function, you may want to make sure the
-   ability is defined here.  Some of these depend upon some others being
-   defined.  I haven't figured out all the interactions here, so you may
-   have to experiment awhile to get everything to compile.  If you are
-   creating or using a shared library, you probably shouldn't touch this,
-   as it will affect the size of the structures, and this will cause bad
-   things to happen if the library and/or application ever change. */
+ * library that you will not be using.  I wish I could figure out how to
+ * automate this, but I can't do that without making it seriously hard
+ * on the users.  So if you are not using an ability, change the #define
+ * to and #undef, and that part of the library will not be compiled.  If
+ * your linker can't find a function, you may want to make sure the
+ * ability is defined here.  Some of these depend upon some others being
+ * defined.  I haven't figured out all the interactions here, so you may
+ * have to experiment awhile to get everything to compile.  If you are
+ * creating or using a shared library, you probably shouldn't touch this,
+ * as it will affect the size of the structures, and this will cause bad
+ * things to happen if the library and/or application ever change.
+ */

 /* Any transformations you will not be using can be undef'ed here */
-#define PNG_PROGRESSIVE_READ_SUPPORTED
-#define PNG_READ_OPT_PLTE_SUPPORTED
-#define PNG_READ_INTERLACING_SUPPORTED
+
+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
+   to turn it off with "*TRANSFORMS_NOT_SUPPORTED" on the compile line,
+   then pick and choose which ones to define without having to edit
+   this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED if you
+   only want to have a png-compliant reader/writer but don't need
+   any of the extra transformations.  This saves about 80 kbytes in a
+   typical installation of the library.
+ */
+
+
+#ifndef PNG_READ_TRANSFORMS_NOT_SUPPORTED
+#define PNG_READ_TRANSFORMS_SUPPORTED
+#endif
+#ifndef PNG_WRITE_TRANSFORMS_NOT_SUPPORTED
+#define PNG_WRITE_TRANSFORMS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
 #define PNG_READ_EXPAND_SUPPORTED
 #define PNG_READ_SHIFT_SUPPORTED
 #define PNG_READ_PACK_SUPPORTED
@@ -225,9 +268,22 @@
 #define PNG_READ_GAMMA_SUPPORTED
 #define PNG_READ_GRAY_TO_RGB_SUPPORTED
 #define PNG_READ_SWAP_ALPHA_SUPPORTED
+#define PNG_READ_INVERT_ALPHA_SUPPORTED
 #define PNG_READ_STRIP_ALPHA_SUPPORTED
+#define PNG_READ_USER_TRANSFORM_SUPPORTED
+/* the following aren't implemented yet
+#define PNG_READ_RGB_TO_GRAY_SUPPORTED
+ */
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */

-#define PNG_WRITE_INTERLACING_SUPPORTED
+#ifndef 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 */
+#define PNG_READ_COMPOSITE_NODIV_SUPPORTED    /* well tested on Intel and SGI */
+
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
 #define PNG_WRITE_SHIFT_SUPPORTED
 #define PNG_WRITE_PACK_SUPPORTED
 #define PNG_WRITE_BGR_SUPPORTED
@@ -237,27 +293,72 @@
 #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_INVERT_ALPHA_SUPPORTED
 #define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */

-/* These are currently experimental features */
-#undef PNG_READ_16_TO_8_ACCURATE_SHIFT_SUPPORTED /* very little testing */
-#undef PNG_READ_COMPOSITE_NODIV_SUPPORTED        /* very little testing */
+#define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant
+                                            encoders, but can cause trouble
+                                            if left undefined */
+
+#if !defined(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()
+ */
+#if !defined(PNG_NO_EASY_ACCESS)
+#define PNG_EASY_ACCESS_SUPPORTED
+#endif
+
+/* These are currently experimental features, define them if you want */
+
+/* very little testing */
+/*
+#define PNG_READ_16_TO_8_ACCURATE_SCALE_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_USE_OWN_CRC
-#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.
 */

+#ifndef PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED
+#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+#ifndef PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED
+#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
 #define PNG_READ_bKGD_SUPPORTED
 #define PNG_READ_cHRM_SUPPORTED
 #define PNG_READ_gAMA_SUPPORTED
@@ -266,11 +367,16 @@
 #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
+#define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the optional */
+                                    /* PLTE chunk in RGB and RGBA images */
+#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */

+#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
 #define PNG_WRITE_bKGD_SUPPORTED
 #define PNG_WRITE_cHRM_SUPPORTED
 #define PNG_WRITE_gAMA_SUPPORTED
@@ -279,10 +385,12 @@
 #define PNG_WRITE_pCAL_SUPPORTED
 #define PNG_WRITE_pHYs_SUPPORTED
 #define PNG_WRITE_sBIT_SUPPORTED
+#define PNG_WRITE_sRGB_SUPPORTED
 #define PNG_WRITE_tEXt_SUPPORTED
 #define PNG_WRITE_tIME_SUPPORTED
 #define PNG_WRITE_tRNS_SUPPORTED
 #define PNG_WRITE_zTXt_SUPPORTED
+#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)
@@ -336,18 +444,19 @@ typedef size_t png_size_t;
 #endif   /* LDATA != 1 */

 /* Possibly useful for moving data out of default segment.
-   Uncomment it if you want. Could also define FARDATA as
-   const if your compiler supports it. (SJT)
+ * Uncomment it if you want. Could also define FARDATA as
+ * const if your compiler supports it. (SJT)
 #  define FARDATA FAR
-*/
+ */
 #endif  /* __WIN32__, __FLAT__ */

 #endif   /* __BORLANDC__ */


 /* Suggest testing for specific compiler first before testing for
-   FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,
-   making reliance oncertain keywords suspect. (SJT) */
+ * FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,
+ * making reliance oncertain keywords suspect. (SJT)
+ */

 /* MSC Medium model */
 #if defined(FAR)
@@ -400,25 +509,36 @@ typedef charf *         png_zcharp;
 typedef charf * FAR *   png_zcharpp;
 typedef z_stream FAR *  png_zstreamp; 

-/* allow for compilation as dll under windows */
+/* 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(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
+
 #ifndef PNG_EXPORT
-#define PNG_EXPORT(t,s) t s
+#define PNG_EXPORT(type,symbol) type symbol
 #endif


 /* User may want to use these so not in PNG_INTERNAL. Any library functions
-   that are passed far data must be model independent. */
+ * that are passed far data must be model independent.
+ */

 #if defined(USE_FAR_KEYWORD)  /* memory model independent fns */
 /* 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_strlen _fstrlen
 #   define png_memcmp _fmemcmp      /* SJT: added */
 #   define png_memcpy _fmemcpy
--- a/pngerror.c
+++ b/pngerror.c
@@ -1,16 +1,18 @@

 /* pngerror.c - stub functions for i/o and memory allocation
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-
-   This file provides a location for all error handling.  Users which
-   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. */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This file provides a location for all error handling.  Users which
+ * 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.
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -21,9 +23,10 @@ static void png_default_warning PNGARG((png_structp png_ptr,
                                        png_const_charp message));

 /* This function is called whenever there is a fatal error.  This function
-   should not be changed.  If there is a need to handle errors differently,
-   you should supply a replacement error function and use png_set_error_fn()
-   to replace the error function at run-time. */
+ * should not be changed.  If there is a need to handle errors differently,
+ * you should supply a replacement error function and use png_set_error_fn()
+ * to replace the error function at run-time.
+ */
 void
 png_error(png_structp png_ptr, png_const_charp message)
 {
@@ -36,9 +39,10 @@ png_error(png_structp png_ptr, png_const_charp message)
 }

 /* This function is called whenever there is a non-fatal error.  This function
-   should not be changed.  If there is a need to handle warnings differently,
-   you should supply a replacement warning function and use
-   png_set_error_fn() to replace the warning function at run-time. */
+ * should not be changed.  If there is a need to handle warnings differently,
+ * you should supply a replacement warning function and use
+ * png_set_error_fn() to replace the warning function at run-time.
+ */
 void
 png_warning(png_structp png_ptr, png_const_charp message)
 {
@@ -48,10 +52,65 @@ 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
+ * 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 PNG_CONST char png_digit[16] = {
+   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+static void
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp message)
+{
+   int iout = 0, iin = 0;
+
+   while (iin < 4) {
+      int c = png_ptr->chunk_name[iin++];
+      if (isnonalpha(c)) {
+         buffer[iout++] = '[';
+         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
+         buffer[iout++] = png_digit[c & 0xf];
+         buffer[iout++] = ']';
+      } else {
+         buffer[iout++] = c;
+      }
+   }
+
+   if (message == NULL)
+      buffer[iout] = 0;
+   else {
+      buffer[iout++] = ':';
+      buffer[iout++] = ' ';
+      png_memcpy(buffer+iout, message, 64);
+      buffer[iout+63] = 0;
+   }
+}
+
+void
+png_chunk_error(png_structp png_ptr, png_const_charp message)
+{
+   char msg[16+64];
+   png_format_buffer(png_ptr, msg, message);
+   png_error(png_ptr, msg);
+}
+
+void
+png_chunk_warning(png_structp png_ptr, png_const_charp message)
+{
+   char msg[16+64];
+   png_format_buffer(png_ptr, msg, message);
+   png_warning(png_ptr, msg);
+}
+
 /* This is the default error handling function.  Note that replacements for
-   this function MUST NOT RETURN, or the program will likely crash.  This
-   function is used by default, or if the program supplies NULL for the
-   error function pointer in png_set_error_fn(). */
+ * this function MUST NOT RETURN, or the program will likely crash.  This
+ * function is used by default, or if the program supplies NULL for the
+ * error function pointer in png_set_error_fn().
+ */
 static void
 png_default_error(png_structp png_ptr, png_const_charp message)
 {
@@ -71,9 +130,10 @@ 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
-   not used, but it is passed in case it may be useful. */
+ * 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
+ * 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)
 {
@@ -86,9 +146,10 @@ png_default_warning(png_structp png_ptr, png_const_charp message)
 }

 /* This function is called when the application wants to use another method
-   of handling errors and warnings.  Note that the error function MUST NOT
-   return to the calling routine or serious problems will occur.  The return
-   method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) */
+ * of handling errors and warnings.  Note that the error function MUST NOT
+ * return to the calling routine or serious problems will occur.  The return
+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
+ */
 void
 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
   png_error_ptr error_fn, png_error_ptr warning_fn)
@@ -100,12 +161,13 @@ png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,


 /* This function returns a pointer to the error_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. */
+ * 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_error_ptr(png_structp png_ptr)
 {
-   return png_ptr->error_ptr;
+   return ((png_voidp)png_ptr->error_ptr);
 }


--- a/pngget.c
+++ b/pngget.c
@@ -1,12 +1,13 @@

 /* pngget.c - retrieval of values from info struct
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -14,7 +15,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);
@@ -23,28 +24,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
+
+#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)
@@ -52,8 +332,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);
@@ -69,7 +349,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)
@@ -98,8 +378,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;
@@ -109,11 +389,27 @@ png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
 }
 #endif

+#if defined(PNG_READ_sRGB_SUPPORTED)
+png_uint_32
+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
+{
+   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 = (int)info_ptr->srgb_intent;
+      return (PNG_INFO_sRGB);
+   }
+   return (0);
+}
+#endif
+
 #if defined(PNG_READ_hIST_SUPPORTED)
 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;
@@ -130,9 +426,12 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
   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;
@@ -144,6 +443,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_uint_32)2147483647L/rowbytes_per_pixel))
+      {
+         png_warning(png_ptr,
+            "Width too large for libpng to process image data.");
+      }
      return (1);
   }
   return (0);
@@ -154,8 +470,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;
@@ -173,7 +489,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)
   {
@@ -196,16 +512,28 @@ png_uint_32
 png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
 {
-   if (info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs &&
-      res_x != NULL && res_y != NULL && unit_type != NULL)
+   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");
-      *res_x = info_ptr->x_pixels_per_unit;
-      *res_y = info_ptr->y_pixels_per_unit;
-      *unit_type = (int)info_ptr->phys_unit_type;
-      return (PNG_INFO_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;
+      }
   }
-   return (0);
+   return (retval);
 }
 #endif

@@ -213,7 +541,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;
@@ -228,7 +557,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);
@@ -243,15 +573,16 @@ 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)
         *num_text = info_ptr->num_text;
-      return (info_ptr->num_text);
+      return ((png_uint_32)info_ptr->num_text);
   }
   return(0);
 }
@@ -261,7 +592,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);
@@ -276,25 +608,37 @@ 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

--- a/pngmem.c
+++ b/pngmem.c
@@ -1,19 +1,31 @@

 /* pngmem.c - stub functions for memory allocation
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-
-   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. */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This file provides a location for all memory allocation.  Users which
+ * need special memory handling are expected to modify the code in this file
+ * to meet their needs.  See the instructions at each function.
+ */

 #define PNG_INTERNAL
 #include "png.h"

+/* The following "hides" PNG_MALLOC and PNG_FREE thus allowing the pngtest
+   application to put a wrapper on top of them. */
+#ifdef PNGTEST_MEMORY_DEBUG
+#define PNG_MALLOC png_debug_malloc
+#define PNG_FREE   png_debug_free
+#else
+#define PNG_MALLOC png_malloc
+#define PNG_FREE   png_free
+#endif
+
 /* Borland DOS special memory handler */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 /* if you change this, be sure to change the one in png.h also */
@@ -31,7 +43,7 @@ png_create_struct(int type)
   else if (type == PNG_STRUCT_PNG)
     size = sizeof(png_struct);
   else
-     return (png_voidp)NULL;
+     return ((png_voidp)NULL);

   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
   {
@@ -47,7 +59,10 @@ void
 png_destroy_struct(png_voidp struct_ptr)
 {
   if (struct_ptr != NULL)
+   {
      farfree (struct_ptr);
+      struct_ptr = NULL;
+   }
 }

 /* Allocate memory.  For reasonable files, size should never exceed
@@ -70,18 +85,18 @@ png_destroy_struct(png_voidp struct_ptr)
 * (which should cause a fatal error) and introducing major problems.
 */
 png_voidp
-png_malloc(png_structp png_ptr, png_uint_32 size)
+PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 {
   png_voidp ret;
   if (png_ptr == NULL || size == 0)
-      return ((voidp)NULL);
+      return ((png_voidp)NULL);

 #ifdef PNG_MAX_MALLOC_64K
   if (size > (png_uint_32)65536L)
      png_error(png_ptr, "Cannot Allocate > 64K");
 #endif

-   if (size == (png_uint_32)(65536L))
+   if (size == (png_uint_32)65536L)
   {
      if (png_ptr->offset_table == NULL)
      {
@@ -96,8 +111,10 @@ 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)
@@ -113,7 +130,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)
@@ -127,7 +144,7 @@ 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;
@@ -139,7 +156,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
            for (i = 0; i < num_blocks; i++)
            {
               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
-               hptr += 65536L;
+               hptr += (png_uint_32)65536L;
            }

            png_ptr->offset_table_number = num_blocks;
@@ -149,7 +166,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++];
   }
@@ -158,17 +175,17 @@ 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
+/* free a pointer allocated by PNG_MALLOC().  In the default
   configuration, png_ptr is not used, but is passed in case it
   is needed.  If ptr is NULL, return without taking any action. */
 void
-png_free(png_structp png_ptr, png_voidp ptr)
+PNG_FREE(png_structp png_ptr, png_voidp ptr)
 {
   if (png_ptr == NULL || ptr == NULL)
      return;
@@ -196,7 +213,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 */
@@ -215,7 +235,7 @@ png_create_struct(int type)
   else if (type == PNG_STRUCT_PNG)
      size = sizeof(png_struct);
   else
-      return (png_voidp)NULL;
+      return ((png_voidp)NULL);

 #if defined(__TURBOC__) && !defined(__FLAT__)
   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
@@ -239,6 +259,7 @@ void
 png_destroy_struct(png_voidp struct_ptr)
 {
   if (struct_ptr != NULL)
+   {
 #if defined(__TURBOC__) && !defined(__FLAT__)
      farfree(struct_ptr);
 #else
@@ -248,6 +269,7 @@ png_destroy_struct(png_voidp struct_ptr)
      free(struct_ptr);
 # endif
 #endif
+   }
 }


@@ -258,11 +280,12 @@ png_destroy_struct(png_voidp struct_ptr)
   have the ability to do that. */

 png_voidp
-png_malloc(png_structp png_ptr, png_uint_32 size)
+PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 {
   png_voidp ret;
+
   if (png_ptr == NULL || size == 0)
-      return (NULL);
+      return ((png_voidp)NULL);

 #ifdef PNG_MAX_MALLOC_64K
   if (size > (png_uint_32)65536L)
@@ -270,12 +293,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

@@ -284,14 +307,14 @@ 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
+/* Free a pointer allocated by PNG_MALLOC().  In the default
  configuration, png_ptr is not used, but is passed in case it
  is needed.  If ptr is NULL, return without taking any action. */
 void
-png_free(png_structp png_ptr, png_voidp ptr)
+PNG_FREE(png_structp png_ptr, png_voidp ptr)
 {
   if (png_ptr == NULL || ptr == NULL)
      return;
@@ -309,3 +332,29 @@ png_free(png_structp png_ptr, png_voidp ptr)

 #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));
+
+}
--- a/pngpread.c
+++ b/pngpread.c
@@ -1,12 +1,13 @@

 /* pngpread.c - read a png file in push mode
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -116,10 +117,11 @@ void
 png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
 {
   /* First we make sure we have enough data for the 4 byte chunk name
-      and the 4 byte chunk length before proceeding with decoding the
-      chunk data.  To fully decode each of these chunks, we also make
-      sure we have enough data in the buffer for the 4 byte CRC at the
-      end of every chunk (except IDAT, which is handled separately). */
+    * and the 4 byte chunk length before proceeding with decoding the
+    * chunk data.  To fully decode each of these chunks, we also make
+    * sure we have enough data in the buffer for the 4 byte CRC at the
+    * end of every chunk (except IDAT, which is handled separately).
+    */
   if (!(png_ptr->flags & PNG_FLAG_HAVE_CHUNK_HEADER))
   {
      png_byte chunk_length[4];
@@ -160,8 +162,9 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
   else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
   {
      /* If we reach an IDAT chunk, this means we have read all of the
-         header chunks, and we can start reading the image (or if this
-         is called after the image has been read - we have an error). */
+       * header chunks, and we can start reading the image (or if this
+       * is called after the image has been read - we have an error).
+       */
      if (png_ptr->mode & PNG_HAVE_IDAT)
      {
         if (png_ptr->push_length == 0)
@@ -227,6 +230,18 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
   }
 #endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+   else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
+   }
+#endif
 #if defined(PNG_READ_tRNS_SUPPORTED)
   else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
   {
@@ -451,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;
@@ -512,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;

@@ -529,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;

@@ -565,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)
@@ -604,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);

@@ -611,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);
@@ -746,7 +774,8 @@ 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++;
@@ -756,8 +785,10 @@ png_read_push_finish_row(png_structp png_ptr)
            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 +
@@ -778,24 +809,29 @@ 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 */

-   if (length > 65535L)  /* We can't hold the entire string in memory */
+   if (length > (png_uint_32)65535L) /* Can't hold the entire string in memory */
   {
      png_warning(png_ptr, "tEXt chunk too large to fit in memory");
-      png_ptr->skip_length = length - 65535L;
-      length = 65535L;
+      png_ptr->skip_length = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
   }
 #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;
 }

@@ -842,7 +878,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;
@@ -859,14 +895,18 @@ 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
    * to be able to store the uncompressed data.  Actually, the threshold
    * is probably around 32K, but it isn't as definite as 64K is.
    */
-   if (length > 65535L)
+   if (length > (png_uint_32)65535L)
   {
      png_warning(png_ptr, "zTXt chunk too large to fit in memory");
      png_push_crc_skip(png_ptr, length);
@@ -874,11 +914,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;
 }

@@ -940,7 +981,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;
@@ -963,8 +1004,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);
@@ -977,8 +1018,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,
@@ -1014,9 +1056,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;
@@ -1029,11 +1070,12 @@ 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
-   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
-   is (currently) silently ignored. */
+ * chunk.  In the future we will have code here which 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
+ * is (currently) silently ignored.
+ */
 void
 png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 {
@@ -1041,10 +1083,9 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 len

   if (!(png_ptr->chunk_name[0] & 0x20))
   {
-      char msg[40];
-
-      sprintf(msg, "Unknown critical chunk %s", png_ptr->chunk_name);
-      png_error(png_ptr, msg);
+      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);
--- a/pngread.c
+++ b/pngread.c
@@ -1,19 +1,23 @@

 /* pngread.c - read a PNG file
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This file contains routines that an application calls directly to
+ * read a PNG file or stream.
+ */

 #define PNG_INTERNAL
 #include "png.h"

 /* Create a PNG structure for reading, and allocate any memory needed. */
 png_structp
-png_create_read_struct(png_charp user_png_ver, png_voidp error_ptr,
+png_create_read_struct(png_const_charp user_png_ver, voidp error_ptr,
   png_error_ptr error_fn, png_error_ptr warn_fn)
 {
   png_structp png_ptr;
@@ -54,7 +58,8 @@ png_create_read_struct(png_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;
@@ -76,7 +81,6 @@ png_create_read_struct(png_charp user_png_ver, png_voidp error_ptr,
   return (png_ptr);
 }

-
 /* Initialize PNG structure for reading, and allocate any memory needed.
   This interface is depreciated in favour of the png_create_read_struct(),
   and it will eventually disappear. */
@@ -97,7 +101,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;
@@ -149,7 +154,7 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
      }
   }

-   while (1)
+   for(;;)
   {
      png_byte chunk_length[4];
      png_uint_32 length;
@@ -215,6 +220,10 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
      else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
         png_handle_sBIT(png_ptr, info_ptr, length);
 #endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+         png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
 #if defined(PNG_READ_tEXt_SUPPORTED)
      else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
         png_handle_tEXt(png_ptr, info_ptr, length);
@@ -247,10 +256,11 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
   png_read_transform_info(png_ptr, 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.
-   If the user doesn't call this, we will do it ourselves. */
+/* 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.
+ * If the user doesn't call this, we will do it ourselves.
+ */
 void
 png_start_read_image(png_structp png_ptr)
 {
@@ -399,14 +409,17 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
   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);
+   {
+      png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
+         (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
+   }

   png_read_filter_row(png_ptr, &(png_ptr->row_info),
      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);
@@ -436,26 +449,32 @@ 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
-   to contain the contents of the rows from the previous pass.  If
-   the 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
-   "chunky" progressive image, with finer detail added as it becomes
-   available.  If you do not want this "chunky" display, you may pass
-   NULL for display_row.  If you do not want the sparkle display, and
-   you have not called png_handle_alpha(), you may pass NULL for rows.
-   If you have called png_handle_alpha(), and the image has either an
-   alpha channel or a transparency chunk, you must provide a buffer for
-   rows.  In this case, you do not have to provide a display_row buffer
-   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. */
+ * 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
+ * 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
+ * "chunky" progressive image, with finer detail added as it becomes
+ * available.  If you do not want this "chunky" display, you may pass
+ * NULL for display_row.  If you do not want the sparkle display, and
+ * you have not called png_handle_alpha(), you may pass NULL for rows.
+ * If you have called png_handle_alpha(), and the image has either an
+ * alpha channel or a transparency chunk, you must provide a buffer for
+ * rows.  In this case, you do not have to provide a display_row buffer
+ * 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.
+ */

 void
 png_read_rows(png_structp png_ptr, png_bytepp row,
@@ -491,14 +510,15 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
 }

 /* 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
-   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
-   png_start_read_image() if png_set_interlace_handling() wasn't called
-   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 */
+ * 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
+ * png_start_read_image() if png_set_interlace_handling() wasn't called
+ * 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.
+ */
 void
 png_read_image(png_structp png_ptr, png_bytepp image)
 {
@@ -524,8 +544,9 @@ png_read_image(png_structp png_ptr, png_bytepp image)
 }

 /* Read the end of the PNG file.  Will not read past the end of the
-   file, will verify the end is accurate, and will read any comments
-   or time information at the end of the file, if info is not NULL. */
+ * file, will verify the end is accurate, and will read any comments
+ * or time information at the end of the file, if info is not NULL.
+ */
 void
 png_read_end(png_structp png_ptr, png_infop info_ptr)
 {
@@ -594,6 +615,10 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
      else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
         png_handle_sBIT(png_ptr, info_ptr, length);
 #endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+         png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
 #if defined(PNG_READ_tEXt_SUPPORTED)
      else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
         png_handle_tEXt(png_ptr, info_ptr, length);
@@ -638,12 +663,18 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,

   if (info_ptr != NULL)
   {
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
+      png_free(png_ptr, info_ptr->text);
+#endif
      png_destroy_struct((png_voidp)info_ptr);
      *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
      png_destroy_struct((png_voidp)end_info_ptr);
      *end_info_ptr_ptr = (png_infop)NULL;
   }
@@ -659,7 +690,6 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 void
 png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
 {
-   int i;
   jmp_buf tmp_jmp;
   png_error_ptr error_fn;
   png_error_ptr warning_fn;
@@ -688,7 +718,7 @@ 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);
+      png_zfree(png_ptr, png_ptr->palette);
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_bKGD_SUPPORTED)
   if (png_ptr->flags & PNG_FLAG_FREE_TRANS)
      png_free(png_ptr, png_ptr->trans);
@@ -700,6 +730,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
 #if defined(PNG_READ_GAMMA_SUPPORTED)
   if (png_ptr->gamma_16_table != NULL)
   {
+      int i;
      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
      {
         png_free(png_ptr, png_ptr->gamma_16_table[i]);
@@ -710,6 +741,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
   png_free(png_ptr, png_ptr->gamma_16_table);
   if (png_ptr->gamma_16_from_1 != NULL)
   {
+      int i;
      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
      {
         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
@@ -718,6 +750,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
   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++)
      {
         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
@@ -748,3 +781,9 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr

   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;
+}
--- a/pngrio.c
+++ b/pngrio.c
@@ -1,18 +1,20 @@

 /* pngrio.c - functions for data input
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-
-   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
-   function, but rather write a replacement function and then make
-   libpng use it at run time with png_set_read_fn(...) */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This file provides a location for all input.  Users which need
+ * special handling are expected to write a function which has the same
+ * arguments as this, and perform a similar function, but possibly has
+ * a different input method.  Note that you shouldn't change this
+ * function, but rather write a replacement function and then make
+ * libpng use it at run time with png_set_read_fn(...).
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -32,6 +34,7 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
      png_error(png_ptr, "Call to NULL read function");
 }

+#if !defined(PNG_NO_STDIO)
 /* This is the function which 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
@@ -96,12 +99,13 @@ 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");
   }
 }
 #endif
+#endif

 /* This function allows the application to supply a new input function
   for libpng if standard C streams aren't being used.
@@ -122,10 +126,14 @@ png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
 {
   png_ptr->io_ptr = io_ptr;

+#if !defined(PNG_NO_STDIO)
   if (read_data_fn != NULL)
      png_ptr->read_data_fn = read_data_fn;
   else
      png_ptr->read_data_fn = png_default_read_data;
+#else
+   png_ptr->read_data_fn = read_data_fn;
+#endif

   /* It is an error to write to a read device */
   png_ptr->write_data_fn = NULL;
--- a/pngrtran.c
+++ b/pngrtran.c
--- a/pngrutil.c
+++ b/pngrutil.c
@@ -1,12 +1,16 @@

 /* pngrutil.c - utilities to read a PNG file
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 0.99
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This file contains routines which are only called from within
+ * libpng itself during the course of reading an image.
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -23,7 +27,7 @@ png_get_uint_32(png_bytep buf)
      ((png_uint_32)(*(buf + 2)) << 8) +
      (png_uint_32)(*(buf + 3));

-   return i;
+   return (i);
 }

 #if defined(PNG_READ_pCAL_SUPPORTED)
@@ -40,7 +44,7 @@ png_get_int_32(png_bytep buf)
      ((png_int_32)(*(buf + 2)) << 8) +
      (png_int_32)(*(buf + 3));

-   return i;
+   return (i);
 }
 #endif /* PNG_READ_pCAL_SUPPORTED */

@@ -53,63 +57,10 @@ png_get_uint_16(png_bytep buf)
   i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
      (png_uint_16)(*(buf + 1)));

-   return i;
+   return (i);
 }
 #endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */

-/* Set the action on getting a CRC error for an ancillary or critical chunk. */
-void
-png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
-{
-   png_debug(1, "in png_set_crc_action\n");
-   /* Tell libpng how we react to CRC errors in critical chunks */
-   switch (crit_action)
-   {
-      case PNG_CRC_NO_CHANGE:                        /* leave setting as is */
-         break;
-      case PNG_CRC_WARN_USE:                               /* warn/use data */
-         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
-         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
-         break;
-      case PNG_CRC_QUIET_USE:                             /* quiet/use data */
-         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
-         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
-                           PNG_FLAG_CRC_CRITICAL_IGNORE;
-         break;
-      case PNG_CRC_WARN_DISCARD:    /* not a valid action for critical data */
-         png_warning(png_ptr, "Can't discard critical data on CRC error.");
-      case PNG_CRC_ERROR_QUIT:                                /* error/quit */
-      case PNG_CRC_DEFAULT:
-      default:
-         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
-         break;
-   }
-
-   switch (ancil_action)
-   {
-      case PNG_CRC_NO_CHANGE:                       /* leave setting as is */
-         break;
-      case PNG_CRC_WARN_USE:                              /* warn/use data */
-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
-         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
-         break;
-      case PNG_CRC_QUIET_USE:                            /* quiet/use data */
-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
-         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
-                           PNG_FLAG_CRC_ANCILLARY_NOWARN;
-         break;
-      case PNG_CRC_ERROR_QUIT:                               /* error/quit */
-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
-         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
-         break;
-      case PNG_CRC_WARN_DISCARD:                      /* warn/discard data */
-      case PNG_CRC_DEFAULT:
-      default:
-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
-         break;
-   }
-}
-
 /* Read data, and (optionally) run it through the CRC. */
 void
 png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
@@ -138,28 +89,24 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip)

   if (png_crc_error(png_ptr))
   {
-      char msg[80];
-
-      sprintf(msg,"CRC error in %s", png_ptr->chunk_name);
-
      if ((png_ptr->chunk_name[0] & 0x20 &&                /* Ancillary */
           !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
          (!(png_ptr->chunk_name[0] & 0x20) &&             /* Critical  */
           png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))
      {
-         png_warning(png_ptr, msg);
+         png_chunk_warning(png_ptr, "CRC error");
      }
      else
      {
-         png_error(png_ptr, msg);
+         png_chunk_error(png_ptr, "CRC error");
      }
-      return 1;
+      return (1);
   }

-   return 0;
+   return (0);
 }

-/* Compare the CRC stored in the PNG file with that calulated by libpng from
+/* Compare the CRC stored in the PNG file with that calculated by libpng from
   the data it has read thus far. */
 int
 png_crc_error(png_structp png_ptr)
@@ -185,14 +132,10 @@ png_crc_error(png_structp png_ptr)
   if (need_crc)
   {
      crc = png_get_uint_32(crc_bytes);
-#ifdef PNG_USE_OWN_CRC
-      return (((crc^0xffffffffL)&0xffffffffL) != (png_ptr->crc&0xffffffffL));
-#else
-      return (crc != png_ptr->crc);
-#endif
+      return ((int)(crc != png_ptr->crc));
   }
   else
-      return 0;
+      return (0);
 }


@@ -228,7 +171,8 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   interlace_type = buf[12];

   /* check for width and height valid values */
-   if (width == 0 || width > 2147483647 || height == 0 || height > 2147483647)
+   if (width == 0 || width > (png_uint_32)2147483647L || height == 0 ||
+        height > (png_uint_32)2147483647L)
      png_error(png_ptr, "Invalid image size in IHDR");

   /* check other values */
@@ -246,7 +190,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
         color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
      png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");

-   if (interlace_type > PNG_INTERLACE_ADAM7)
+   if (interlace_type >= PNG_INTERLACE_LAST)
      png_error(png_ptr, "Unknown interlace method in IHDR");

   if (compression_type != PNG_COMPRESSION_TYPE_BASE)
@@ -282,7 +226,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   /* set up other useful info */
   png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
-      png_ptr->channels);
+   png_ptr->channels);
   png_ptr->rowbytes = ((png_ptr->width *
      (png_uint_32)png_ptr->pixel_depth + 7) >> 3);
   png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth);
@@ -314,6 +258,20 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   png_ptr->mode |= PNG_HAVE_PLTE;

+#if defined (PNG_READ_tRNS_SUPPORTED)
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
+      {
+         if (png_ptr->num_trans > png_ptr->num_palette)
+         {
+            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
+            png_ptr->num_trans = png_ptr->num_palette;
+         }
+      }
+   }
+#endif
+
 #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
   {
@@ -337,7 +295,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   }

   num = (int)length / 3;
-   palette = (png_colorp)png_malloc(png_ptr, num * sizeof (png_color));
+   palette = (png_colorp)png_zalloc(png_ptr, (uInt)num, sizeof (png_color));
   png_ptr->flags |= PNG_FLAG_FREE_PALETTE;
   for (i = 0; i < num; i++)
   {
@@ -354,16 +312,15 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      whatever the normal CRC configuration tells us.  However, if we
      have an RGB image, the PLTE can be considered ancillary, so
      we will act as though it is. */
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+#endif
   {
      png_crc_finish(png_ptr, 0);
   }
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
   else if (png_crc_error(png_ptr))  /* Only if we have a CRC error */
   {
-      char msg[80];
-
-      sprintf(msg,"CRC error in %s", png_ptr->chunk_name);
-
      /* If we don't want to use the data from an ancillary chunk,
         we have two options: an error abort, or a warning and we
         ignore the data in this chunk (which should be OK, since
@@ -372,23 +329,23 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      {
         if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
         {
-            png_error(png_ptr, msg);
+            png_chunk_error(png_ptr, "CRC error");
         }
         else
         {
-            png_warning(png_ptr, msg);
+            png_chunk_warning(png_ptr, "CRC error");
            png_ptr->flags &= ~PNG_FLAG_FREE_PALETTE;
-            png_free(png_ptr, palette);
+            png_zfree(png_ptr, palette);
            return;
         }
      }
      /* Otherwise, we (optionally) emit a warning and use the chunk. */
      else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
      {
-         png_warning(png_ptr, msg);
+         png_chunk_warning(png_ptr, "CRC error");
      }
   }
-
+#endif
   png_ptr->palette = palette;
   png_ptr->num_palette = (png_uint_16)num;
   png_set_PLTE(png_ptr, info_ptr, palette, num);
@@ -402,6 +359,10 @@ png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
   {
      png_error(png_ptr, "No image in file");
+
+      /* to quiet compiler warnings about unused info_ptr */
+      if (info_ptr == NULL)
+         return;
   }

   png_ptr->mode |= PNG_AFTER_IDAT | PNG_HAVE_IEND;
@@ -434,7 +395,12 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   else if (png_ptr->mode & PNG_HAVE_PLTE)
      /* Should be an error, but we can cope with it */
      png_warning(png_ptr, "Out of place gAMA chunk");
-   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_gAMA)
+
+   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_gAMA
+#if defined(PNG_READ_sRGB_SUPPORTED)
+      && !(info_ptr->valid & PNG_INFO_sRGB)
+#endif
+      )
   {
      png_warning(png_ptr, "Duplicate gAMA chunk");
      png_crc_finish(png_ptr, length);
@@ -457,8 +423,23 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   if (igamma == 0)
      return;

+#if defined(PNG_READ_sRGB_SUPPORTED)
+   if (info_ptr->valid & PNG_INFO_sRGB)
+      if(igamma != (png_uint_32)45000L)
+      {
+         png_warning(png_ptr,
+           "Ignoring incorrect gAMA value when sRGB is also present");
+#ifndef PNG_NO_STDIO
+         fprintf(stderr, "igamma = %lu\n", igamma);
+#endif
+         return;
+      }
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
   file_gamma = (float)igamma / (float)100000.0;
+#ifdef PNG_READ_GAMMA_SUPPORTED
   png_ptr->gamma = file_gamma;
+#endif
   png_set_gAMA(png_ptr, info_ptr, file_gamma);
 }
 #endif
@@ -483,8 +464,10 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      return;
   }
   else if (png_ptr->mode & PNG_HAVE_PLTE)
+   {
      /* Should be an error, but we can cope with it */
      png_warning(png_ptr, "Out of place sBIT chunk");
+   }
   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sBIT)
   {
      png_warning(png_ptr, "Duplicate sBIT chunk");
@@ -545,7 +528,12 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   else if (png_ptr->mode & PNG_HAVE_PLTE)
      /* Should be an error, but we can cope with it */
      png_warning(png_ptr, "Missing PLTE before cHRM");
-   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_cHRM)
+
+   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_cHRM
+#if defined(PNG_READ_sRGB_SUPPORTED)
+      && !(info_ptr->valid & PNG_INFO_sRGB)
+#endif
+      )
   {
      png_warning(png_ptr, "Duplicate cHRM chunk");
      png_crc_finish(png_ptr, length);
@@ -615,8 +603,8 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   val = png_get_uint_32(buf);
   blue_y = (float)val / (float)100000.0;

-   if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 ||
-       blue_x + blue_y > 1.0)
+   if (blue_x < (float)0 || blue_x > (float)0.8 || blue_y < (float)0 ||
+       blue_y > (float)0.8 || blue_x + blue_y > (float)1.0)
   {
      png_warning(png_ptr, "Invalid cHRM blue point");
      png_crc_finish(png_ptr, 0);
@@ -626,11 +614,116 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   if (png_crc_finish(png_ptr, 0))
      return;

+#if defined(PNG_READ_sRGB_SUPPORTED)
+   if (info_ptr->valid & PNG_INFO_sRGB)
+      {
+      if (fabs(white_x - (float).3127) > (float).001 ||
+          fabs(white_y - (float).3290) > (float).001 ||
+          fabs(  red_x - (float).6400) > (float).001 ||
+          fabs(  red_y - (float).3300) > (float).001 ||
+          fabs(green_x - (float).3000) > (float).001 ||
+          fabs(green_y - (float).6000) > (float).001 ||
+          fabs( blue_x - (float).1500) > (float).001 ||
+          fabs( blue_y - (float).0600) > (float).001)
+         {
+
+            png_warning(png_ptr,
+              "Ignoring incorrect cHRM value when sRGB is also present");
+#ifndef PNG_NO_STDIO
+            fprintf(stderr,"wx=%f, wy=%f, rx=%f, ry=%f\n",
+               white_x, white_y, red_x, red_y);
+            fprintf(stderr,"gx=%f, gy=%f, bx=%f, by=%f\n",
+               green_x, green_y, blue_x, blue_y);
+#endif
+         }
+         return;
+      }
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
   png_set_cHRM(png_ptr, info_ptr,
      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
 }
 #endif

+#if defined(PNG_READ_sRGB_SUPPORTED)
+void
+png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   int intent;
+   png_byte buf[1];
+
+   png_debug(1, "in png_handle_sRGB\n");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sRGB");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid sRGB after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place sRGB chunk");
+
+   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sRGB)
+   {
+      png_warning(png_ptr, "Duplicate sRGB chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (length != 1)
+   {
+      png_warning(png_ptr, "Incorrect sRGB chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 1);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   intent = buf[0];
+   /* check for bad intent */
+   if (intent >= PNG_sRGB_INTENT_LAST)
+   {
+      png_warning(png_ptr, "Unknown sRGB intent");
+      return;
+   }
+
+#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
+   if ((info_ptr->valid & PNG_INFO_gAMA))
+      if((png_uint_32)(png_ptr->gamma*(float)100000.+.5) != (png_uint_32)45000L)
+      {
+         png_warning(png_ptr,
+           "Ignoring incorrect gAMA value when sRGB is also present");
+#ifndef PNG_NO_STDIO
+           fprintf(stderr,"gamma=%f\n",png_ptr->gamma);
+#endif
+      }
+#endif /* PNG_READ_gAMA_SUPPORTED */
+
+#ifdef PNG_READ_cHRM_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_cHRM)
+      if (fabs(info_ptr->x_white - (float).3127) > (float).001 ||
+          fabs(info_ptr->y_white - (float).3290) > (float).001 ||
+          fabs(  info_ptr->x_red - (float).6400) > (float).001 ||
+          fabs(  info_ptr->y_red - (float).3300) > (float).001 ||
+          fabs(info_ptr->x_green - (float).3000) > (float).001 ||
+          fabs(info_ptr->y_green - (float).6000) > (float).001 ||
+          fabs( info_ptr->x_blue - (float).1500) > (float).001 ||
+          fabs( info_ptr->y_blue - (float).0600) > (float).001)
+         {
+            png_warning(png_ptr,
+              "Ignoring incorrect cHRM value when sRGB is also present");
+         }
+#endif /* PNG_READ_cHRM_SUPPORTED */
+
+   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
+}
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
 #if defined(PNG_READ_tRNS_SUPPORTED)
 void
 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
@@ -647,7 +740,7 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   }
   else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
   {
-      png_warning(png_ptr, "Duplcate tRNS chunk");
+      png_warning(png_ptr, "Duplicate tRNS chunk");
      png_crc_finish(png_ptr, length);
      return;
   }
@@ -683,7 +776,7 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      }

      png_crc_read(png_ptr, buf, (png_size_t)length);
-      png_ptr->num_trans = 3;
+      png_ptr->num_trans = 1;
      png_ptr->trans_values.red = png_get_uint_16(buf);
      png_ptr->trans_values.green = png_get_uint_16(buf + 2);
      png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
@@ -834,7 +927,7 @@ png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   num = (int)length / 2;
   png_ptr->hist = (png_uint_16p)png_malloc(png_ptr,
-      num * sizeof (png_uint_16));
+      (png_uint_32)(num * sizeof (png_uint_16)));
   png_ptr->flags |= PNG_FLAG_FREE_HIST;
   for (i = 0; i < num; i++)
   {
@@ -947,6 +1040,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_byte type, nparams;
   png_charp buf, units, endptr;
   png_charpp params;
+   png_size_t slength;
   int i;

   png_debug(1, "in png_handle_pCAL\n");
@@ -969,7 +1063,8 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_debug1(2, "Allocating and reading pCAL chunk data (%d bytes)\n",
      length + 1);
   purpose = (png_charp)png_malloc(png_ptr, length + 1);
-   png_crc_read(png_ptr, (png_bytep)purpose, (png_size_t)length);
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)purpose, slength);

   if (png_crc_finish(png_ptr, 0))
   {
@@ -977,13 +1072,13 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      return;
   }

-   purpose[length] = '\0'; /* null terminate the last string */
+   purpose[slength] = 0x00; /* null terminate the last string */

   png_debug(3, "Finding end of pCAL purpose string\n");
   for (buf = purpose; *buf != '\0'; buf++)
      /* empty loop */;

-   endptr = purpose + length;
+   endptr = purpose + slength;

   /* We need to have at least 12 bytes after the purpose string
      in order to get the parameter information. */
@@ -1019,19 +1114,20 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   }

   /* Empty loop to move past the units string. */
-   for (buf = units; *buf != '\0'; buf++);
+   for (buf = units; *buf != 0x00; buf++);

   png_debug(3, "Allocating pCAL parameters array\n");
-   params = (png_charpp)png_malloc(png_ptr, nparams*sizeof(png_charp)) ;
+   params = (png_charpp)png_malloc(png_ptr, (png_uint_32)(nparams
+      *sizeof(png_charp))) ;

   /* Get pointers to the start of each parameter string. */
-   for (i = 0; i < nparams; i++)
+   for (i = 0; i < (int)nparams; i++)
   {
      buf++; /* Skip the null string terminator from previous parameter. */

      png_debug1(3, "Reading pCAL parameter %d\n", i);
      /* Empty loop to move past each paramter string */
-      for (params[i] = buf; *buf != '\0' && buf <= endptr; buf++);
+      for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++);

      /* Make sure we haven't run out of data yet */
      if (buf > endptr)
@@ -1103,6 +1199,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_charp key;
   png_charp text;
   png_uint_32 skip = 0;
+   png_size_t slength;

   png_debug(1, "in png_handle_tEXt\n");

@@ -1113,16 +1210,17 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      png_ptr->mode |= PNG_AFTER_IDAT;

 #ifdef PNG_MAX_MALLOC_64K
-   if (length > 65535L)
+   if (length > (png_uint_32)65535L)
   {
      png_warning(png_ptr, "tEXt chunk too large to fit in memory");
-      skip = length - 65535L;
-      length = 65535L;
+      skip = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
   }
 #endif

   key = (png_charp)png_malloc(png_ptr, length + 1);
-   png_crc_read(png_ptr, (png_bytep)key, (png_size_t)length);
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)key, slength);

   if (png_crc_finish(png_ptr, skip))
   {
@@ -1130,15 +1228,15 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      return;
   }

-   key[length] = '\0';
+   key[slength] = 0x00;

   for (text = key; *text; text++)
      /* empty loop to find end of key */ ;

-   if (text != key + (png_size_t)length)
+   if (text != key + slength)
      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;
@@ -1159,6 +1257,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_charp key;
   png_charp text;
   int comp_type = PNG_TEXT_COMPRESSION_NONE;
+   png_size_t slength;

   png_debug(1, "in png_handle_zTXt\n");

@@ -1171,7 +1270,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #ifdef PNG_MAX_MALLOC_64K
   /* We will no doubt have problems with chunks even half this size, but
      there is no hard and fast rule to tell us where to stop. */
-   if (length > 65535L)
+   if (length > (png_uint_32)65535L)
   {
     png_warning(png_ptr,"zTXt chunk too large to fit in memory");
     png_crc_finish(png_ptr, length);
@@ -1180,20 +1279,21 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #endif

   key = (png_charp)png_malloc(png_ptr, length + 1);
-   png_crc_read(png_ptr, (png_bytep)key, (png_size_t)length);
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)key, slength);
   if (png_crc_finish(png_ptr, 0))
   {
      png_free(png_ptr, key);
      return;
   }

-   key[length] = '\0';
+   key[slength] = 0x00;

   for (text = key; *text; text++)
      /* empty loop */ ;

   /* zTXt must have some text after the keyword */
-   if (text == key + (png_size_t)length)
+   if (text == key + slength)
   {
      png_warning(png_ptr, "Zero length zTXt chunk");
   }
@@ -1205,9 +1305,9 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      png_ptr->zstream.next_in = (png_bytep)text;
      png_ptr->zstream.avail_in = (uInt)(length - (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;
+      key_size = (png_size_t)(text - key);
      text_size = 0;
      text = NULL;

@@ -1228,14 +1328,14 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
            if (text ==  NULL)
            {
               text_size = key_size + sizeof(msg) + 1;
-               text = (png_charp)png_malloc(png_ptr, text_size);
+               text = (png_charp)png_malloc(png_ptr, (png_uint_32)text_size);
               png_memcpy(text, key, key_size);
            }

-            text[text_size - 1] = '\0';
+            text[text_size - 1] = 0x00;

            /* Copy what we can of the error message into the text chunk */
-            text_size = length - (text - key) - 1;
+            text_size = (png_size_t)(slength - (text - key) - 1);
            text_size = sizeof(msg) > text_size ? text_size : sizeof(msg);
            png_memcpy(text + key_size, msg, text_size + 1);
            break;
@@ -1245,28 +1345,28 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
            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);
               text_size = key_size + png_ptr->zbuf_size -
                  png_ptr->zstream.avail_out;
-               *(text + text_size) = '\0';
+               *(text + text_size) = 0x00;
            }
            else
            {
               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, (png_uint_32)(text_size +
+                  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,
                  (png_ptr->zbuf_size - png_ptr->zstream.avail_out));
               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
-               *(text + text_size) = '\0';
+               *(text + text_size) = 0x00;
            }
            if (ret != Z_STREAM_END)
            {
@@ -1286,23 +1386,26 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      png_free(png_ptr, key);
      key = text;
      text += key_size;
-      text_size -= key_size;
   }
   else /* if (comp_type >= PNG_TEXT_COMPRESSION_LAST) */
   {
      png_size_t text_size;
+#if !defined(PNG_NO_STDIO)
      char umsg[50];

      sprintf(umsg, "Unknown zTXt compression type %d", comp_type);
      png_warning(png_ptr, umsg);
+#else
+      png_warning(png_ptr, "Unknown zTXt compression type");
+#endif

      /* Copy what we can of the error message into the text chunk */
-      text_size = (png_size_t)length - (text - key) - 1;
+      text_size = (png_size_t)(slength - (text - key) - 1);
      text_size = sizeof(msg) > text_size ? text_size : sizeof(msg);
      png_memcpy(text, msg, text_size + 1);
   }

-   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 = comp_type;
   text_ptr->key = key;
   text_ptr->text = text;
@@ -1329,16 +1432,18 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   if (!(png_ptr->chunk_name[0] & 0x20))
   {
-      char msg[40];
+      png_chunk_error(png_ptr, "unknown critical chunk");

-      sprintf(msg, "Unknown critical chunk %s", png_ptr->chunk_name);
-      png_error(png_ptr, msg);
+      /* to quiet compiler warnings about unused info_ptr */
+      if (info_ptr == NULL)
+         return;
   }

   if (png_ptr->mode & PNG_HAVE_IDAT)
      png_ptr->mode |= PNG_AFTER_IDAT;

   png_crc_finish(png_ptr, length);
+
 }

 /* This function is called to verify that a chunk name is valid.
@@ -1356,11 +1461,7 @@ png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
   if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||
       isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))
   {
-      char msg[45];
-
-      sprintf(msg, "Invalid chunk type 0x%02X 0x%02X 0x%02X 0x%02X",
-         chunk_name[0], chunk_name[1], chunk_name[2], chunk_name[3]);
-      png_error(png_ptr, msg);
+      png_chunk_error(png_ptr, "invalid chunk type");
   }
 }

@@ -1662,13 +1763,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
            int s_start, s_end, s_inc;
            png_uint_32 i;

-            sp = row + (png_size_t)((row_info->width - 1) >> 2);
-            dp = row + (png_size_t)((final_width - 1) >> 2);
+            sp = row + (png_uint_32)((row_info->width - 1) >> 2);
+            dp = row + (png_uint_32)((final_width - 1) >> 2);
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
            if (transformations & PNG_PACKSWAP)
            {
-               sshift = (png_size_t)(((row_info->width + 3) & 3) << 1);
-               dshift = (png_size_t)(((final_width + 3) & 3) << 1);
+               sshift = (int)(((row_info->width + 3) & 3) << 1);
+               dshift = (int)(((final_width + 3) & 3) << 1);
               s_start = 6;
               s_end = 0;
               s_inc = -2;
@@ -1676,8 +1777,8 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
            else
 #endif
            {
-               sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);
-               dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);
+               sshift = (int)((3 - ((row_info->width + 3) & 3)) << 1);
+               dshift = (int)((3 - ((final_width + 3) & 3)) << 1);
               s_start = 0;
               s_end = 6;
               s_inc = 2;
@@ -1723,8 +1824,8 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
            if (transformations & PNG_PACKSWAP)
            {
-               sshift = (png_size_t)(((row_info->width + 1) & 1) << 2);
-               dshift = (png_size_t)(((final_width + 1) & 1) << 2);
+               sshift = (int)(((row_info->width + 1) & 1) << 2);
+               dshift = (int)(((final_width + 1) & 1) << 2);
               s_start = 4;
               s_end = 0;
               s_inc = -4;
@@ -1732,8 +1833,8 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
            else
 #endif
            {
-               sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);
-               dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);
+               sshift = (int)((1 - ((row_info->width + 1) & 1)) << 2);
+               dshift = (int)((1 - ((final_width + 1) & 1)) << 2);
               s_start = 0;
               s_end = 4;
               s_inc = 4;
@@ -1775,8 +1876,8 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,

            pixel_bytes = (row_info->pixel_depth >> 3);

-            sp = row + (row_info->width - 1) * pixel_bytes;
-            dp = row + (final_width - 1) * pixel_bytes;
+            sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
+            dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
            for (i = row_info->width; i; i--)
            {
               png_byte v[8];
@@ -1807,6 +1908,7 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
   png_debug(1, "in png_read_filter_row\n");
   png_debug2(2,"row = %d, filter = %d\n", png_ptr->row_number, filter);

+
   switch (filter)
   {
      case PNG_FILTER_VALUE_NONE:
@@ -1920,7 +2022,7 @@ png_read_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++;
@@ -1930,8 +2032,9 @@ png_read_finish_row(png_structp png_ptr)
            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;
+            png_ptr->irowbytes = ((png_ptr->iwidth *
+               (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1;
+
         if (!(png_ptr->transformations & PNG_INTERLACE))
         {
            png_ptr->num_rows = (png_ptr->height +
@@ -1956,7 +2059,7 @@ png_read_finish_row(png_structp png_ptr)

      png_ptr->zstream.next_out = (Byte *)&extra;
      png_ptr->zstream.avail_out = (uInt)1;
-      do
+      for(;;)
      {
         if (!(png_ptr->zstream.avail_in))
         {
@@ -1999,7 +2102,7 @@ png_read_finish_row(png_structp png_ptr)
         if (!(png_ptr->zstream.avail_out))
            png_error(png_ptr, "Extra compressed data");

-      } while (1);
+      }
      png_ptr->zstream.avail_out = 0;
   }

@@ -2032,8 +2135,12 @@ png_read_start_row(png_structp png_ptr)
         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;
+
+         rowbytes = ((png_ptr->iwidth *
+            (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1;
+         png_ptr->irowbytes = (png_size_t)rowbytes;
+         if((png_uint_32)png_ptr->irowbytes != rowbytes)
+            png_error(png_ptr, "Rowbytes overflow in png_read_start_row");
   }
   else
   {
@@ -2113,18 +2220,19 @@ png_read_start_row(png_structp png_ptr)
   rowbytes = ((rowbytes * (png_uint_32)max_pixel_depth + 7) >> 3) +
      1 + ((max_pixel_depth + 7) >> 3);
 #ifdef PNG_MAX_MALLOC_64K
-   if (rowbytes > 65536L)
+   if (rowbytes > (png_uint_32)65536L)
      png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, rowbytes);

 #ifdef PNG_MAX_MALLOC_64K
-   if (png_ptr->rowbytes + 1 > 65536L)
+   if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)
      png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
-   png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
+   png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
+      png_ptr->rowbytes + 1));

-   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);

   png_debug1(3, "width = %d,\n", png_ptr->width);
   png_debug1(3, "height = %d,\n", png_ptr->height);
--- a/pngset.c
+++ b/pngset.c
@@ -1,12 +1,18 @@

 /* pngset.c - storage of image information into info struct
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * The functions here are used during reads to store data from the file
+ * into the info struct, and during writes to store application data
+ * into the info struct for writing into the file.  This abstracts the
+ * info struct and allows us to change the structure in the future.
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -16,7 +22,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));
@@ -31,7 +37,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;
@@ -51,7 +57,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;
@@ -64,7 +70,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;
@@ -78,8 +84,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;
@@ -98,7 +105,16 @@ 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;
+   info_ptr->rowbytes = info_ptr->width * rowbytes_per_pixel;
+   if (( width > (png_uint_32)2147483647L/rowbytes_per_pixel))
+   {
+      png_warning(png_ptr,
+         "Width too large to process image data; rowbytes will overflow.");
+      info_ptr->rowbytes = (png_size_t)0;
+   }
 }

 #if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
@@ -107,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;
@@ -123,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;
@@ -144,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++)
@@ -155,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;
@@ -168,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;
@@ -183,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;
@@ -197,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));
@@ -205,8 +221,57 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
 }
 #endif

-#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) || \
-    defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
+#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
+void
+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
+{
+   png_debug1(1, "in %s storage function\n", "sRGB");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   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,
+   int intent)
+{
+#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
+   float file_gamma;
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
+   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 (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;
+   png_set_gAMA(png_ptr, info_ptr, file_gamma);
+#endif
+
+#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
+   white_x = (float).3127;
+   white_y = (float).3290;
+   red_x   = (float).64;
+   red_y   = (float).33;
+   green_x = (float).30;
+   green_y = (float).60;
+   blue_x  = (float).15;
+   blue_y  = (float).06;
+
+   png_set_cHRM(png_ptr, info_ptr,
+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+
+#endif
+}
+#endif
+
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
+    defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
 void
 png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
   int num_text)
@@ -214,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
@@ -233,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
@@ -242,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);
@@ -253,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')
      {
@@ -278,7 +344,7 @@ 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)
      return;

   png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time));
@@ -292,7 +358,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)
@@ -304,6 +370,8 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
   {
      png_memcpy(&(info_ptr->trans_values), trans_values,
         sizeof(png_color_16));
+      if (num_trans == 0)
+        num_trans = 1;
   }
   info_ptr->num_trans = (png_uint_16)num_trans;
   info_ptr->valid |= PNG_INFO_tRNS;
--- a/pngtest.c
+++ b/pngtest.c
@@ -1,12 +1,31 @@

 /* pngtest.c - a simple test program to test libpng
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This program reads in a PNG image, writes it out again, and then
+ * compares the two files.  If the files are identical, this shows that
+ * the basic chunk handling, filtering, and (de)compression code is working
+ * properly.  It does not currently test all of the transforms, although
+ * it probably should.
+ *
+ * The program will 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.
+ * 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"
+ * to see what the differences between the two images are.
+ *
+ * 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.
+ */

 #include <stdio.h>
 #include <stdlib.h>
@@ -18,6 +37,8 @@

 #include "png.h"

+int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
+
 #ifdef __TURBOC__
 #include <mem.h>
 #endif
@@ -26,21 +47,418 @@
 /*  #define STDERR stderr  */
 #define STDERR stdout   /* for DOS */

-/* input and output filenames */
-#ifdef RISCOS
-char *inname = "pngtest_png";
-char *outname = "pngout_png";
+/* 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 > 0x3fffffffL) return;
+    if(status_pass != pass)
+    {
+       fprintf(stdout,"\n Pass %d: ",pass);
+       status_pass = pass;
+       status_dots = 30;
+    }
+    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 > 0x3fffffffL || pass > 7) return;
+    fprintf(stdout, "w");
+}
+
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+/* example of using user transform callback (we don't transform anything,
+   but merely count the black pixels) */
+
+static png_uint_32 black_pixels;
+
+void
+count_black_pixels(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 black pixels (or zero pixels if color_type is 3 */
+
+    if(row_info->color_type == 0 || row_info->color_type == 3)
+    {
+       int pos=0;
+       png_uint_32 n;
+       for (n=0; n<row_info->width; n++)
+       {
+          if(row_info->bit_depth == 1)
+             if(((*dp << pos++ )& 0x80) == 0) black_pixels++;
+             if(pos == 8)
+             {
+                pos=0;
+                dp++;
+             }
+          if(row_info->bit_depth == 2)
+             if(((*dp << (pos+=2))& 0xc0) == 0) black_pixels++;
+             if(pos == 8)
+             {
+                pos=0;
+                dp++;
+             }
+          if(row_info->bit_depth == 4)
+             if(((*dp << (pos+=4))& 0xf0) == 0) black_pixels++;
+             if(pos == 8)
+             {
+                pos=0;
+                dp++;
+             }
+          if(row_info->bit_depth == 8)
+             if(*dp++ == 0) black_pixels++;
+          if(row_info->bit_depth == 16)
+          {
+             if((*dp | *(dp+1)) == 0) black_pixels++;
+             dp+=2;
+          }
+       }
+    }
+    else /* other color types */
+    {
+       png_uint_32 n;
+       int channel;
+       int color_channels = row_info->channels;
+       if(row_info->color_type > 3)color_channels--;
+
+       for (n=0; n<row_info->width; n++)
+       {
+          for (channel = 0; channel < color_channels; channel++)
+          {
+             if(row_info->bit_depth == 8)
+                if(*dp++ == 0) black_pixels++;
+             if(row_info->bit_depth == 16)
+             {
+                if((*dp | *(dp+1)) == 0) black_pixels++;
+                dp+=2;
+             }
+          }
+          if(row_info->color_type > 3)
+          {
+             dp++;
+             if(row_info->bit_depth == 16)dp++;
+          }
+       }
+    }
+}
+#endif /* PNG_READ|WRITE_USER_TRANSFORM_SUPPORTED */
+
+static int verbose = 0;
+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. */
+/* This is the function which 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. */
+#ifndef USE_FAR_KEYWORD
+static void
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+
+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+    * instead of an int, which is what fread() actually returns.
+    */
+   check = (png_size_t)fread(data, (png_size_t)1, length,
+      (FILE *)png_ptr->io_ptr);
+
+   if (check != length)
+   {
+      png_error(png_ptr, "Read Error");
+   }
+}
 #else
-char *inname = "pngtest.png";
-char *outname = "pngout.png";
+/* this is the model-independent version. Since the standard I/O library
+   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)
+{
+   int check;
+   png_byte *n_data;
+   FILE *io_ptr;
+
+   /* Check if data really is near. If so, use usual code. */
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (FILE *)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)n_data == data)
+   {
+      check = fread(n_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+         err = fread(buf, (png_size_t)1, read, io_ptr);
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+         if(err != read)
+            break;
+         else
+            check += err;
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+   {
+      png_error(png_ptr, "read Error");
+   }
+}
+#endif /* USE_FAR_KEYWORD */
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+static void
+png_default_flush(png_structp png_ptr)
+{
+   FILE *io_ptr;
+   io_ptr = (FILE *)CVT_PTR((png_ptr->io_ptr));
+   if (io_ptr != NULL)
+      fflush(io_ptr);
+}
 #endif

-char inbuf[256], outbuf[256];
-
-int
-main(int argc, char *argv[])
+/* This is the function which 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. */
+#ifndef USE_FAR_KEYWORD
+static void
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
-   FILE *fpin, *fpout;
+   png_uint_32 check;
+
+   check = fwrite(data, 1, length, (FILE *)(png_ptr->io_ptr));
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+   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_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_uint_32 check;
+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
+   FILE *io_ptr;
+
+   /* Check if data really is near. If so, use usual code. */
+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (FILE *)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)near_data == data)
+   {
+      check = fwrite(near_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t written, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         written = MIN(NEAR_BUF_SIZE, remaining);
+         png_memcpy(buf, data, written); /* copy far buffer to near buffer */
+         err = fwrite(buf, 1, written, io_ptr);
+         if (err != written)
+            break;
+         else
+            check += err;
+         data += written;
+         remaining -= written;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+
+#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
+ * here if you don't want 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)
+{
+   PNG_CONST char *name = "UNKNOWN (ERROR!)";
+   if (png_ptr != NULL && png_ptr->error_ptr != NULL)
+      name = png_ptr->error_ptr;
+   fprintf(STDERR, "%s: libpng warning: %s\n", name, message);
+}
+
+/* This is the default error handling function.  Note that replacements for
+ * this function MUST NOT RETURN, or the program will likely crash.  This
+ * function is used by default, or if the program supplies NULL for the
+ * error function pointer in png_set_error_fn().
+ */
+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. */
+}
+#endif /* PNG_NO_STDIO */
+/* END of code to validate stdio-free compilation */
+
+/* START of code to validate memory allocation and deallocation */
+#ifdef PNGTEST_MEMORY_DEBUG
+/* Borland DOS special memory handler */
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+ERROR - memory debugging is not supported on this platform
+#else
+
+/* 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_malloc(png_structp png_ptr, png_uint_32 size) {
+   if (png_ptr == NULL) {
+      fprintf(STDERR, "NULL pointer to memory allocator\n");
+      return (NULL);
+   }
+   if (size == 0)
+      return (png_voidp)(NULL);
+
+   /* This calls the library allocator twice, once to get the requested
+      buffer and once to get a new free list entry. */
+   {
+      memory_infop pinfo = png_debug_malloc(png_ptr, sizeof *pinfo);
+      pinfo->size = size;
+      current_allocation += size;
+      if (current_allocation > maximum_allocation)
+         maximum_allocation = current_allocation;
+      pinfo->pointer = png_debug_malloc(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_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL)
+      fprintf(STDERR, "NULL pointer to memory allocator\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 which is to be freed. */
+            memset(ptr, 0x55, pinfo->size);
+            png_debug_free(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_debug_free(png_ptr, ptr);
+}
+#endif /* Not Borland DOS special memory handler */
+#endif
+/* 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;
@@ -51,51 +469,40 @@ main(int argc, char *argv[])
 #ifdef USE_FAR_KEYWORD
   jmp_buf jmpbuf;
 #endif   
+   
+   char inbuf[256], outbuf[256];
+
   row_buf = (png_bytep)NULL;

-   fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
-
-   if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
-   {
-      fprintf(STDERR,
-         "Warning: versions are different between png.h and png.c\n");
-      fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);
-      fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);
-   }
-
-   if (argc > 1)
-     inname = argv[1];
-
-   if (argc > 2)
-     outname = argv[2];
-
-   if (argc > 3)
-   {
-     fprintf(stderr, "usage: %s [infile.png] [outfile.png]\n", argv[0]);
-     exit(1);
-   }
-
   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");
   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
   write_ptr = png_create_write_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(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);

   png_debug(0, "Setting jmpbuf for read struct\n");
@@ -105,12 +512,12 @@ main(int argc, char *argv[])
   if (setjmp(read_ptr->jmpbuf))
 #endif
   {
-      fprintf(STDERR, "libpng read error\n");
+      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
      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);
-      return 1;
+      return (1);
   }

   png_debug(0, "Setting jmpbuf for write struct\n");
@@ -121,20 +528,46 @@ main(int argc, char *argv[])
   if (setjmp(write_ptr->jmpbuf))
 #endif
   {
-      fprintf(STDERR, "libpng write error\n");
+      fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
      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);
-      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);
   png_init_io(write_ptr, fpout);
+#else
+   png_set_read_fn(read_ptr, (png_voidp)fpin, png_default_read_data);
+   png_set_write_fn(write_ptr, (png_voidp)fpout,  png_default_write_data,
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+      png_default_flush);
+#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) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+   black_pixels=0;
+   png_set_write_user_transform_fn(write_ptr, count_black_pixels);
+#endif

   png_debug(0, "Reading info struct\n");
   png_read_info(read_ptr, read_info_ptr);
@@ -147,7 +580,11 @@ main(int argc, char *argv[])
          &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)
@@ -182,6 +619,16 @@ main(int argc, char *argv[])
      }
   }
 #endif
+#if defined(PNG_READ_sRGB_SUPPORTED) && defined(PNG_WRITE_sRGB_SUPPORTED)
+   {
+      int intent;
+
+      if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
+      {
+         png_set_sRGB(write_ptr, write_info_ptr, intent);
+      }
+   }
+#endif
 #if defined(PNG_READ_hIST_SUPPORTED) && defined(PNG_WRITE_hIST_SUPPORTED)
   {
      png_uint_16p hist;
@@ -289,6 +736,7 @@ main(int argc, char *argv[])
   png_debug(0, "\nWriting info struct\n");
   png_write_info(write_ptr, write_info_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)
@@ -298,14 +746,16 @@ main(int argc, char *argv[])
      png_destroy_write_struct(&write_ptr, &write_info_ptr);
      fclose(fpin);
      fclose(fpout);
-      return 1;
+      return (1);
   }
+   png_debug(0, "Writing row data\n");

   num_pass = png_set_interlace_handling(read_ptr);
   png_set_interlace_handling(write_ptr);

   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);
@@ -316,31 +766,41 @@ main(int argc, char *argv[])
   png_debug(0, "Reading and writing end_info data\n");
   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;

@@ -351,9 +811,20 @@ main(int argc, char *argv[])
      {
         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)
@@ -362,16 +833,208 @@ main(int argc, char *argv[])
      if (png_memcmp(inbuf, outbuf, num_in))
      {
         fprintf(STDERR, "Files %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);
-   fprintf(STDERR, "libpng passes test\n");

-   return 0;
+   return (0);
 }

+/* input and output filenames */
+#ifdef RISCOS
+PNG_CONST char *inname = "pngtest/png";
+PNG_CONST char *outname = "pngout/png";
+#else
+static PNG_CONST char *inname = "pngtest.png";
+static PNG_CONST char *outname = "pngout.png";
+#endif
+
+int
+main(int argc, char *argv[])
+{
+   int multiple = 0;
+   int ierror = 0;
+
+   fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
+   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);
+
+   /* 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))
+   {
+      fprintf(STDERR,
+         "Warning: versions are different between png.h and png.c\n");
+      fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);
+      fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);
+      ++ierror;
+   }
+
+   if (argc > 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+verbose)
+     outname = argv[2+verbose];
+
+   if ((!multiple && argc > 3+verbose) || (multiple && argc < 2))
+   {
+     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);
+     exit(1);
+   }
+
+   if (multiple)
+   {
+      int i;
+#ifdef PNGTEST_MEMORY_DEBUG
+      int allocation_now = current_allocation;
+#endif
+      for (i=2; i<argc; ++i)
+      {
+         int kerror;
+         fprintf(STDERR, "Testing %s:",argv[i]);
+         kerror = test_one_file(argv[i], outname);
+         if (kerror == 0) 
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+            fprintf(STDERR, " PASS (%lu black pixels)\n",black_pixels);
+#else
+            fprintf(STDERR, " PASS\n");
+#endif
+         else {
+            fprintf(STDERR, " FAIL\n");
+            ierror += kerror;
+            }
+#ifdef PNGTEST_MEMORY_DEBUG
+         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 PNGTEST_MEMORY_DEBUG
+         fprintf(STDERR, "Maximum memory allocation: %d bytes\n",
+            maximum_allocation);
+#endif
+   }
+   else
+   {
+      int i;
+      for (i=0; i<3; ++i) {
+         int kerror;
+#ifdef PNGTEST_MEMORY_DEBUG
+         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)
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+                fprintf(STDERR, " PASS (%lu black pixels)\n",black_pixels);
+#else
+                fprintf(STDERR, " PASS\n");
+#endif
+         }
+         else
+         {
+            if(verbose == 0 && i != 2)
+               fprintf(STDERR, "Testing %s:",inname);
+            fprintf(STDERR, " FAIL\n");
+            ierror += kerror;
+         }
+#ifdef PNGTEST_MEMORY_DEBUG
+         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 PNGTEST_MEMORY_DEBUG
+       fprintf(STDERR, "Maximum memory allocation: %d bytes\n",
+          maximum_allocation);
+#endif
+   }
+
+   if (ierror == 0)
+      fprintf(STDERR, "libpng passes test\n");
+   else
+      fprintf(STDERR, "libpng FAILS test\n");
+   return (int)(ierror != 0);
+}
--- a/pngtest.png
+++ b/pngtest.png
--- a/pngtrans.c
+++ b/pngtrans.c
@@ -1,12 +1,13 @@

 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -67,7 +68,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)
 {
@@ -75,10 +77,10 @@ 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

@@ -117,6 +119,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)
@@ -288,7 +300,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)
   {
--- a/pngwio.c
+++ b/pngwio.c
@@ -1,18 +1,20 @@

 /* pngwio.c - functions for data output
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-
-   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
-   functions, but rather write replacement functions and then change
-   them at run time with png_set_write_fn(...) */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ *
+ * This file provides a location for all output.  Users which need
+ * special handling are expected to write functions which have the same
+ * arguments as these, and perform similar functions, but possibly use
+ * different output methods.  Note that you shouldn't change these
+ * functions, but rather write replacement functions and then change
+ * them at run time with png_set_write_fn(...).
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -32,6 +34,7 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
      png_error(png_ptr, "Call to NULL write function");
 }

+#if !defined(PNG_NO_STDIO)
 /* This is the function which 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
@@ -97,6 +100,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
   }
 }

+#endif
 #endif

 /* This function is called to output any data pending writing (normally
@@ -110,6 +114,7 @@ png_flush(png_structp png_ptr)
      (*(png_ptr->output_flush_fn))(png_ptr);
 }

+#if !defined(PNG_NO_STDIO)
 static void
 png_default_flush(png_structp png_ptr)
 {
@@ -119,6 +124,7 @@ png_default_flush(png_structp png_ptr)
      fflush(io_ptr);
 }
 #endif
+#endif

 /* This function allows the application to supply new output functions for
   libpng if standard C streams aren't being used.
@@ -148,16 +154,24 @@ png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
 {
   png_ptr->io_ptr = io_ptr;

+#if !defined(PNG_NO_STDIO)
   if (write_data_fn != NULL)
      png_ptr->write_data_fn = write_data_fn;
   else
      png_ptr->write_data_fn = png_default_write_data;
+#else
+   png_ptr->write_data_fn = write_data_fn;
+#endif

 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
+#if !defined(PNG_NO_STDIO)
   if (output_flush_fn != NULL)
      png_ptr->output_flush_fn = output_flush_fn;
   else
      png_ptr->output_flush_fn = png_default_flush;
+#else
+   png_ptr->output_flush_fn = output_flush_fn;
+#endif
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */

   /* It is an error to read while writing a png file */
@@ -166,7 +180,7 @@ png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,

 #if defined(USE_FAR_KEYWORD) 
 #if defined(_MSC_VER)   
-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 FAR *far_ptr;
@@ -178,7 +192,7 @@ 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 FAR *far_ptr;
--- a/pngwrite.c
+++ b/pngwrite.c
@@ -1,12 +1,13 @@
   
 /* pngwrite.c - general routines to write a PNG file
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 /* get internal access to png.h */
 #define PNG_INTERNAL
@@ -24,20 +25,31 @@
 void
 png_write_info(png_structp png_ptr, png_infop info_ptr)
 {
+#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
   int i;
+#endif

   png_debug(1, "in png_write_info\n");
   png_write_sig(png_ptr); /* write PNG signature */
   /* 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)
   if (info_ptr->valid & PNG_INFO_gAMA)
      png_write_gAMA(png_ptr, info_ptr->gamma);
 #endif
+#if defined(PNG_WRITE_sRGB_SUPPORTED)
+   if (info_ptr->valid & PNG_INFO_sRGB)
+      png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
+#endif
 #if defined(PNG_WRITE_sBIT_SUPPORTED)
   if (info_ptr->valid & PNG_INFO_sBIT)
      png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
@@ -55,10 +67,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)
@@ -128,9 +153,10 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
 }

 /* Writes the end of the PNG file.  If you don't want to write comments or
-   time information, you can pass NULL for info.  If you already wrote these
-   in png_write_info(), do not write them again here.  If you have long
-   comments, I suggest writing them here, and compressing them. */
+ * time information, you can pass NULL for info.  If you already wrote these
+ * in png_write_info(), do not write them again here.  If you have long
+ * comments, I suggest writing them here, and compressing them.
+ */
 void
 png_write_end(png_structp png_ptr, png_infop info_ptr)
 {
@@ -141,7 +167,9 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
   /* see if user wants us to write information chunks */
   if (info_ptr != NULL)
   {
+#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
      int i; /* local index variable */
+#endif
 #if defined(PNG_WRITE_tIME_SUPPORTED)
      /* check to see if user has supplied a time chunk */
      if (info_ptr->valid & PNG_INFO_tIME &&
@@ -190,6 +218,43 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
   png_write_IEND(png_ptr);
 }

+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+/* Convert the supplied time into an RFC 1123 string suitable for use in
+ * a "Creation Time" or other text-based time string.
+ */
+png_charp
+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
+{
+   static const char short_months[12][4] =
+	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+	 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+   if (png_ptr->time_buffer == NULL)
+   {
+      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
+         sizeof(char)));
+   }
+
+#ifdef USE_FAR_KEYWORD
+   {
+      char near_time_buf[29];
+      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
+               ptime->day % 31, short_months[ptime->month],
+               ptime->year, ptime->hour % 24, ptime->minute % 60,
+               ptime->second % 61);
+      png_memcpy(png_ptr->time_buffer, near_time_buf,
+      29*sizeof(char));
+   }
+#else
+   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
+               ptime->day % 31, short_months[ptime->month],
+               ptime->year, ptime->hour % 24, ptime->minute % 60,
+               ptime->second % 61);
+#endif
+   return ((png_charp)png_ptr->time_buffer);
+}
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
 #if defined(PNG_WRITE_tIME_SUPPORTED)
 void
 png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
@@ -226,7 +291,7 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
   png_debug(1, "in png_create_write_struct\n");
   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
   {
-      return (png_structp)NULL;
+      return ((png_structp)NULL);
   }
 #ifdef USE_FAR_KEYWORD
   if (setjmp(jmpbuf))
@@ -236,7 +301,7 @@ 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));
@@ -257,11 +322,17 @@ 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);

-   return (png_ptr);
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
+      1, NULL, NULL);
+#endif
+
+   return ((png_structp)png_ptr);
 }


@@ -283,7 +354,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)
@@ -292,10 +364,11 @@ png_write_init(png_structp png_ptr)
 #endif
 }

-/* write a few rows of image data.  If the image is interlaced,
-   either you will have to write the 7 sub images, or, if you
-   have called png_set_interlace_handling(), you will have to
-   "write" the image seven times */
+/* Write a few rows of image data.  If the image is interlaced,
+ * either you will have to write the 7 sub images, or, if you
+ * have called png_set_interlace_handling(), you will have to
+ * "write" the image seven times.
+ */
 void
 png_write_rows(png_structp png_ptr, png_bytepp row,
   png_uint_32 num_rows)
@@ -311,8 +384,9 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
   }
 }

-/* write the image.  You only need to call this function once, even
-   if you are writing an interlaced image. */
+/* Write the image.  You only need to call this function once, even
+ * if you are writing an interlaced image.
+ */
 void
 png_write_image(png_structp png_ptr, png_bytepp image)
 {
@@ -321,9 +395,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++)
   {
@@ -339,7 +417,8 @@ png_write_image(png_structp png_ptr, png_bytepp image)
 void
 png_write_row(png_structp png_ptr, png_bytep row)
 {
-   png_debug(1, "in png_write_row\n");
+   png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
+      png_ptr->row_number, png_ptr->pass);
   /* initialize transformations and other stuff if first time */
   if (png_ptr->row_number == 0 && png_ptr->pass == 0)
   {
@@ -412,18 +491,20 @@ 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);

-   png_debug1(4, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
-   png_debug1(4, "row_info->width = %d\n", png_ptr->row_info.width);
-   png_debug1(4, "row_info->channels = %d\n", png_ptr->row_info.channels);
-   png_debug1(4, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
-   png_debug1(4, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
-   png_debug1(4, "row_info->rowbytes = %d\n", png_ptr->row_info.rowbytes);
+   png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
+   png_debug1(3, "row_info->width = %d\n", png_ptr->row_info.width);
+   png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
+   png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
+   png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
+   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 */
@@ -447,6 +528,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)
@@ -527,6 +611,22 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)

   if (info_ptr != NULL)
   {
+#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
      png_destroy_struct((png_voidp)info_ptr);
      *info_ptr_ptr = (png_infop)NULL;
   }
@@ -561,6 +661,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_RFC1123_SUPPORTED)
+   png_free(png_ptr, png_ptr->time_buffer);
+#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);
@@ -620,7 +723,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;
         }

@@ -634,7 +737,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;
            }
         }
@@ -649,7 +752,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;
            }
         }
@@ -664,8 +767,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;
            }
         }
@@ -683,14 +786,17 @@ png_set_filter(png_structp png_ptr, int method, int filters)
 * differences metric is relatively fast and effective, there is some
 * question as to whether it can be improved upon by trying to keep the
 * filtered data going to zlib more consistent, hopefully resulting in
- * better compression. */
+ * better compression.
+ */
 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)      /* GRR 970116 */
 void
 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)
@@ -718,7 +824,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++)
@@ -729,11 +835,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++)
         {
@@ -764,11 +870,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++)
      {
@@ -845,3 +951,20 @@ 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
+
--- a/pngwtran.c
+++ b/pngwtran.c
@@ -1,27 +1,48 @@

 /* pngwtran.c - transforms the data in a row for PNG writers
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 #define PNG_INTERNAL
 #include "png.h"

-/* transform the data according to the users wishes.  The order of
-   transformations is significant. */
+/* Transform the data according to the users 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,
@@ -36,6 +57,10 @@ png_do_write_transformations(png_structp png_ptr)
   if (png_ptr->transformations & PNG_SWAP_BYTES)
      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
+#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)
      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
@@ -51,9 +76,10 @@ png_do_write_transformations(png_structp png_ptr)
 }

 #if defined(PNG_WRITE_PACK_SUPPORTED)
-/* pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
-   row_info bit depth should be 8 (one pixel per byte).  The channels
-   should be 1 (this only happens on grayscale and paletted images) */
+/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
+ * row_info bit depth should be 8 (one pixel per byte).  The channels
+ * should be 1 (this only happens on grayscale and paletted images).
+ */
 void
 png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
 {
@@ -169,12 +195,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
 #endif

 #if defined(PNG_WRITE_SHIFT_SUPPORTED)
-/* shift pixel values to take advantage of whole range.  Pass the
-   true number of bits in bit_depth.  The row should be packed
-   according to row_info->bit_depth.  Thus, if you had a row of
-   bit depth 4, but the pixels only had values from 0 to 7, you
-   would pass 3 as bit_depth, and this routine would translate the
-   data to 0 to 15. */
+/* Shift pixel values to take advantage of whole range.  Pass the
+ * true number of bits in bit_depth.  The row should be packed
+ * according to row_info->bit_depth.  Thus, if you had a row of
+ * bit depth 4, but the pixels only had values from 0 to 7, you
+ * would pass 3 as bit_depth, and this routine would translate the
+ * data to 0 to 15.
+ */
 void
 png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
 {
@@ -215,7 +242,7 @@ 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;
@@ -252,7 +279,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)

         for (bp = row, i = 0; i < row_info->width; i++)
         {
-            int c;
+            png_uint_32 c;

            for (c = 0; c < channels; c++, bp++)
            {
@@ -278,7 +305,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)

         for (bp = row, i = 0; i < row_info->width * row_info->channels; i++)
         {
-            int c;
+            png_uint_32 c;

            for (c = 0; c < channels; c++, bp += 2)
            {
@@ -390,3 +417,79 @@ 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;
+
+            for (i = 0, sp = dp = row; i < row_info->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;
+
+            for (i = 0, sp = dp = row; i < row_info->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;
+
+            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+         /* This inverts the alpha channel in GGAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+
+            for (i = 0, sp = dp = row; i < row_info->width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+      }
+   }
+}
+#endif
--- a/pngwutil.c
+++ b/pngwutil.c
@@ -1,12 +1,13 @@

 /* pngwutil.c - utilities to write a PNG file
-
-   libpng 1.0 beta 6 - version 0.96
-   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
-   May 12, 1997
-   */
+ *
+ * libpng 1.00
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, Glenn Randers-Pehrson
+ * March 7, 1998
+ */

 #define PNG_INTERNAL
 #include "png.h"
@@ -26,8 +27,9 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)

 #if defined(PNG_WRITE_pCAL_SUPPORTED)
 /* The png_save_int_32 function assumes integers are stored in two's
-   complement format.  If this isn't the case, then this routine needs to
-   be modified to write data in two's complement format. */
+ * complement format.  If this isn't the case, then this routine needs to
+ * be modified to write data in two's complement format.
+ */
 void
 png_save_int_32(png_bytep buf, png_int_32 i)
 {
@@ -38,22 +40,26 @@ png_save_int_32(png_bytep buf, png_int_32 i)
 }
 #endif

-/* Place a 16-bit number into a buffer in PNG byte order. */
+/* Place a 16-bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
 void
-png_save_uint_16(png_bytep buf, png_uint_16 i)
+png_save_uint_16(png_bytep buf, unsigned int i)
 {
   buf[0] = (png_byte)((i >> 8) & 0xff);
   buf[1] = (png_byte)(i & 0xff);
 }

 /* Write a PNG chunk all at once.  The type is an array of ASCII characters
-   representing the chunk name.  The array must be at least 4 bytes in
-   length, and does not need to be null terminated.  To be safe, pass the
-   pre-defined chunk names here, and if you need a new one, define it
-   where the others are defined.  The length is the length of the data.
-   All the data must be present.  If that is not possible, use the
-   png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
-   functions instead.  */
+ * representing the chunk name.  The array must be at least 4 bytes in
+ * length, and does not need to be null terminated.  To be safe, pass the
+ * pre-defined chunk names here, and if you need a new one, define it
+ * where the others are defined.  The length is the length of the data.
+ * All the data must be present.  If that is not possible, use the
+ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
+ * functions instead.
+ */
 void
 png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
   png_bytep data, png_size_t length)
@@ -64,8 +70,9 @@ png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
 }

 /* Write the start of a PNG chunk.  The type is the chunk type.
-   The total_length is the sum of the lengths of all the data you will be
-   passing in png_write_chunk_data() */
+ * The total_length is the sum of the lengths of all the data you will be
+ * passing in png_write_chunk_data().
+ */
 void
 png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
   png_uint_32 length)
@@ -85,9 +92,10 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
 }

 /* Write the data of a PNG chunk started with png_write_chunk_start().
-   Note that multiple calls to this function are allowed, and that the
-   sum of the lengths from these calls *must* add up to the total_length
-   given to png_write_chunk_start(). */
+ * Note that multiple calls to this function are allowed, and that the
+ * sum of the lengths from these calls *must* add up to the total_length
+ * given to png_write_chunk_start().
+ */
 void
 png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
@@ -106,11 +114,7 @@ png_write_chunk_end(png_structp png_ptr)
   png_byte buf[4];

   /* write the crc */
-#ifdef PNG_USE_OWN_CRC
-   png_save_uint_32(buf, ~png_ptr->crc);
-#else
   png_save_uint_32(buf, png_ptr->crc);
-#endif

   png_write_data(png_ptr, buf, (png_size_t)4);
 }
@@ -119,7 +123,8 @@ png_write_chunk_end(png_structp png_ptr)
 * the magic bytes of the signature, or more likely, the PNG stream is
 * being embedded into another stream and doesn't need its own signature,
 * we should call png_set_sig_bytes() to tell libpng how many of the
- * bytes have already been written. */
+ * bytes have already been written.
+ */
 void
 png_write_sig(png_structp png_ptr)
 {
@@ -129,8 +134,9 @@ png_write_sig(png_structp png_ptr)
 }

 /* Write the IHDR chunk, and update the png_struct with the necessary
-   information.  Note that the rest of this code depends upon this
-   information being correct.  */
+ * information.  Note that the rest of this code depends upon this
+ * information being correct.
+ */
 void
 png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
   int bit_depth, int color_type, int compression_type, int filter_type,
@@ -194,12 +200,16 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
      filter_type = PNG_FILTER_TYPE_BASE;
   }

+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
   if (interlace_type != PNG_INTERLACE_NONE &&
      interlace_type != PNG_INTERLACE_ADAM7)
   {
      png_warning(png_ptr, "Invalid interlace type specified");
      interlace_type = PNG_INTERLACE_ADAM7;
   }
+#else
+   interlace_type=PNG_INTERLACE_NONE;
+#endif

   /* save off the relevent information */
   png_ptr->bit_depth = (png_byte)bit_depth;
@@ -264,8 +274,9 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
 }

 /* write the palette.  We are careful not to trust png_color to be in the
-   correct order for PNG, so people can redefine it to any convient
-   structure. */
+ * correct order for PNG, so people can redefine it to any convient
+ * structure.
+ */
 void
 png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
 {
@@ -336,6 +347,22 @@ png_write_gAMA(png_structp png_ptr, double file_gamma)
 }
 #endif

+#if defined(PNG_WRITE_sRGB_SUPPORTED)
+/* write a sRGB chunk */
+void
+png_write_sRGB(png_structp png_ptr, int srgb_intent)
+{
+   png_byte buf[1];
+
+   png_debug(1, "in png_write_sRGB\n");
+   if(srgb_intent >= PNG_sRGB_INTENT_LAST)
+         png_warning(png_ptr,
+            "Invalid sRGB rendering intent specified");
+   buf[0]=(png_byte)srgb_intent;
+   png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
+}
+#endif
+
 #if defined(PNG_WRITE_sBIT_SUPPORTED)
 /* write the sBIT chunk */
 void
@@ -348,7 +375,7 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
   /* make sure we don't depend upon the order of PNG_COLOR_8 */
   if (color_type & PNG_COLOR_MASK_COLOR)
   {
-      int maxbits;
+      png_byte maxbits;

      maxbits = color_type==PNG_COLOR_TYPE_PALETTE ? 8:png_ptr->usr_bit_depth;
      if (sbit->red == 0 || sbit->red > maxbits || 
@@ -459,7 +486,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
   png_debug(1, "in png_write_tRNS\n");
   if (color_type == PNG_COLOR_TYPE_PALETTE)
   {
-      if (num_trans <= 0 || num_trans > png_ptr->num_palette)
+      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
      {
         png_warning(png_ptr,"Invalid number of transparent colors specified");
         return;
@@ -483,7 +510,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
   }
   else
   {
-      png_warning(png_ptr, "Can't write tRNS with and alpha channel");
+      png_warning(png_ptr, "Can't write tRNS with an alpha channel");
   }
 }
 #endif
@@ -524,13 +551,13 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
 #if defined(PNG_WRITE_hIST_SUPPORTED)
 /* write the histogram */
 void
-png_write_hIST(png_structp png_ptr, png_uint_16p hist, png_uint_32 num_hist)
+png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
 {
-   png_uint_32 i;
+   int i;
   png_byte buf[3];

   png_debug(1, "in png_write_hIST\n");
-   if (num_hist > png_ptr->num_palette)
+   if (num_hist > (int)png_ptr->num_palette)
   {
      png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,
         png_ptr->num_palette);
@@ -538,7 +565,7 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, png_uint_32 num_hist)
      return;
   }

-   png_write_chunk_start(png_ptr, png_hIST, num_hist * 2);
+   png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
   for (i = 0; i < num_hist; i++)
   {
      png_save_uint_16(buf, hist[i]);
@@ -560,11 +587,10 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, png_uint_32 num_hist)
 * static keywords without having to have duplicate copies of the strings.
 */
 png_size_t
-png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key)
+png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
 {
   png_size_t key_len;
-   png_charp kp;
-   png_bytep dp;
+   png_charp kp, dp;
   int kflag;

   png_debug(1, "in png_check_keyword\n");
@@ -572,27 +598,27 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key)

   if (key == NULL || (key_len = png_strlen(key)) == 0)
   {
-      char msg[40];
-
-      sprintf(msg, "Zero length %s keyword", png_ptr->chunk_name);
-      png_warning(png_ptr, msg);
-      return 0;
+      png_chunk_warning(png_ptr, "zero length keyword");
+      return ((png_size_t)0);
   }

   png_debug1(2, "Keyword to be checked is '%s'\n", key);

-   *new_key = (png_bytep)png_malloc(png_ptr, key_len + 1);
+   *new_key = (png_charp)png_malloc(png_ptr, (png_uint_32)(key_len + 1));

   /* Replace non-printing characters with a blank and print a warning */
   for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
   {
-      if (*kp < 0x20 || ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))
+      if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1))
      {
+#if !defined(PNG_NO_STDIO)
         char msg[40];

-         sprintf(msg, "Invalid %s keyword character 0x%02X",
-            png_ptr->chunk_name, *kp);
-         png_warning(png_ptr, msg);
+         sprintf(msg, "invalid keyword character 0x%02X", *kp);
+         png_chunk_warning(png_ptr, msg);
+#else
+         png_chunk_warning(png_ptr, "invalid character in keyword");
+#endif
         *dp = ' ';
      }
      else
@@ -606,11 +632,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key)
   kp = *new_key + key_len - 1;
   if (*kp == ' ')
   {
-      char msg[50];
-      sprintf(msg, "Trailing spaces removed from %s keyword",
-         png_ptr->chunk_name);
-
-      png_warning(png_ptr, msg);
+      png_chunk_warning(png_ptr, "trailing spaces removed from keyword");

      while (*kp == ' ')
      {
@@ -623,11 +645,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key)
   kp = *new_key;
   if (*kp == ' ')
   {
-      char msg[50];
-      sprintf(msg, "Leading spaces removed from %s keyword",
-         png_ptr->chunk_name);
-
-      png_warning(png_ptr, msg);
+      png_chunk_warning(png_ptr, "leading spaces removed from keyword");

      while (*kp == ' ')
      {
@@ -660,24 +678,17 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key)

   if (key_len == 0)
   {
-      char msg[40];
-
-      sprintf(msg, "Zero length %s keyword", png_ptr->chunk_name);
-      png_warning(png_ptr, msg);
+      png_chunk_warning(png_ptr, "zero length keyword");
   }

   if (key_len > 79)
   {
-      char msg[50];
-
-      sprintf(msg, "%s keyword length must be 1 - 79 characters",
-         png_ptr->chunk_name);
-      png_warning(png_ptr, msg);
+      png_chunk_warning(png_ptr, "keyword length must be 1 - 79 characters");
      new_key[79] = '\0';
      key_len = 79;
   }

-   return key_len;
+   return (key_len);
 }
 #endif

@@ -688,15 +699,12 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
   png_size_t text_len)
 {
   png_size_t key_len;
-   png_bytep new_key;
+   png_charp new_key;

   png_debug(1, "in png_write_tEXt\n");
   if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
   {
-      char msg[40];
-
-      sprintf(msg, "Empty keyword in %s chunk", "tEXt");
-      png_warning(png_ptr, msg);
+      png_warning(png_ptr, "Empty keyword in tEXt chunk");
      return;
   }

@@ -705,7 +713,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,

   /* make sure we include the 0 after the key */
   png_write_chunk_start(png_ptr, png_tEXt, (png_uint_32)key_len+text_len+1);
-   png_write_chunk_data(png_ptr, new_key, key_len + 1);
+   png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
   if (text_len)
      png_write_chunk_data(png_ptr, (png_bytep)text, text_len);

@@ -722,7 +730,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
 {
   png_size_t key_len;
   char buf[1];
-   png_bytep new_key;
+   png_charp new_key;
   int i, ret;
   png_charpp output_ptr = NULL; /* array of pointers to output */
   int num_output_ptr = 0; /* number of output pointers used */
@@ -732,10 +740,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,

   if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
   {
-      char msg[40];
-
-      sprintf(msg, "Empty keyword in %s chunk", "zTXt");
-      png_warning(png_ptr, msg);
+      png_warning(png_ptr, "Empty keyword in zTXt chunk");
      return;
   }

@@ -750,9 +755,13 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,

   if (compression >= PNG_TEXT_COMPRESSION_LAST)
   {
+#if !defined(PNG_NO_STDIO)
      char msg[50];
      sprintf(msg, "Unknown zTXt compression type %d", compression);
      png_warning(png_ptr, msg);
+#else
+      png_warning(png_ptr, "Unknown zTXt compression type");
+#endif
      compression = PNG_TEXT_COMPRESSION_zTXt;
   }

@@ -806,17 +815,18 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,

               old_ptr = output_ptr;
               output_ptr = (png_charpp)png_malloc(png_ptr,
-                  max_output_ptr * sizeof (png_charpp));
+                  (png_uint_32)(max_output_ptr * sizeof (png_charpp)));
               png_memcpy(output_ptr, old_ptr, old_max * sizeof (png_charp));
               png_free(png_ptr, old_ptr);
            }
            else
               output_ptr = (png_charpp)png_malloc(png_ptr,
-                  max_output_ptr * sizeof (png_charp));
+                  (png_uint_32)(max_output_ptr * sizeof (png_charp)));
         }

         /* save the data */
-         output_ptr[num_output_ptr] = png_malloc(png_ptr, png_ptr->zbuf_size);
+         output_ptr[num_output_ptr] = (png_charp)png_malloc(png_ptr,
+            (png_uint_32)png_ptr->zbuf_size);
         png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
            png_ptr->zbuf_size);
         num_output_ptr++;
@@ -859,18 +869,18 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
               old_ptr = output_ptr;
               /* This could be optimized to realloc() */
               output_ptr = (png_charpp)png_malloc(png_ptr,
-                  max_output_ptr * sizeof (png_charpp));
+                  (png_uint_32)(max_output_ptr * sizeof (png_charpp)));
               png_memcpy(output_ptr, old_ptr, old_max * sizeof (png_charp));
               png_free(png_ptr, old_ptr);
            }
            else
               output_ptr = (png_charpp)png_malloc(png_ptr,
-                  max_output_ptr * sizeof (png_charp));
+                  (png_uint_32)(max_output_ptr * sizeof (png_charp)));
         }

         /* save off the data */
-         output_ptr[num_output_ptr] = png_malloc(png_ptr,
-            png_ptr->zbuf_size);
+         output_ptr[num_output_ptr] = (png_charp)png_malloc(png_ptr,
+            (png_uint_32)png_ptr->zbuf_size);
         png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
            png_ptr->zbuf_size);
         num_output_ptr++;
@@ -945,7 +955,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
   png_size_t purpose_len, units_len, total_len; 
   png_uint_32p params_len;
   png_byte buf[10];
-   png_bytep new_purpose;
+   png_charp new_purpose;
   int i;

   png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);
@@ -958,7 +968,8 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
   png_debug1(3, "pCAL units length = %d\n", units_len);
   total_len = purpose_len + units_len + 10;

-   params_len = (png_uint_32p)png_malloc(png_ptr, nparams*sizeof(png_uint_32));
+   params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams
+      *sizeof(png_uint_32)));

   /* Find the length of each parameter, making sure we don't count the
      null terminator for the last parameter. */
@@ -970,8 +981,8 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
   }

   png_debug1(3, "pCAL total length = %d\n", total_len);
-   png_write_chunk_start(png_ptr, png_pCAL, total_len);
-   png_write_chunk_data(png_ptr, new_purpose, purpose_len);
+   png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len);
+   png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len);
   png_save_int_32(buf, X0);
   png_save_int_32(buf + 4, X1);
   buf[8] = (png_byte)type;
@@ -987,6 +998,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
         (png_size_t)params_len[i]);
   }

+   png_free(png_ptr, params_len);
   png_write_chunk_end(png_ptr);
 }
 #endif
@@ -1013,8 +1025,9 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
 #endif

 #if defined(PNG_WRITE_tIME_SUPPORTED)
-/* write the tIME chunk.  Use either png_convert_from_struct_tm()
-   or png_convert_from_time_t(), or fill in the structure yourself */
+/* Write the tIME chunk.  Use either png_convert_from_struct_tm()
+ * or png_convert_from_time_t(), or fill in the structure yourself.
+ */
 void
 png_write_tIME(png_structp png_ptr, png_timep mod_time)
 {
@@ -1051,14 +1064,14 @@ png_write_start_row(png_structp png_ptr)
                            png_ptr->usr_bit_depth + 7) >> 3) + 1);

   /* set up row buffer */
-   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
+   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;

   /* set up filtering buffer, if using this filter */
   if (png_ptr->do_filter & PNG_FILTER_SUB)
   {
      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;
   }

@@ -1066,31 +1079,32 @@ png_write_start_row(png_structp png_ptr)
   if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
   {
     /* set up previous row buffer */
-      png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, buf_size);
+      png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
      png_memset(png_ptr->prev_row, 0, buf_size);

      if (png_ptr->do_filter & PNG_FILTER_UP)
      {
         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;
      }

      if (png_ptr->do_filter & PNG_FILTER_AVG)
      {
-         png_ptr->avg_row = (png_bytep )png_malloc(png_ptr,
-            png_ptr->rowbytes + 1);
+         png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
+            (png_ptr->rowbytes + 1));
         png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
      }

      if (png_ptr->do_filter & PNG_FILTER_PAETH)
      {
         png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr,
-            png_ptr->rowbytes + 1);
+            (png_ptr->rowbytes + 1));
         png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
      }
   }

+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
   /* if interlaced, we need to set up width and height of pass */
   if (png_ptr->interlaced)
   {
@@ -1108,6 +1122,7 @@ png_write_start_row(png_structp png_ptr)
      }
   }
   else
+#endif
   {
      png_ptr->num_rows = png_ptr->height;
      png_ptr->usr_width = png_ptr->width;
@@ -1130,6 +1145,7 @@ png_write_finish_row(png_structp png_ptr)
   if (png_ptr->row_number < png_ptr->num_rows)
      return;

+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
   /* if interlaced, go to next pass */
   if (png_ptr->interlaced)
   {
@@ -1171,6 +1187,7 @@ png_write_finish_row(png_structp png_ptr)
         return;
      }
   }
+#endif

   /* if we get here, we've just written the last row, so we need
      to flush the compressor */
@@ -1206,14 +1223,13 @@ png_write_finish_row(png_structp png_ptr)
 }

 #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
-/* pick out the correct pixels for the interlace pass.
-
-   The basic idea here is to go through the row with a source
-   pointer and a destination pointer (sp and dp), and copy the
-   correct pixels for the pass.  As the row gets compacted,
-   sp will always be >= dp, so we should never overwrite anything.
-   See the default: case for the easiest code to understand.
-   */
+/* Pick out the correct pixels for the interlace pass.
+ * The basic idea here is to go through the row with a source
+ * pointer and a destination pointer (sp and dp), and copy the
+ * correct pixels for the pass.  As the row gets compacted,
+ * sp will always be >= dp, so we should never overwrite anything.
+ * See the default: case for the easiest code to understand.
+ */
 void
 png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 {
@@ -1342,7 +1358,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
               i += png_pass_inc[pass])
            {
               /* find out where the original pixel is */
-               sp = row + i * pixel_bytes;
+               sp = row + (png_size_t)i * pixel_bytes;
               /* move the pixel */
               if (dp != sp)
                  png_memcpy(dp, sp, pixel_bytes);
@@ -1357,20 +1373,20 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
         png_pass_inc[pass] - 1 -
         png_pass_start[pass]) /
         png_pass_inc[pass];
-      row_info->rowbytes = ((row_info->width *
-         row_info->pixel_depth + 7) >> 3);
-
+         row_info->rowbytes = ((row_info->width *
+            row_info->pixel_depth + 7) >> 3);
   }
 }
 #endif

 /* This filters the row, chooses which filter to use, if it has not already
 * been specified by the application, and then writes the row out with the
- * chosen filter. */
-#define PNG_MAXSUM (~0x0UL >> 1)
+ * chosen filter.
+ */
+#define PNG_MAXSUM (~((png_uint_32)0) >> 1)
 #define PNG_HISHIFT 10
-#define PNG_LOMASK 0xffffL
-#define PNG_HIMASK (~PNG_LOMASK >> PNG_HISHIFT)
+#define PNG_LOMASK ((png_uint_32)0xffffL)
+#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
 void
 png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 {
@@ -1389,7 +1405,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
    * smallest value when summing the absolute values of the distances
    * from zero using anything >= 128 as negative numbers.  This is known
    * as the "minimum sum of absolute differences" heuristic.  Other
-    * heruistics are the "weighted minumum sum of absolute differences"
+    * heuristics are the "weighted minumum sum of absolute differences"
    * (experimental and can in theory improve compression), and the "zlib
    * predictive" method (not implemented in libpng 0.95), which does test
    * compressions of lines using different filter methods, and then chooses
@@ -1405,7 +1421,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
   {
      png_bytep rp;
      png_uint_32 sum = 0;
-      png_size_t i;
+      png_uint_32 i;
      int v;

      for (i = 0, rp = row_buf + 1; i < row_info->rowbytes; i++, rp++)
@@ -1422,7 +1438,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */

         /* Reduce the sum if we match any of the previous rows */
-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
         {
            if (png_ptr->prev_filters[i] == PNG_FILTER_NONE)
            {
@@ -1456,7 +1472,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
   {
      png_bytep rp, dp, lp;
      png_uint_32 sum = 0, lmins = mins;
-      png_size_t i;
+      png_uint_32 i;
      int v;

 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
@@ -1470,7 +1486,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
         lmlo = lmins & PNG_LOMASK;
         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
         {
            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_SUB)
            {
@@ -1500,7 +1516,8 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)

         sum += (v < 128) ? v : 256 - v;
      }
-      for (lp = row_buf + 1; i < row_info->rowbytes; i++, rp++, lp++, dp++)
+      for (lp = row_buf + 1; i < row_info->rowbytes;
+         i++, rp++, lp++, dp++)
      {
         v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

@@ -1517,7 +1534,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
         sumlo = sum & PNG_LOMASK;
         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
         {
            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_SUB)
            {
@@ -1552,7 +1569,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
   {
      png_bytep rp, dp, pp;
      png_uint_32 sum = 0, lmins = mins;
-      png_size_t i;
+      png_uint_32 i;
      int v;

 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
@@ -1562,7 +1579,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
         lmlo = lmins & PNG_LOMASK;
         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
         {
            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_UP)
            {
@@ -1586,7 +1603,8 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #endif

      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
-           pp = prev_row + 1; i < row_info->rowbytes; i++, rp++, pp++, dp++)
+           pp = prev_row + 1; i < row_info->rowbytes;
+           i++, rp++, pp++, dp++)
      {
         v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);

@@ -1603,7 +1621,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
         sumlo = sum & PNG_LOMASK;
         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
         {
            if (png_ptr->prev_filters[i] == PNG_FILTER_UP)
            {
@@ -1638,7 +1656,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
   {
      png_bytep rp, dp, pp, lp;
      png_uint_32 sum = 0, lmins = mins;
-      png_size_t i;
+      png_uint_32 i;
      int v;

 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
@@ -1648,7 +1666,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
         lmlo = lmins & PNG_LOMASK;
         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-         for (i = 0; i < png_ptr->num_prev_filters; i++)
+         for (i = 0; i < (png_uint_32)png_ptr->num_prev_filters; i++)
         {
            if (png_ptr->prev_filters[i] == PNG_FILTER_VALUE_AVG)
            {
@@ -1731,7 +1749,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
   {
      png_bytep rp, dp, pp, cp, lp;
      png_uint_32 sum = 0, lmins = mins;
-      png_size_t i;
+      png_uint_32 i;
      int v;

 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
@@ -1765,7 +1783,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 #endif

      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
-           pp = prev_row + 1; i < bpp; i++, rp++, pp++, dp++)
+           pp = prev_row + 1; (unsigned)i < bpp; i++, rp++, pp++, dp++)
      {
         v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);

@@ -1843,9 +1861,9 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
   /* Save the type of filter we picked this time for future calculations */
   if (png_ptr->num_prev_filters > 0)
   {
-      png_byte i;
+      int i;

-      for (i = 1; i < png_ptr->num_prev_filters; i++)
+      for (i = 1; i < (int)png_ptr->num_prev_filters; i++)
      {
         png_ptr->prev_filters[i] = png_ptr->prev_filters[i - 1];
      }
@@ -1914,4 +1932,3 @@ png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
   }
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 }
-
--- a/scripts/build.bat
+++ b/scripts/build.bat
--- a/scripts/descrip.mms
+++ b/scripts/descrip.mms
--- a/scripts/makefile.aco
+++ b/scripts/makefile.aco
--- a/scripts/makefile.ama
+++ b/scripts/makefile.ama
--- a/scripts/makefile.atr
+++ b/scripts/makefile.atr
--- a/scripts/makefile.bor
+++ b/scripts/makefile.bor
--- a/scripts/makefile.dec
+++ b/scripts/makefile.dec
@@ -0,0 +1,68 @@
+# 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 the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CC=cc
+CFLAGS=-std -w1 -I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+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
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) 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
+
--- a/scripts/makefile.dj2
+++ b/scripts/makefile.dj2
@@ -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
--- a/scripts/makefile.knr
+++ b/scripts/makefile.knr
@@ -34,8 +34,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
--- a/scripts/makefile.lnx
+++ b/scripts/makefile.lnx
@@ -1,5 +1,6 @@
-# makefile for libpng on (linux) ELF
+# makefile for libpng on Linux ELF with gcc
 # 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
@@ -13,14 +14,17 @@ ZLIBINC=../zlib
 WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
         -Wmissing-declarations -Wtraditional -Wcast-align \
         -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
-CFLAGS=-I$(ZLIBINC) -Wall -O2 -fPIC # $(WARNMORE) # -g -DPNG_DEBUG=3
+CFLAGS=-I$(ZLIBINC) -Wall -O3 -funroll-loops -malign-loops=2 \
+       -malign-functions=2 #$(WARNMORE) -g -DPNG_DEBUG=5
 LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm

 RANLIB=ranlib
 #RANLIB=echo

-PNGMAJ = 0
-PNGMIN = 96
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
+PNGMAJ = 2
+PNGMIN = 1.00
 PNGVER = $(PNGMAJ).$(PNGMIN)

 # where make install puts libpng.a, libpng.so*, and png.h
@@ -32,10 +36,17 @@ 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 pngtest
+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)
+	ar rc $@ $(OBJS)
 	$(RANLIB) $@

 libpng.so: libpng.so.$(PNGMAJ)
@@ -44,43 +55,45 @@ libpng.so: libpng.so.$(PNGMAJ)
 libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
 	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)

-libpng.so.$(PNGVER): $(OBJS)
-	gcc -shared -Wl,-soname,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) $(OBJS)
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(CC) -shared -Wl,-soname,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) \
+	 $(OBJSDLL)

 pngtest: pngtest.o libpng.so
-	$(CC) -o pngtest pngtest.o $(LDFLAGS)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)

 test: pngtest
 	./pngtest

-install: libpng.so.$(PNGVER)
+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.so.$(PNGVER) $(LIBPATH)
+	cp libpng.a libpng.so.$(PNGVER) $(LIBPATH)
 	chmod 755 $(LIBPATH)/libpng.so.$(PNGVER)
-	-@/bin/rm $(LIBPATH)/libpng.so.$(PNGMAJ) $(LIBPATH)/libpng.so
+	-@/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:
-	rm -f *.o libpng.a libpng.so* pngtest pngout.png
+	/bin/rm -f *.o libpng.a libpng.so* 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
+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
-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
--- a/scripts/makefile.mip
+++ b/scripts/makefile.mip
@@ -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
--- a/scripts/makefile.msc
+++ b/scripts/makefile.msc
@@ -5,7 +5,7 @@

 # ------------- Microsoft C 5.1 and later -------------
 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
--- a/scripts/makefile.os2
+++ b/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
--- a/scripts/makefile.s2x
+++ b/scripts/makefile.s2x
@@ -0,0 +1,98 @@
+ makefile for libpng on Solaris 2.x with gcc
+# Contributed by William L. Sebok, based on makefile.lnx
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1998 Greg Roelofs
+# 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
+
+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.00
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+# where make install puts libpng.a, libpng.so*, and png.h
+prefix=/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.pic.o:
+	$(CC) -c $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a libpng.so pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.so: libpng.so.$(PNGMAJ)
+	ln -sf libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(LD) -G -L$(LIBPATH) -R$(LIBPATH) -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 -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
--- a/scripts/makefile.sgi
+++ b/scripts/makefile.sgi
@@ -9,11 +9,12 @@ ZLIBLIB=../zlib
 ZLIBINC=../zlib

 CC=cc
-CFLAGS=-I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+
+CFLAGS=-I$(ZLIBINC) -O -fullwarn # -g -DPNG_DEBUG=1
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm

-#RANLIB=echo
-RANLIB=ranlib
+RANLIB=echo
+#RANLIB=ranlib

 # where make install puts libpng.a and png.h
 prefix=/usr/local
@@ -29,7 +30,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
--- a/scripts/makefile.std
+++ b/scripts/makefile.std
@@ -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
--- a/scripts/makefile.sun
+++ b/scripts/makefile.sun
@@ -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
--- a/scripts/makefile.tc3
+++ b/scripts/makefile.tc3
@@ -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.tc3"

 # ------------- Turbo C++ 3.0 -------------
 MODEL=-ml
@@ -9,18 +9,22 @@ 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)
+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)
 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)
+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
@@ -75,4 +79,7 @@ libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
        $(LIB) libpng +$(OBJSL2)
        $(LIB) libpng +$(OBJSL3)

-# End of makefile for libpng
+pngtest$(E): pngtest$(O) libpng.lib
+        $(CC) $(LDFLAGS) pngtest.obj libpng.lib zlib.lib
+
+# End of makefile for libpng
--- a/scripts/makefile.wat
+++ b/scripts/makefile.wat
@@ -0,0 +1,88 @@
+# Makefile for libpng
+# Watcom 10a+ 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 makefile.wat"
+
+# ------------- Watcom 10a+ -------------
+MODEL=-mf
+CFLAGS= $(MODEL) -fpi87 -fp5 -5r -oaeilmnrt -s -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
+	pngtest
+
+# End of makefile for libpng
--- a/scripts/makevms.com
+++ b/scripts/makevms.com
--- a/scripts/pngos2.def
+++ b/scripts/pngos2.def
@@ -0,0 +1,286 @@
+;----------------------------------------
+; 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_write_struct
+  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_set_error_fn
+  png_get_error_ptr
+  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_debug_malloc
+; png_debug_free
+; 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_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_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
Author	SHA1	Message	Date
Glenn Randers-Pehrson	7cd899c707	Imported from libpng-0.99m.tar	2009-04-06 16:04:17 -05:00
Glenn Randers-Pehrson	ea3bcd7087	Imported from libpng-0.99k.tar	2009-04-06 16:04:17 -05:00
Glenn Randers-Pehrson	983ec160b4	Imported from libpng-0.99j.tar	2009-04-06 16:04:16 -05:00
Glenn Randers-Pehrson	08a3343e05	Imported from libpng-0.99i.tar	2009-04-06 16:04:16 -05:00
Glenn Randers-Pehrson	cbe52d8720	Imported from libpng-0.99e.tar	2009-04-06 16:04:15 -05:00
Glenn Randers-Pehrson	a357b99113	Imported from libpng-0.99d.tar	2009-04-06 16:04:14 -05:00
Glenn Randers-Pehrson	0f881d62b3	Imported from libpng-0.99c.tar	2009-04-06 16:04:13 -05:00
Glenn Randers-Pehrson	b212002101	Imported from libpng-0.99a.tar	2009-04-06 16:04:12 -05:00
Glenn Randers-Pehrson	46f61e2398	Imported from libpng-0.99.tar	2009-04-06 16:04:12 -05:00
Glenn Randers-Pehrson	c4a2ae6cac	Imported from libpng-0.98.tar	2009-04-06 16:04:11 -05:00
Glenn Randers-Pehrson	2687fcc7b5	Imported from libpng-0.97c.tar	2009-04-06 16:04:10 -05:00
Glenn Randers-Pehrson	70e3f543f1	Imported from libpng-0.97a.tar	2009-04-06 16:04:10 -05:00
Glenn Randers-Pehrson	b6ce43d6ff	Imported from libpng-0.97.tar	2009-04-06 16:04:09 -05:00