Imported from libpng-1.0.1.tar

Imported from libpng-1.0.0b.tar
Imported from libpng-1.0.0a.tar
2025-07-10 18:04:09 +02:00 · 2009-04-06 16:04:23 -05:00 · 2009-04-06 16:04:22 -05:00 · 2009-04-06 16:04:21 -05:00 · 2009-04-06 16:04:20 -05:00 · 2009-04-06 16:04:20 -05:00
54 changed files with 2527 additions and 1046 deletions
--- a/65
+++ b/65
@@ -1,4 +1,4 @@
-pngchange.txt - changes for libpng
+CHANGES - changes for libpng

 version 0.2
   added reader into png.h
@@ -224,12 +224,65 @@ 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 8, 1998]
+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().
-version 0.99e [February 9, 1998]
-   Fixed a bug with background compositing of paletted images in pngrtran.c
+     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.
+     unused png_ptr, mostly in pngget.c and pngset.c.
+   Check for overlength tRNS chunk present when indexed-color PLTE is read.
+   Cleaned up spelling errors in libpng.3/libpng.txt
+   Corrected a problem with png_get_tRNS() which returned undefined trans array
+version 0.99e [February 28, 1998]
+   Corrected png_get_tRNS() again.
+   Add parentheses for easier reading of pngget.c, fixed "||" should be "&&".
+   Touched up example.c to make more of it compileable, although the entire
+     file still can't be compiled (Willem van Schaik)
+   Fixed a bug in png_do_shift() (Bryan Tsai)
+   Added a space in png.h prototype for png_write_chunk_start()
+   Replaced pngtest.png with one created with zlib 1.1.1
+   Changed pngtest to report PASS even when file size is different (Jean-loup G.)
+   Corrected some logic errors in png_do_invert_alpha() (Chris Patterson)
+version 0.99f [March 5, 1998]
+   Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey)
+   Moved makefiles into a "scripts" directory, and added INSTALL instruction file
+   Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok)
+   Added pointers to "note on libpng versions" in makefile.lnx and README
+   Added row callback feature when reading and writing nonprogressive rows
+      and added a test of this feature in pngtest.c
+   Added user transform callbacks, with test of the feature in pngtest.c
+version 0.99g [March 6, 1998, morning]
+   Minor changes to pngtest.c to suppress compiler warnings.
+   Removed "beta" language from documentation.
+version 0.99h [March 6, 1998, evening]
+   Minor changes to previous minor changes to pngtest.c 
+   Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED
+   and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro
+version 1.00 [March 7, 1998]
+   Changed several typedefs in pngrutil.c
+   Added makefile.wat (Pawel Mrochen), updated makefile.tc3 (Willem van Schaik)
+   replaced "while(1)" with "for(;;)"
+   added PNGARG() to prototypes in pngtest.c and removed some prototypes
+   updated some of the makefiles (Tom Lane)
+   changed some typedefs (s_start, etc.) in pngrutil.c
+   fixed dimensions of "short_months" array in pngwrite.c
+   Replaced ansi2knr.c with the one from jpeg-v6
+version 1.0.0 [March 8, 1998]
+   Changed name from 1.00 to 1.0.0 (Adam Costello)
+   Added smakefile.ppc (with SCOPTIONS.ppc) for Amiga PPC (Andreas Kleinert)
+version 1.0.0a [March 9, 1998]
+   Fixed three bugs in pngrtran.c to make gamma+background handling consistent
+   (Greg Roelofs)
+   Changed format of the PNG_LIBPNG_VER integer to xyyzz instead of xyz
+   for major, minor, and bugfix releases.  This is 10001. (Adam Costello,
+   Tom Lane)
+   Make months range from 1-12 in png_convert_to_rfc1123
+version 1.0.0b [March 13, 1998]
+   Quieted compiler complaints about two empty "for" loops in pngrutil.c
+   Minor changes to makefile.s2x
+   Removed #ifdef/#endif around a png_free() in pngread.c
+version 1.0.1 [March 14, 1998]
+   Changes makefile.s2x to reduce security risk of using a relative pathname
+   Fixed some typos in the documentation (Greg).
+   Fixed a problem with value of "channels" returned by png_read_update_info()
--- a/87
+++ b/87
@@ -0,0 +1,87 @@
+
+Installing libpng version 1.0.1 March 15, 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.0.1 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.0)
+      makefile.lnx  =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0)
+      makefile.mip  =>  MIPS makefile
+      makefile.aco  =>  Acorn makefile
+      makefile.ama  =>  Amiga makefile
+      smakefile.ppc =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                        (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+      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/56
+++ b/56
@@ -1,8 +1,7 @@
-[NOTE:  this is still beta version 0.99d; the text below has already
- been updated in anticipation of the imminent 1.0 release.]
+README for libpng 1.0.1 (shared library 2.1)
+See the note about version numbers near the top of png.h

-
-README for libpng 1.0
+See INSTALL for instructions on how to install libpng.

 This is the first official release of libpng.  Don't let the fact that
 it's the first release fool you.  The libpng library has been in
@@ -117,7 +116,7 @@ and ...".  If in doubt, send questions to me.  I'll bounce them
 to others, if necessary.

 Please do not send suggestions on how to change PNG.  We have
-been discussing PNG for a couple years now, and it is official and
+been discussing PNG for three years now, and it is official and
 finished.  If you have suggestions for libpng, however, I'll
 gladly listen.  Even if your suggestion is not used for version
 1.0, it may be used later.
@@ -127,30 +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.aco  =>  ACORN makefile
-      makefile.ama  =>  Amiga makefile
-      makefile.atr  =>  Atari makefile
-      makefile.bor  =>  Borland makefile
-      makefile.dec  =>  DEC 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.sgi  =>  Silicon Graphics Irix makefile
-      makefile.std  =>  Standard Unix makefile
-      makefile.sun  =>  SUN makefile
-      makefile.tc3  =>  Turbo C 3.0 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
@@ -165,6 +154,30 @@ 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.0)
+        makefile.lnx  =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0)
+        makefile.mip  =>  MIPS makefile
+        makefile.aco  =>  Acorn makefile
+        makefile.ama  =>  Amiga makefile
+        smakefile.ppc =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                          (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+        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.

@@ -178,5 +191,4 @@ Good luck, and happy coding.

 -Guy Eric Schalnat
 (formerly of Group 42, Inc)
- Web: http://www.group42.com/
-
+ Internet: gschal@infinet.com
--- a/4
+++ b/4
@@ -1,6 +1,8 @@
-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
+add "grayscale" -> "grayscale+alpha" and "grayscale+FILLER" transformations
 improved dithering
 multi-lingual error and warning message support
 sPLT chunk handling
--- 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,3 +1,4 @@
+
 /* example.c - an example of using libpng */

 /* This is an example of how to use libpng to read and write PNG files.
@@ -12,9 +13,9 @@
 * 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
+/* Check to see if a file is a PNG file using png_sig_cmp().  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,
@@ -28,7 +29,7 @@
 *
 * Many applications already read the first 2 or 4 bytes from the start
 * of the image to determine the file type, so it would be easiest just
- * to pass the bytes to png_check_sig() or even skip that if you know
+ * to pass the bytes to png_sig_cmp() or even skip that if you know
 * you have a PNG file, and call png_set_sig_bytes().
 */
 #define PNG_BYTES_TO_CHECK 4
@@ -45,7 +46,7 @@ int check_if_png(char *file_name, FILE **fp)
      return 0;

   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. */
-   return(png_check_sig(buf, PNG_BYTES_TO_CHECK));
+   return(png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
 }

 /* Read a PNG file.  You may want to return an error code if the read
@@ -54,7 +55,7 @@ int check_if_png(char *file_name, FILE **fp)
 * file, and the other where we are given an open file (possibly with
 * some or all of the magic bytes read - see comments above).
 */
-**** prototype 1 ****
+#ifdef open_file /* prototype 1 */
 void read_png(char *file_name)  /* We need to open the file */
 {
   png_structp png_ptr;
@@ -66,14 +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,
@@ -91,7 +92,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
   }

   /* Allocate/initialize the memory for image information.  REQUIRED. */
-   info_ptr = png_create_info_struct();
+   info_ptr = png_create_info_struct(png_ptr);
   if (info_ptr == NULL)
   {
      fclose(fp);
@@ -113,20 +114,20 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
   }

   /* One of the following I/O initialization methods is REQUIRED */
-**** PNG file I/O method 1 ****
+#ifdef streams /* PNG file I/O method 1 */
   /* Set up the input control if you are using standard C streams */
   png_init_io(png_ptr, fp);

-**** PNG file I/O method 2 ****
+#else no_streams /* PNG file I/O method 2 */
   /* If you are using replacement read functions, instead of calling
    * png_init_io() here you would call:
    */
   png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
   /* where user_io_ptr is a structure you want available to the callbacks */
-**** Use only one I/O method! ****
+#endif no_streams /* Use only one I/O method! */

   /* If we have already read some of the signature */
-   png_set_sig_bytes_read(png_ptr, sig_read);
+   png_set_sig_bytes(png_ptr, sig_read);

   /* The call to png_read_info() gives us all of the information from the
    * PNG file before the first IDAT (image data chunk).  REQUIRED
@@ -180,10 +181,10 @@ 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,
@@ -191,7 +192,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */

   /* Some suggestions as to how to get a screen gamma value */

-   /* Note that screen gamma is (display_gamma/viewing_gamma)
+   /* Note that screen gamma is (display_gamma/viewing_gamma) */
   if (/* We have a user-defined screen gamma value */)
   {
      screen_gamma = user-defined screen_gamma;
@@ -217,10 +218,10 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */

   int intent;

-   if (png_get_sRGB(png_ptr, info_ptr, &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)
+      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);
@@ -234,7 +235,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
      png_colorp palette;

      /* This reduces the image to the application supplied palette */
-      if (we have our own palette)
+      if (/* we have our own palette */)
      {
         /* An array of colors to which the image should be dithered */
         png_color std_color_cube[MAX_SCREEN_COLORS];
@@ -243,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;

@@ -304,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 ****
+#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);
@@ -479,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;
@@ -526,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
@@ -550,7 +551,7 @@ void write_png(char *file_name, ... other image information ...)

   /* set the palette if there is one.  REQUIRED for indexed-color images */
   palette = (png_colorp)png_malloc(png_ptr, 256 * sizeof (png_color));
-   ... set palette colors ...
+   /* ... set palette colors ... */
   png_set_PLTE(png_ptr, info_ptr, palette, 256);

   /* optional significant bit chunk */
@@ -640,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.
    */
@@ -661,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
@@ -1,27 +1,28 @@
 libpng.txt - A description on how to use and modify libpng

-libpng version 0.99d
-Updated and distributed by Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
-Copyright (c) 1998, Glenn Randers-Pehrson
-February 8, 1998
+ libpng version 1.0.1 March 15, 1998
+ Updated and distributed by Glenn Randers-Pehrson
+ <randeg@alumni.rpi.edu>
+ Copyright (c) 1998, Glenn Randers-Pehrson
+ For conditions of distribution and use, see copyright
+ notice in png.h.

-based on:
+ based on:

-libpng 1.0 beta 6  version 0.96
-Updated and distributed by Andreas Dilger 
-Copyright (c) 1996, 1997 Andreas Dilger
-May 28, 1997
+ libpng 1.0 beta 6  version 0.96 May 28, 1997
+ Updated and distributed by Andreas Dilger 
+ Copyright (c) 1996, 1997 Andreas Dilger

-libpng 1.0 beta 2 - version 0.88
-For conditions of distribution and use, see copyright notice in png.h
-Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-January 26, 1996
+ libpng 1.0 beta 2 - version 0.88  January 26, 1996
+ For conditions of distribution and use, see copyright
+ notice in png.h. Copyright (c) 1995, 1996 Guy Eric
+ Schalnat, Group 42, Inc.

-Updated/rewritten per request in the libpng FAQ
-Copyright (c) 1995 Frank J. T. Wojcik
-December 18, 1995 && January 20, 1996
+ Updated/rewritten per request in the libpng FAQ
+ Copyright (c) 1995 Frank J. T. Wojcik
+ December 18, 1995 && January 20, 1996

-I. Introduction
+Introduction

 This file describes how to use and modify the PNG reference library
 (known as libpng) for your own use.  There are five sections to this
@@ -29,7 +30,8 @@ file: introduction, structures, reading, writing, and modification and
 configuration notes for various special platforms.  In addition to this
 file, example.c is a good starting point for using the library, as
 it is heavily commented and should include everything most people
-will need.
+will need.  We assume that libpng is already installed; see the
+INSTALL file for instructions on how to install libpng.

 Libpng was written as a companion to the PNG specification, as a way
 of reducing the amount of time and effort it takes to support the PNG
@@ -73,9 +75,7 @@ II. Structures
 There are two main structures that are important to libpng, png_struct
 and png_info.  The first, png_struct, is an internal structure that
 will not, for the most part, be used by a user except as the first
-variable passed to every libpng function call.  It is not actually
-used in many of the functions; do not be alarmed about compiler
-warnings that say something to the effect that "png_ptr is not used."
+variable passed to every libpng function call.

 The png_info structure is designed to provide information about the
 PNG file.  At one time, the fields of png_info were intended to be
@@ -203,6 +203,22 @@ libpng know that there are some bytes missing from the start of the file.

    png_set_sig_bytes(png_ptr, number);

+At this point, you can set up a callback function that will be
+called after each row has been read, which you can use to control
+a progress meter or the like.  It's demonstrated in pngtest.c.
+You must supply a function
+
+    void read_row_callback(png_ptr, png_uint_32 row, int pass);
+    {
+      /* put your code here */
+    }
+
+(You can give it another name that you like instead of "read_row_callback")
+
+To inform libpng about your function, use
+
+    png_set_read_status_fn(png_ptr, read_row_callback);
+
 In PNG files, the alpha channel in an image is the level of opacity.
 If you need the alpha channel in an image to be the level of transparency
 instead of opacity, you can invert the alpha channel (or the tRNS chunk
@@ -216,6 +232,21 @@ because the tRNS chunk data must be modified in the case of paletted images.
 If your image is not a paletted image, the tRNS data (which in such cases
 represents a single color to be rendered as transparent) won't be changed.

+Finally, you can write your own transformation function if none of
+the existing ones meets your needs.  This is done by setting a callback
+with
+
+    png_set_read_user_transform_fn(png_ptr,
+       read_transform_fn);
+
+You must supply the function
+
+    void read_transform_fn(png_ptr ptr, row_info_ptr
+       row_info, png_bytep data) 
+
+See pngtest.c for a working example.  Your function will be called
+after all of the other transformations have been processed.
+
 You are now ready to read all the file information up to the actual
 image data.  You do this with a call to png_read_info().

@@ -257,8 +288,8 @@ Functions are used to get the information from the info_ptr:
                     for PNG 1.0)
    compression_type - (must be PNG_COMPRESSION_TYPE_BASE
                     for PNG 1.0)
-    interlace_type - (PNG_INTERLACE_TYPE_NONE or
-                     PNG_INTERLACE_TYPE_ADAM7)
+    interlace_type - (PNG_INTERLACE_NONE or
+                     PNG_INTERLACE_ADAM7)
    Any or all of interlace_type, compression_type, of
                     filter_type can be
    NULL if you are not interested in their values.
@@ -275,7 +306,7 @@ Functions are used to get the information from the info_ptr:
    signature      - holds the signature read from the
                     file (if any).  The data is kept in
                     the same offset it would be if the
-                     whole signature were read (ie if an
+                     whole signature were read (i.e. if an
                     application had already read in 4
                     bytes of signature before starting
                     libpng, the remaining 4 bytes would
@@ -377,12 +408,16 @@ into the info_ptr is returned for any complex types.
                     x direction
    res_y          - pixels/unit physical resolution in
                     x direction
-    unit_type      - PNG_RESOLUTION_UNKOWN,
+    unit_type      - PNG_RESOLUTION_UNKNOWN,
                     PNG_RESOLUTION_METER

 The data from the pHYs chunk can be retrieved in several convenient
 forms:

+    res_x = png_get_x_pixels_per_meter(png_ptr,
+                  info_ptr)
+    res_y = png_get_y_pixels_per_meter(png_ptr,
+                  info_ptr)
    res_x_and_y = png_get_pixels_per_meter(png_ptr,
                  info_ptr)
    aspect_ratio = png_get_pixel_aspect_ratio(png_ptr,
@@ -425,7 +460,7 @@ ways to transform the data will be described in the order that they
 should occur.  This is important, as some of these change the color
 type and/or bit depth of the data, and some others only work on
 certain color types and bit depths.  Even though each transformation
-checks to see if it has data that it can do somthing with, you should
+checks to see if it has data that it can do something with, you should
 make sure to only enable a transformation if it will be valid for the
 data.  For example, don't swap red and blue on grayscale data.

@@ -497,7 +532,7 @@ values of the pixels:

 PNG files have possible bit depths of 1, 2, 4, 8, and 16.  All pixels
 stored in a PNG image have been "scaled" or "shifted" up to the next
-higher possible bit depth (eg from 5 bits/sample in the range [0,31] to
+higher possible bit depth (e.g. from 5 bits/sample in the range [0,31] to
 8 bits/sample in the range [0, 255]).  However, it is also possible to
 convert the PNG pixel data back to the original bit depth of the image.
 This call reduces the pixels back down to the original bit depth:
@@ -571,9 +606,8 @@ the overall gamma correction required to produce pleasing results,
 which depends on the lighting conditions in the surrounding environment.
 Screen_gamma is display_gamma/viewing_gamma, where viewing_gamma is
 the amount of additional gamma correction needed to compensate for
-a dim (viewing_gamma=1.125) or dark (viewing_gamma=1.25) environment.
-In a brightly lit room, no compensation other than the display_gamma
-is needed (viewing_gamma=1.0).
+a (viewing_gamma=1.25) environment.  In a dim or brightly lit room, no
+compensation other than the display_gamma is needed (viewing_gamma=1.0).

   if (/* We have a user-defined screen
       gamma value */)
@@ -590,10 +624,8 @@ is needed (viewing_gamma=1.0).
   /* If we don't have another value */
   else
   {
-      screen_gamma = 2.5; /* A good guess for a
-           PC monitor in a bright office */
      screen_gamma = 2.2; /* A good guess for a
-           PC monitor in a dim room */
+           PC monitor in a bright office or a dim room */
      screen_gamma = 2.0; /* A good guess for a
           PC monitor in a dark room */
      screen_gamma = 1.7 or 1.0;  /* A good
@@ -656,8 +688,8 @@ zero):
      png_set_invert_mono(png_ptr);

 PNG files store 16 bit pixels in network byte order (big-endian,
-ie. most significant bits first).  This code chages the storage to the
-other way (little-endian, ie. least significant bits first, eg. the
+ie. most significant bits first).  This code changes the storage to the
+other way (little-endian, i.e. least significant bits first, the
 way PCs store them):

    if (bit_depth == 16)
@@ -713,7 +745,7 @@ You can point to void or char or whatever you use for pixels.

 If you don't want to read in the whole image at once, you can
 use png_read_rows() instead.  If there is no interlacing (check
-interlace_type == PNG_INTERLACE_TYPE_NONE), this is simple:
+interlace_type == PNG_INTERLACE_NONE), this is simple:

    png_read_rows(png_ptr, row_pointers, NULL,
       number_of_rows);
@@ -728,7 +760,7 @@ row_pointers:

 If the file is interlaced (info_ptr->interlace_type != 0), things get
 somewhat harder.  The only current (PNG Specification version 1.0)
-interlacing type for PNG is (interlace_type == PNG_INTERLACE_TYPE_ADAM7)
+interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7)
 is a somewhat complicated 2D interlace scheme, known as Adam7, that
 breaks down an image into seven smaller images of varying size, based
 on an 8x8 grid.
@@ -767,7 +799,7 @@ numbered scanlines.  Phew!
 If you want libpng to expand the images, call this before calling
 png_start_read_image() or png_read_update_info():

-    if (interlace_type == PNG_INTERLACE_TYPE_ADAM7)
+    if (interlace_type == PNG_INTERLACE_ADAM7)
        number_of_passes
           = png_set_interlace_handling(png_ptr);

@@ -914,6 +946,7 @@ png_infop info_ptr;
    read.
 */
 void
+ info_callback(png_structp png_ptr, png_infop info)
 {
    /* Do any setup here, including setting any of
       the transformations mentioned in the Reading
@@ -1005,7 +1038,10 @@ custom writing functions.  See the discussion under Customizing libpng.
 Next, png_struct and png_info need to be allocated and initialized.
 As these can be both relatively large, you may not want to store these
 on the stack, unless you have stack space to spare.  Of course, you
-will want to check if they return NULL.
+will want to check if they return NULL.  If you are also reading,
+you won't want to name your read structure and your write structure
+both "png_ptr"; you can call them anything you like, such as
+"read_ptr" and "write_ptr".  Look at pngtest.c, for example.

    png_structp png_ptr = png_create_write_struct
       (PNG_LIBPNG_VER_STRING, (void *)user_error_ptr,
@@ -1048,6 +1084,22 @@ Libpng section below.

    png_init_io(png_ptr, fp);

+At this point, you can set up a callback function that will be
+called after each row has been written, which you can use to control
+a progress meter or the like.  It's demonstrated in pngtest.c.
+You must supply a function
+
+    void write_row_callback(png_ptr, png_uint_32 row, int pass);
+    {
+      /* put your code here */
+    }
+
+(You can give it another name that you like instead of "write_row_callback")
+
+To inform libpng about your function, use
+
+    png_set_write_status_fn(png_ptr, write_row_callback);
+
 You now have the option of modifying how the compression library will
 run.  The following functions are mainly for testing, but may be useful
 in some cases, like if you need to write PNG files extremely fast and
@@ -1057,7 +1109,8 @@ have no special needs in this area, let the library do what it wants by
 not calling this function at all, as it has been tuned to deliver a good
 speed/compression ratio. The second parameter to png_set_filter() is
 the filter method, for which the only valid value is '0' (as of the
-06/96 PNG specification.  The third parameter is a flag that indicates
+October 1996 PNG specification, version 1.0).  The third parameter is a
+flag that indicates
 which filter type(s) are to be tested for each scanline.  See the
 Compression Library for details on the specific filter types.

@@ -1128,8 +1181,8 @@ Some of the more important parts of the png_info are:
                     PNG_COLOR_MASK_COLOR
                     PNG_COLOR_MASK_ALPHA

-    interlace_type - PNG_INTERLACE_TYPE_NONE or
-                     PNG_INTERLACE_TYPE_ADAM7
+    interlace_type - PNG_INTERLACE_NONE or
+                     PNG_INTERLACE_ADAM7
    compression_type - (must be
                     PNG_COMPRESSION_TYPE_DEFAULT)
    filter_type    - (must be PNG_FILTER_TYPE_DEFAULT)
@@ -1226,7 +1279,7 @@ Some of the more important parts of the png_info are:
                  in x direction
    res_y       - pixels/unit physical resolution
                  in y direction
-    unit_type   - PNG_RESOLUTION_UNKOWN,
+    unit_type   - PNG_RESOLUTION_UNKNOWN,
                  PNG_RESOLUTION_METER

 In PNG files, the alpha channel in an image is the level of opacity.
@@ -1267,7 +1320,7 @@ The keywords that are given in the PNG Specification are:
    Description      Description of image (possibly long)
    Copyright        Copyright notice
    Creation Time    Time of original image creation
-                    (usually RFC 1123 format, see below)
+                     (usually RFC 1123 format, see below)
    Software         Software used to create the image
    Disclaimer       Legal disclaimer
    Warning          Warning of nature of content
@@ -1277,7 +1330,7 @@ The keywords that are given in the PNG Specification are:

 The keyword-text pairs work like this.  Keywords should be short
 simple descriptions of what the comment is about.  Some typical
-keywords are found in the PNG specification, as is some recomendations
+keywords are found in the PNG specification, as is some recommendations
 on keywords.  You can repeat keywords in a file.  You can even write
 some text before the image and some after.  For example, you may want
 to put a description of the image before the image, but leave the
@@ -1301,7 +1354,7 @@ time_t routine uses gmtime().  You don't have to use either of
 these, but if you wish to fill in the png_time structure directly,
 you should provide the time in universal time (GMT) if possible
 instead of your local time.  Note that the year number is the full
-year (ie 1996, rather than 96 - PNG is year 2000 compliant!), and
+year (e.g. 1998, rather than 98 - PNG is year 2000 compliant!), and
 that months start with 1.

 If you want to store the time of the original image creation, you should
@@ -1311,7 +1364,7 @@ depending on whether you mean the PNG file, the time the image was
 created in a non-PNG format, a still photo from which the image was
 scanned, or possibly the subject matter itself.  In order to facilitate
 machine-readable dates, it is recommended that the "Creation Time"
-tEXt chunk use RFC 1123 format dates (eg 22 May 1997 18:07:10 GMT"),
+tEXt chunk use RFC 1123 format dates (e.g. 22 May 1997 18:07:10 GMT"),
 although this isn't a requirement.  Unlike the tIME chunk, the
 "Creation Time" tEXt chunk is not expected to be automatically changed
 by the software.  To facilitate the use of RFC 1123 dates, a function
@@ -1329,7 +1382,7 @@ ways to transform the data will be described in the order that they
 should occur.  This is important, as some of these change the color
 type and/or bit depth of the data, and some others only work on
 certain color types and bit depths.  Even though each transformation
-checks to see if it has data that it can do somthing with, you should
+checks to see if it has data that it can do something with, you should
 make sure to only enable a transformation if it will be valid for the
 data.  For example, don't swap red and blue on grayscale data.

@@ -1372,7 +1425,7 @@ file so that decoders can get the original data if desired.
    png_set_sBIT(png_ptr, info_ptr, &sig_bit);

 If the data is stored in the row buffer in a bit depth other than
-one supported by PNG (ie 3 bit data in the range 0-7 for a 4-bit PNG),
+one supported by PNG (e.g. 3 bit data in the range 0-7 for a 4-bit PNG),
 this will scale the values to appear to be the correct bit depth as
 is required by PNG.

@@ -1380,8 +1433,8 @@ is required by PNG.

 PNG files store 16 bit pixels in network byte order (big-endian,
 ie. most significant bits first).  This code would be used if they are
-supplied the other way (little-endian, ie. least significant bits
-first, eg. the way PCs store them):
+supplied the other way (little-endian, i.e. least significant bits
+first, the way PCs store them):

    if (bit_depth > 8)
       png_set_swap(png_ptr);
@@ -1403,6 +1456,21 @@ one. This code would be used if the pixels are supplied with this reversed

    png_set_invert_mono(png_ptr);

+Finally, you can write your own transformation function if none of
+the existing ones meets your needs.  This is done by setting a callback
+with
+
+    png_set_write_user_transform_fn(png_ptr,
+       write_transform_fn);
+
+You must supply the function
+
+    void write_transform_fn(png_ptr ptr, row_info_ptr
+       row_info, png_bytep data) 
+
+See pngtest.c for a working example.  Your function will be called
+before any of the other transformations have been processed.
+
 It is possible to have libpng flush any pending output, either manually,
 or automatically after a certain number of lines have been written.  To
 flush the output stream a single time call:
@@ -1418,9 +1486,9 @@ Note that the distance between rows is from the last time png_write_flush()
 was called, or the first row of the image if it has never been called.
 So if you write 50 lines, and then png_set_flush 25, it will flush the
 output on the next scanline, and every 25 lines thereafter, unless
-png_write_flush()ls is called before 25 more lines have been written.
+png_write_flush() is called before 25 more lines have been written.
 If nrows is too small (less than about 10 lines for a 640 pixel wide
-RGB image) the image compression may decrease noticably (although this
+RGB image) the image compression may decrease noticeably (although this
 may be acceptable for real-time applications).  Infrequent flushing will
 only degrade the compression performance by a few percent over images
 that do not use flushing.
@@ -1458,9 +1526,9 @@ row_pointers:
    png_write_row(png_ptr, &row_pointer);

 When the file is interlaced, things can get a good deal more
-complicated.  The only currently (as of 6/96 -- PNG Specification
-version 1.0) defined interlacing scheme for PNG files is a
-compilcated interlace scheme, known as Adam7, that breaks down an
+complicated.  The only currently (as of February 1998 -- PNG Specification
+version 1.0, dated October 1996) defined interlacing scheme for PNG files
+is the "Adam7" interlace scheme, that breaks down an
 image into seven smaller images of varying size.  libpng will build
 these images for you, or you can do them yourself.  If you want to
 build them yourself, see the PNG specification for details of which
@@ -1513,9 +1581,9 @@ The second deals with more complicated things like adding new chunks,
 adding new transformations, and generally changing how libpng works.

 All of the memory allocation, input/output, and error handling in libpng
-goes through callbacks which are user setable.  The default routines are
+goes through callbacks which are user settable.  The default routines are
 in pngmem.c, pngrio.c, pngwio.c, and pngerror.c respectively.  To change
-these functions, call the approprate png_set_???_fn() function.
+these functions, call the appropriate png_set_???_fn() function.

 Memory allocation is done through the functions png_large_malloc(),
 png_malloc(), png_realloc(), png_large_free(), and png_free().  These
@@ -1613,11 +1681,11 @@ can be found in the comments inside the code itself.
 Configuring for 16 bit platforms:

 You may need to change the png_large_malloc() and png_large_free()
-routines in pngmem.c, as these are requred to allocate 64K, although
+routines in pngmem.c, as these are required to allocate 64K, although
 there is already support for many of the common DOS compilers.  Also,
 you will want to look into zconf.h to tell zlib (and thus libpng) that
 it cannot allocate more then 64K at a time.  Even if you can, the memory
-won't be accessable.  So limit zlib and libpng to 64K by defining MAXSEG_64K.
+won't be accessible.  So limit zlib and libpng to 64K by defining MAXSEG_64K.

 Configuring for DOS:

@@ -1642,7 +1710,7 @@ You will need to write new error and warning functions that use the GUI
 interface, as described previously, and set them to be the error and
 warning functions at the time that png_create_???_struct() is called,
 in order to have them available during the structure initialization.
-They can be changed later via png_set_error_fn().  On some compliers,
+They can be changed later via png_set_error_fn().  On some compilers,
 you may also have to change the memory allocators (png_malloc, etc.).

 Configuring for compiler xxx:
@@ -1744,7 +1812,7 @@ to be considered when selecting row filters.  This means that filters
 with higher costs are less likely to be chosen over filters with lower
 costs, unless their "sum of absolute differences" is that much smaller.
 The costs do not necessarily reflect the exact computational speeds of
-the various filters, since this would unduely influence the final image
+the various filters, since this would unduly influence the final image
 size.

 Note that the numbers above were invented purely for this example and
@@ -1757,15 +1825,18 @@ There are a bunch of #define's in pngconf.h that control what parts of
 libpng are compiled.  All the defines end in _SUPPORTED.  If you are
 never going to use an ability, you can change the #define to #undef
 before recompiling libpng and save yourself code and data space.
-You can also turn them off en masse with a compiler directive that
-defines PNG_READ[or WRITE]_NOT_FULLY_SUPPORTED, or
+You can also turn a number of them off en masse with a compiler directive
+that defines PNG_READ[or WRITE]_TRANSFORMS_NOT_SUPPORTED, or
 PNG_READ[or WRITE]_ANCILLARY_CHUNKS_NOT_SUPPORTED, or all four,
 along with directives to turn on any of the capabilities that you do
-want.  The NOT_FULLY_SUPPORTED directives disable the extra
-transformations but still leave the library fully capable of reading
+want.  The PNG_READ[or WRITE]_TRANSFORMS_NOT_SUPPORTED directives disable
+the extra transformations but still leave the library fully capable of reading
 and writing PNG files with all known public chunks [except for sPLT].
 Use of the PNG_READ[or WRITE]_ANCILLARY_CHUNKS_NOT_SUPPORTED directive
 produces a library that is incapable of reading or writing ancillary chunks.
+If you are not using the progressive reading capability, you can
+turn that off with PNG_PROGRESSIVE_READ_NOT_SUPPORTED (don't confuse
+this with the INTERLACING capability, which you'll still have).

 All the reading and writing specific code are in separate files, so the
 linker should only grab the files it needs.  However, if you want to
@@ -1815,16 +1886,4 @@ to set the error callbacks AFTER png_read_init(), or to change them with
 png_set_error_fn(), which is essentially the same function, but with a
 new name to force compilation errors with applications that try to use
 the old method.
-.SH AUTHORS
-This man page: Glenn Randers-Pehrson
-
-Libpng version 0.99d (February 8, 1998):
-Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.
-Currently maintained by Glenn Randers-Pehrson (randeg@alumni.rpi.edu).
-
-Supported by the PNG development group
-.br
-(png-implement@dworkin.wustl.edu).
-
-.\" end of man page

--- a/libpngpf.3
+++ b/libpngpf.3
@@ -0,0 +1,342 @@
+.TH LIBPNGPF 3 "March 15, 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/makefile.min
+++ b/makefile.min
@@ -1,80 +0,0 @@
-# makefile for libpng
-# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
-# For conditions of distribution and use, see copyright notice in png.h
-
-# Where the zlib library and include files are located
-#ZLIBLIB=/usr/local/lib
-#ZLIBINC=/usr/local/include
-ZLIBLIB=../zlib
-ZLIBINC=../zlib
-
-CC=cc
-
-# CFLAGS=-I$(ZLIBINC) -O -fullwarn \
-#    -DPNG_NO_EASY_ACCESS
-
-CFLAGS=-I$(ZLIBINC) -O -fullwarn  \
-    -DPNG_READ_NOT_FULLY_SUPPORTED -DPNG_WRITE_NOT_FULLY_SUPPORTED
-
-#CFLAGS=-I$(ZLIBINC) -O -fullwarn -DPNGTEST_MEMORY_DEBUG \
-#    -DPNG_READ_NOT_FULLY_SUPPORTED -DPNG_WRITE_NOT_FULLY_SUPPORTED \
-#    -DPNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED \
-#    -DPNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED \
-#    -DPNG_NO_STDIO
-
-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 $(CCFLAGS) pngtest.o $(LDFLAGS)
-
-test: pngtest
-	./pngtest
-
-install: libpng.a
-	-@mkdir $(prefix)/include
-	-@mkdir $(prefix)/lib
-	cp png.h $(prefix)/include
-	cp pngconf.h $(prefix)/include
-	chmod 644 $(prefix)/include/png.h
-	chmod 644 $(prefix)/include/pngconf.h
-	cp libpng.a $(prefix)/lib
-	chmod 644 $(prefix)/lib/libpng.a
-
-clean:
-	rm -f *.o libpng.a pngtest pngout.png
-
-# DO NOT DELETE THIS LINE -- make depend depends on it.
-
-png.o: png.h pngconf.h
-pngerror.o: png.h pngconf.h
-pngrio.o: png.h pngconf.h
-pngwio.o: png.h pngconf.h
-pngmem.o: png.h pngconf.h
-pngset.o: png.h pngconf.h
-pngget.o: png.h pngconf.h
-pngread.o: png.h pngconf.h
-pngrtran.o: png.h pngconf.h
-pngrutil.o: png.h pngconf.h
-pngtest.o: png.h pngconf.h
-pngtrans.o: png.h pngconf.h
-pngwrite.o: png.h pngconf.h
-pngwtran.o: png.h pngconf.h
-pngwutil.o: png.h pngconf.h
-pngpread.o: png.h pngconf.h
-
--- a/png.5
+++ b/png.5
@@ -1,4 +1,4 @@
-.TH PNG 5 "February 8, 1998"
+.TH PNG 5 "March 15, 1998"
 .SH NAME
 png \- Portable Network Graphics (PNG) format
 .SH DESCRIPTION
--- a/png.c
+++ b/png.c
@@ -1,12 +1,12 @@

 /* png.c - location for general purpose libpng functions
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 #define PNG_INTERNAL
@@ -16,7 +16,7 @@
 /* Version information for C files.  This had better match the version
 * string defined in png.h.
 */
-char png_libpng_ver[5] = "0.99";
+char png_libpng_ver[12] = "1.0.1";

 /* Place to hold the signature string for a PNG file. */
 png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
@@ -185,7 +185,7 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
   }

   if (need_crc)
-      png_ptr->crc = crc32(png_ptr->crc, ptr, length);
+      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
 }

 /* Allocate the memory for an info_struct for the application.  We don't
--- a/png.h
+++ b/png.h
@@ -1,12 +1,12 @@

 /* png.h - header file for PNG reference library
 *
- * libpng 0.99d beta
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * Note about libpng version numbers:
 *
@@ -16,37 +16,29 @@
 *    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                     0.99      2.0.99
- *      0.99b                     0.99      2.0.99
- *      0.99c                     0.99      2.0.99
- *      0.99d                     0.99      2.0.99
- *      1.0                       1.00      2.1.0
+ *      source                    png.h   png.h   shared-lib
+ *      version                   string    int   version
+ *      -------                   ------  ------  ----------
+ *      0.89c ("1.0 beta 3")      0.89        89  1.0.89
+ *      0.90  ("1.0 beta 4")      0.90        90  0.90  [should have been 2.0.90]
+ *      0.95  ("1.0 beta 5")      0.95        95  0.95  [should have been 2.0.95]
+ *      0.96  ("1.0 beta 6")      0.96        96  0.96  [should have been 2.0.96]
+ *      0.97b ("1.00.97 beta 7")  1.00.97     97  1.0.1 [should have been 2.0.97]
+ *      0.97c                     0.97        97  2.0.97
+ *      0.98                      0.98        98  2.0.98
+ *      0.99                      0.99        98  2.0.99
+ *      0.99a-m                   0.99        99  2.0.99
+ *      1.00                      1.00       100  2.1.0 [int should be 10000]
+ *      1.0.0                     1.0.0      100  2.1.0 [int should be 10000]
+ *      1.0.1                     1.0.1    10001  2.1.0
 *
 *    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.
- *
- * 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.
+ *    The PNG_PNGLIB_VER macro, which is not used within libpng but
+ *    is available for applications, is an unsigned integer of the form
+ *    xyyzz corresponding to the source version x.y.z (leading zeros in y and z).
+ *    
 *
 * See libpng.txt for more information.  The PNG specification is available
 * as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/>
@@ -65,6 +57,7 @@
 *    Guy Eric Schalnat
 *    Paul Schmidt
 *    Tom Tanner
+ *    Willem van Schaik
 *    Tim Wegner
 *
 * The contributing authors would like to thank all those who helped
@@ -125,19 +118,21 @@ extern "C" {
 */

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

-/* 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  99
+/* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
+ * We must not include leading zeros.
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
+ * version 1.0.0 was mis-numbered 100 instead of 10000).  From
+ * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=bugfix */
+#define PNG_LIBPNG_VER    10001  /* 1.0.1 */

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

 /* Structures to facilitate easy interlacing.  See png.c for more details */
 extern int FARDATA png_pass_start[7];
@@ -507,6 +502,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));
@@ -514,6 +511,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.
@@ -530,9 +533,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 */

@@ -619,9 +627,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 */
@@ -708,6 +718,21 @@ 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));
@@ -795,7 +820,7 @@ extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));
 extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));
 #endif /* PNG_READ_PACK_SUPPORTED || PNG_WRITE_PACK_SUPPORTED */

-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPOR)
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 /* Swap packing order of pixels in bytes. */
 extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));
 #endif /* PNG_READ_PACKSWAP_SUPPORTED || PNG_WRITE_PACKSWAP_SUPPOR */
@@ -1080,6 +1105,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.
@@ -1200,6 +1241,10 @@ 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
@@ -1450,6 +1495,7 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 #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
@@ -1620,21 +1666,6 @@ PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i));
 */
 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 signature */
 PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));

@@ -1811,7 +1842,7 @@ PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
 PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));
 #endif

-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPOR)
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));
 #endif

--- a/pngconf.h
+++ b/pngconf.h
@@ -1,12 +1,12 @@

 /* pngconf.h - machine configurable file for libpng
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 /* Any machine specific code is near the front of this file, so if you
@@ -236,21 +236,24 @@ __dont__ include it again

 /* Any transformations you will not be using can be undef'ed here */

-/* GR-P, 0.96a: Set "*FULLY_SUPPORTED as default but allow user
-   to turn it off with "*NOT_FULLY_SUPPORTED" on the compile line,
+/* 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.
+   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_NOT_FULLY_SUPPORTED
-#define PNG_READ_FULLY_SUPPORTED
+
+#ifndef PNG_READ_TRANSFORMS_NOT_SUPPORTED
+#define PNG_READ_TRANSFORMS_SUPPORTED
 #endif
-#ifndef PNG_WRITE_NOT_FULLY_SUPPORTED
-#define PNG_WRITE_FULLY_SUPPORTED
+#ifndef PNG_WRITE_TRANSFORMS_NOT_SUPPORTED
+#define PNG_WRITE_TRANSFORMS_SUPPORTED
 #endif

-#ifdef PNG_READ_FULLY_SUPPORTED
-#define PNG_PROGRESSIVE_READ_SUPPORTED
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
 #define PNG_READ_EXPAND_SUPPORTED
 #define PNG_READ_SHIFT_SUPPORTED
 #define PNG_READ_PACK_SUPPORTED
@@ -267,12 +270,20 @@ __dont__ include it again
 #define PNG_READ_SWAP_ALPHA_SUPPORTED
 #define PNG_READ_INVERT_ALPHA_SUPPORTED
 #define PNG_READ_STRIP_ALPHA_SUPPORTED
-#define PNG_READ_COMPOSITE_NODIV_SUPPORTED        /* well tested on Intel */
-#endif /* PNG_READ_FULLY_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_READ_INTERLACING_SUPPORTED  /* required for PNG-compliant decoders */
+#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_FULLY_SUPPORTED
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
 #define PNG_WRITE_SHIFT_SUPPORTED
 #define PNG_WRITE_PACK_SUPPORTED
 #define PNG_WRITE_BGR_SUPPORTED
@@ -284,10 +295,11 @@ __dont__ include it again
 #define PNG_WRITE_SWAP_ALPHA_SUPPORTED
 #define PNG_WRITE_INVERT_ALPHA_SUPPORTED
 #define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
-#endif /* PNG_WRITE_FULLY_SUPPORTED */
+#define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */

-#define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant */
-                                         /* encoders, but can cause trouble
+#define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant
+                                            encoders, but can cause trouble
                                            if left undefined */

 #if !defined(PNG_NO_STDIO)
@@ -318,7 +330,7 @@ __dont__ include it again

 /* very little testing */
 /*
-#define PNG_READ_16_TO_8_ACCURATE_SHIFT_SUPPORTED
+#define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
 */

 /* This is only for PowerPC big-endian and 680x0 systems */
--- a/pngerror.c
+++ b/pngerror.c
@@ -1,12 +1,12 @@

 /* pngerror.c - stub functions for i/o and memory allocation
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * This file provides a location for all error handling.  Users which
 * need special error handling are expected to write replacement functions
@@ -59,7 +59,7 @@ png_warning(png_structp png_ptr, png_const_charp message)
 * if the character is invalid.
 */
 #define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97))
-static const char png_digit[16] = {
+static PNG_CONST char png_digit[16] = {
   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 };

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

 /* pngget.c - retrieval of values from info struct
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 #define PNG_INTERNAL
@@ -102,14 +102,47 @@ png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
   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)
+   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)
+      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);
   }
@@ -122,7 +155,7 @@ 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)
+   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)
@@ -140,7 +173,7 @@ 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)
+   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)
@@ -156,7 +189,7 @@ 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)
+   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)
@@ -172,7 +205,7 @@ 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)
+   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)
@@ -188,7 +221,7 @@ 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)
+   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)
@@ -200,9 +233,82 @@ png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
   return (0);
 }

-/* png_get_channels really belongs in here, too, but it's been around longer */
+#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)
 {
@@ -226,8 +332,8 @@ png_uint_32
 png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
   png_color_16p *background)
 {
-   if (png_ptr != NULL && 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);
@@ -243,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 (png_ptr != NULL && 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)
@@ -272,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 (png_ptr != NULL && 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;
@@ -287,8 +393,8 @@ png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
 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)
+   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;
@@ -302,8 +408,8 @@ png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
 png_uint_32
 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
 {
-   if (png_ptr != NULL && 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;
@@ -364,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 (png_ptr != NULL && 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;
@@ -411,9 +517,13 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
   {
      png_debug1(1, "in %s retrieval function\n", "pHYs");
-      if (res_x != NULL && res_y != NULL)
+      if (res_x != NULL)
      {
         *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (res_y != NULL)
+      {
         *res_y = info_ptr->y_pixels_per_unit;
         retval |= PNG_INFO_pHYs;
      }
@@ -422,9 +532,8 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
         *unit_type = (int)info_ptr->phys_unit_type;
         retval |= PNG_INFO_pHYs;
      }
-      return (retval);
   }
-   return (0);
+   return (retval);
 }
 #endif

@@ -464,7 +573,7 @@ png_uint_32
 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
   int *num_text)
 {
-   if (png_ptr != NULL && 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"
@@ -499,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)
 {
+   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,11 +1,12 @@
+
 /* pngmem.c - stub functions for memory allocation
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 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
@@ -18,11 +19,11 @@
 /* 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
+#define PNG_MALLOC png_debug_malloc
+#define PNG_FREE   png_debug_free
 #else
-   #define PNG_MALLOC png_malloc
-   #define PNG_FREE   png_free
+#define PNG_MALLOC png_malloc
+#define PNG_FREE   png_free
 #endif

 /* Borland DOS special memory handler */
@@ -297,7 +298,7 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
   ret = halloc(size, 1);
 # else
-   ret = malloc(size);
+   ret = malloc((size_t)size);
 # endif
 #endif

--- a/pngpread.c
+++ b/pngpread.c
@@ -1,12 +1,12 @@

 /* pngpread.c - read a png file in push mode
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 #define PNG_INTERNAL
@@ -591,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)
@@ -785,7 +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->pixel_depth + 7) >> 3) + 1;
+
+         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 +
@@ -978,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;
--- a/pngread.c
+++ b/pngread.c
@@ -1,12 +1,12 @@

 /* pngread.c - read a PNG file
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * This file contains routines that an application calls directly to
 * read a PNG file or stream.
@@ -123,7 +123,7 @@ png_read_init(png_structp png_ptr)
 }

 /* Read the information before the actual image data.  This has been
- * changed in v0.90 to allow reading a file which already has the magic
+ * changed in v0.90 to allow reading a file that already has the magic
 * bytes read from the stream.  You can tell libpng how many bytes have
 * been read from the beginning of the stream (up to the maxumum of 8)
 * via png_set_sig_bytes(), and we will only check the remaining bytes
@@ -154,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;
@@ -449,6 +449,9 @@ 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,
@@ -716,10 +719,8 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
 #endif
   if (png_ptr->flags & PNG_FLAG_FREE_PALETTE)
      png_zfree(png_ptr, png_ptr->palette);
-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_bKGD_SUPPORTED)
   if (png_ptr->flags & PNG_FLAG_FREE_TRANS)
      png_free(png_ptr, png_ptr->trans);
-#endif
 #if defined(PNG_READ_hIST_SUPPORTED)
   if (png_ptr->flags & PNG_FLAG_FREE_HIST)
      png_free(png_ptr, png_ptr->hist);
@@ -778,3 +779,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,12 +1,12 @@

 /* pngrio.c - functions for data input
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * This file provides a location for all input.  Users which need
 * special handling are expected to write a function which has the same
--- a/pngrtran.c
+++ b/pngrtran.c
@@ -1,12 +1,12 @@

 /* pngrtran.c - transforms the data in a row for PNG readers
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * This file contains functions optionally called by an application 
 * in order to tell libpng how to handle data when reading a PNG.
@@ -600,6 +600,17 @@ png_set_rgb_to_gray(png_structp png_ptr, int gray_bits)
 }
 #endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+void
+png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
+   read_user_transform_fn)
+{
+   png_debug(1, "in png_set_read_user_transform_fn\n");
+   png_ptr->transformations |= PNG_USER_TRANSFORM;
+   png_ptr->read_user_transform_fn = read_user_transform_fn;
+}
+#endif
+
 /* Initialize everything needed for the read.  This includes modifying
 * the palette.
 */
@@ -654,7 +665,7 @@ png_init_read_transformations(png_structp png_ptr)
        if (png_ptr->transformations & PNG_INVERT_ALPHA)
        {
 #if defined(PNG_READ_EXPAND_SUPPORTED)
-           if (png_ptr->transformations & !PNG_EXPAND)
+           if (!(png_ptr->transformations & PNG_EXPAND))
 #endif
           {
           /* invert the alpha channel (in tRNS) unless the pixels are 
@@ -701,41 +712,50 @@ png_init_read_transformations(png_structp png_ptr)
            }
            else
            {
-               double g;
+               double g, gs;

-               g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
-
-               if (png_ptr->background_gamma_type==PNG_BACKGROUND_GAMMA_SCREEN||
-                   fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
+               switch (png_ptr->background_gamma_type)
               {
-                  back.red = (png_byte)png_ptr->background.red;
+                  case PNG_BACKGROUND_GAMMA_SCREEN:
+                     g = (png_ptr->screen_gamma);
+                     gs = 1.0;
+                     break;
+                  case PNG_BACKGROUND_GAMMA_FILE:
+                     g = 1.0 / (png_ptr->gamma);
+                     gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+                     break;
+                  case PNG_BACKGROUND_GAMMA_UNIQUE:
+                     g = 1.0 / (png_ptr->background_gamma);
+                     gs = 1.0 / (png_ptr->background_gamma *
+                                 png_ptr->screen_gamma);
+                     break;
+                  default:
+                     g = 1.0;    /* back_1 */
+                     gs = 1.0;   /* back */
+               }
+
+               if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
+               {
+                  back.red   = (png_byte)png_ptr->background.red;
                  back.green = (png_byte)png_ptr->background.green;
-                  back.blue = (png_byte)png_ptr->background.blue;
+                  back.blue  = (png_byte)png_ptr->background.blue;
               }
               else
               {
-                  back.red =
-                     (png_byte)(pow((double)png_ptr->background.red/255, g) *
-                      255.0 + 0.5);
-                  back.green =
-                     (png_byte)(pow((double)png_ptr->background.green/255, g) *
-                      255.0 + 0.5);
-                  back.blue =
-                     (png_byte)(pow((double)png_ptr->background.blue/255, g) *
-                      255.0 + 0.5);
+                  back.red = (png_byte)(pow(
+                     (double)png_ptr->background.red/255, gs) * 255.0 + .5);
+                  back.green = (png_byte)(pow(
+                     (double)png_ptr->background.green/255, gs) * 255.0 + .5);
+                  back.blue = (png_byte)(pow(
+                     (double)png_ptr->background.blue/255, gs) * 255.0 + .5);
               }

-               g = 1.0 / png_ptr->background_gamma;
-
-               back_1.red =
-                  (png_byte)(pow((double)png_ptr->background.red/255, g) *
-                   255.0 + 0.5);
-               back_1.green =
-                  (png_byte)(pow((double)png_ptr->background.green/255, g) *
-                   255.0 + 0.5);
-               back_1.blue =
-                  (png_byte)(pow((double)png_ptr->background.blue/255, g) *
-                   255.0 + 0.5);
+               back_1.red = (png_byte)(pow(
+                  (double)png_ptr->background.red/255, g) * 255.0 + .5);
+               back_1.green = (png_byte)(pow(
+                  (double)png_ptr->background.green/255, g) * 255.0 + .5);
+               back_1.blue = (png_byte)(pow(
+                  (double)png_ptr->background.blue/255, g) * 255.0 + .5);
            }

            for (i = 0; i < num_palette; i++)
@@ -771,8 +791,9 @@ png_init_read_transformations(png_structp png_ptr)
               }
            }
         }
-         else
         /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN)*/
+         else
+         /* color_type != PNG_COLOR_TYPE_PALETTE */
         {
            double g, gs, m;

@@ -799,6 +820,7 @@ png_init_read_transformations(png_structp png_ptr)

            if (color_type & PNG_COLOR_MASK_COLOR)
            {
+               /* RGB or RGBA */
               png_ptr->background_1.red = (png_uint_16)(pow(
                  (double)png_ptr->background.red / m, g) * m + .5);
               png_ptr->background_1.green = (png_uint_16)(pow(
@@ -814,6 +836,7 @@ png_init_read_transformations(png_structp png_ptr)
            }
            else
            {
+               /* GRAY or GRAY ALPHA */
               png_ptr->background_1.gray = (png_uint_16)(pow(
                  (double)png_ptr->background.gray / m, g) * m + .5);
               png_ptr->background.gray = (png_uint_16)(pow(
@@ -822,6 +845,7 @@ png_init_read_transformations(png_structp png_ptr)
         }
      }
      else
+      /* transformation does not include PNG_BACKGROUND */
 #endif
      if (color_type == PNG_COLOR_TYPE_PALETTE)
      {
@@ -844,6 +868,7 @@ png_init_read_transformations(png_structp png_ptr)
 #endif
 #endif
 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
+   /* No GAMMA transformation */
   if (png_ptr->transformations & PNG_BACKGROUND &&
       color_type == PNG_COLOR_TYPE_PALETTE)
   {
@@ -964,8 +989,7 @@ png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
 #endif

 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
-   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
-      !(info_ptr->color_type & PNG_COLOR_MASK_COLOR))
+   if (png_ptr->transformations & PNG_GRAY_TO_RGB)
      info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
 #endif

@@ -977,12 +1001,8 @@ png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
      info_ptr->channels = 1;

 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
-   if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
-       info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
-   {
-      info_ptr->channels--;
+   if (png_ptr->transformations & PNG_STRIP_ALPHA)
      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
-   }
 #endif

 #if defined(PNG_READ_FILLER_SUPPORTED)
@@ -1073,7 +1093,7 @@ png_do_read_transformations(png_structp png_ptr)
         png_ptr->gamma_shift);
 #endif

-#if defined(PNG_RGB_TO_GRAY_SUPPORTED)
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
   if (png_ptr->transformations & PNG_RGB_TO_GRAY)
      png_do_rgb_to_gray(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
@@ -1130,20 +1150,36 @@ png_do_read_transformations(png_structp png_ptr)
         (png_uint_32)png_ptr->filler, png_ptr->flags);
 #endif

-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
-   if (png_ptr->transformations & PNG_SWAP_ALPHA)
-      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
-#endif
-
 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
   if (png_ptr->transformations & PNG_INVERT_ALPHA)
      png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_ALPHA)
+      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
 #if defined(PNG_READ_SWAP_SUPPORTED)
   if (png_ptr->transformations & PNG_SWAP_BYTES)
      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+      if(png_ptr->read_user_transform_fn != NULL)
+        (*(png_ptr->read_user_transform_fn)) /* user read 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_READ_PACK_SUPPORTED)
@@ -1516,10 +1552,10 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
            for (i = 0, sp = dp = row + row_info->rowbytes;
               i < row_info->width; i++)
            {
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
               *(--dp) = 255 - *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
            }
         }
         /* This inverts the alpha channel in RRGGBBAA */
@@ -1531,20 +1567,20 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
            for (i = 0, sp = dp = row + row_info->rowbytes;
               i < row_info->width; i++)
            {
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
               *(--dp) = 255 - *(--sp);
               *(--dp) = 255 - *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
            }
         }
      }
      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
      {
-         /* This inverts the alpha channel in AG */
+         /* This inverts the alpha channel in GA */
         if (row_info->bit_depth == 8)
         {
            png_bytep sp, dp;
@@ -1553,11 +1589,11 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
            for (i = 0, sp = dp = row + row_info->rowbytes;
               i < row_info->width; i++)
            {
-               *(--dp) = *(--sp);
               *(--dp) = 255 - *(--sp);
+               *(--dp) = *(--sp);
            }
         }
-         /* This inverts the alpha channel in AAGG */
+         /* This inverts the alpha channel in GGAA */
         else
         {
            png_bytep sp, dp;
@@ -1566,10 +1602,10 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
            for (i = 0, sp = dp = row + row_info->rowbytes;
               i < row_info->width; i++)
            {
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
               *(--dp) = 255 - *(--sp);
               *(--dp) = 255 - *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
            }
         }
      }
@@ -1919,7 +1955,7 @@ png_correct_palette(png_structp png_ptr, png_colorp palette,
         back.green = (png_byte)png_ptr->background.green;
         back.blue  = (png_byte)png_ptr->background.blue;

-         for (i = 0; i < (int)png_ptr->num_trans && i < num_palette; i++)
+         for (i = 0; i < (int)png_ptr->num_trans; i++)
         {
            if (png_ptr->trans[i] == 0)
            {
@@ -1986,7 +2022,6 @@ png_do_background(png_row_infop row_info, png_bytep row,
      {
         case PNG_COLOR_TYPE_GRAY:
         {
-            /* We currently don't do gamma correction for 2 and 4 bit */
            switch (row_info->bit_depth)
            {
               case 1:
--- a/pngrutil.c
+++ b/pngrutil.c
@@ -1,12 +1,12 @@

 /* pngrutil.c - utilities to read a PNG file
 *
- * libpng 0.99
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * This file contains routines which are only called from within
 * libpng itself during the course of reading an image.
@@ -258,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)
   {
@@ -1062,7 +1076,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

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

   endptr = purpose + slength;

@@ -1099,8 +1113,8 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
   }

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

   png_debug(3, "Allocating pCAL parameters array\n");
   params = (png_charpp)png_malloc(png_ptr, (png_uint_32)(nparams
@@ -1112,8 +1126,8 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      buf++; /* Skip the null string terminator from previous parameter. */

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

      /* Make sure we haven't run out of data yet */
      if (buf > endptr)
@@ -1291,7 +1305,7 @@ 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 = (png_size_t)(text - key);
      text_size = 0;
@@ -1419,8 +1433,8 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   if (!(png_ptr->chunk_name[0] & 0x20))
   {
      png_chunk_error(png_ptr, "unknown critical chunk");
-      /* to quiet compiler warnings about unused info_ptr */

+      /* to quiet compiler warnings about unused info_ptr */
      if (info_ptr == NULL)
         return;
   }
@@ -1749,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;
@@ -1763,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;
@@ -1810,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;
@@ -1819,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;
@@ -2045,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))
         {
@@ -2088,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;
   }

--- a/pngset.c
+++ b/pngset.c
@@ -1,12 +1,12 @@

 /* pngset.c - storage of image information into info struct
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 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
--- a/pngtest.c
+++ b/pngtest.c
@@ -1,12 +1,12 @@

 /* pngtest.c - a simple test program to test libpng
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 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
@@ -37,11 +37,7 @@

 #include "png.h"

-#ifdef PNGTEST_MEMORY_DEBUG
-#include <unistd.h>
-#endif
-
-int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname);
+int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));

 #ifdef __TURBOC__
 #include <mem.h>
@@ -51,7 +47,128 @@ int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname);
 /*  #define STDERR stderr  */
 #define STDERR stdout   /* for DOS */

+/* example of using row callbacks to make a simple progress meter */
+static int status_pass=1;
+static int status_dots_requested=0;
+static int status_dots=1;
+
+void
+read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
+{
+    if(png_ptr == NULL || row_number > 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_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_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 */
@@ -63,8 +180,6 @@ static int verbose = 0;
   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);
-static void
 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
   png_size_t check;
@@ -89,8 +204,6 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 #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);
 static void
 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
@@ -134,8 +247,6 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 static void
-png_default_flush(png_structp png_ptr);
-static void
 png_default_flush(png_structp png_ptr)
 {
   FILE *io_ptr;
@@ -151,8 +262,6 @@ png_default_flush(png_structp png_ptr)
   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);
-static void
 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
   png_uint_32 check;
@@ -172,8 +281,6 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 #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);
 static void
 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
@@ -347,7 +454,8 @@ png_free(png_structp png_ptr, png_voidp ptr)
 /* END of code to test memory allocation/deallocation */

 /* Test one file */
-int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
+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;
@@ -443,6 +551,21 @@ int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
      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_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);
@@ -675,7 +798,7 @@ int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
      return (1);
   }

-   while (1)
+   for(;;)
   {
      png_size_t num_in, num_out;

@@ -686,9 +809,20 @@ int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
      {
         fprintf(STDERR, "Files %s and %s are of a different size\n",
                 inname, outname);
+         if(wrote_question == 0)
+         {
+            fprintf(STDERR,
+              "   Was %s written with the same chunk size (8k),",inname);
+            fprintf(STDERR,
+              " filtering\n   heuristic (libpng default), compression");
+            fprintf(STDERR,
+              " level (zlib default)\n   and zlib version (%s)?\n\n",
+              ZLIB_VERSION);
+            wrote_question=1;
+         }
         fclose(fpin);
         fclose(fpout);
-         return (1);
+         return (0);
      }

      if (!num_in)
@@ -697,9 +831,20 @@ int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
      if (png_memcmp(inbuf, outbuf, num_in))
      {
         fprintf(STDERR, "Files %s and %s are different\n", inname, outname);
+         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);
      }
   }

@@ -711,11 +856,11 @@ int test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)

 /* input and output filenames */
 #ifdef RISCOS
-PNG_CONST char *inname = "pngtest_png";
-PNG_CONST char *outname = "pngout_png";
+PNG_CONST char *inname = "pngtest/png";
+PNG_CONST char *outname = "pngout/png";
 #else
-static char *inname = "pngtest.png";
-static char *outname = "pngout.png";
+static PNG_CONST char *inname = "pngtest.png";
+static PNG_CONST char *outname = "pngout.png";
 #endif

 int
@@ -731,13 +876,13 @@ main(int argc, char *argv[])
      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)
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
-   #endif
+#endif
   /* I think the following can happen. */
-   #if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
+#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
      fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");
-   #endif
+#endif

   if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
   {
@@ -751,20 +896,28 @@ main(int argc, char *argv[])
   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)
@@ -794,7 +947,11 @@ main(int argc, char *argv[])
         fprintf(STDERR, "Testing %s:",argv[i]);
         kerror = test_one_file(argv[i], outname);
         if (kerror == 0) 
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+            fprintf(STDERR, " PASS (%lu black pixels)\n",black_pixels);
+#else
            fprintf(STDERR, " PASS\n");
+#endif
         else {
            fprintf(STDERR, " FAIL\n");
            ierror += kerror;
@@ -828,12 +985,19 @@ main(int argc, char *argv[])
 #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) fprintf(STDERR, " PASS\n");
+            if(verbose == 1 || i == 2)
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+                fprintf(STDERR, " PASS (%lu black pixels)\n",black_pixels);
+#else
+                fprintf(STDERR, " PASS\n");
+#endif
         }
         else
         {
--- a/pngtest.png
+++ b/pngtest.png
--- a/pngtrans.c
+++ b/pngtrans.c
@@ -1,12 +1,12 @@

 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 #define PNG_INTERNAL
--- a/pngwio.c
+++ b/pngwio.c
@@ -1,12 +1,12 @@

 /* pngwio.c - functions for data output
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 *
 * This file provides a location for all output.  Users which need
 * special handling are expected to write functions which have the same
--- a/pngwrite.c
+++ b/pngwrite.c
@@ -1,12 +1,12 @@
   
 /* pngwrite.c - general routines to write a PNG file
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 /* get internal access to png.h */
@@ -225,8 +225,9 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
 png_charp
 png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
 {
-   const char *short_months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-                                   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+   static PNG_CONST char short_months[12][4] =
+	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+	 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

   if (png_ptr->time_buffer == NULL)
   {
@@ -238,7 +239,7 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
   {
      char near_time_buf[29];
      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
-               ptime->day % 31, short_months[ptime->month],
+               ptime->day % 31, short_months[ptime->month - 1],
               ptime->year, ptime->hour % 24, ptime->minute % 60,
               ptime->second % 61);
      png_memcpy(png_ptr->time_buffer, near_time_buf,
@@ -246,7 +247,7 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
   }
 #else
   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
-               ptime->day % 31, short_months[ptime->month],
+               ptime->day % 31, short_months[ptime->month - 1],
               ptime->year, ptime->hour % 24, ptime->minute % 60,
               ptime->second % 61);
 #endif
@@ -527,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)
@@ -831,10 +835,10 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,

      if (png_ptr->filter_weights == NULL)
      {
-         png_ptr->filter_weights = png_malloc(png_ptr,
+         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_malloc(png_ptr,
+         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++)
@@ -866,10 +870,10 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
    */
   if (png_ptr->filter_costs == NULL)
   {
-      png_ptr->filter_costs = png_malloc(png_ptr,
+      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,
+      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++)
@@ -947,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,12 +1,12 @@

 /* pngwtran.c - transforms the data in a row for PNG writers
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 #define PNG_INTERNAL
@@ -19,6 +19,21 @@ 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,
@@ -42,14 +57,14 @@ 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_SWAP_ALPHA_SUPPORTED)
-   if (png_ptr->transformations & PNG_SWAP_ALPHA)
-      png_do_write_swap_alpha(&(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);
+#endif
 #if defined(PNG_WRITE_BGR_SUPPORTED)
   if (png_ptr->transformations & PNG_BGR)
      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
@@ -227,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;
--- a/pngwutil.c
+++ b/pngwutil.c
@@ -1,12 +1,12 @@

 /* pngwutil.c - utilities to write a PNG file
 *
- * libpng 0.99d
+ * libpng 1.0.1
 * 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
- * February 8, 1998
+ * March 15, 1998
 */

 #define PNG_INTERNAL
@@ -340,7 +340,7 @@ png_write_gAMA(png_structp png_ptr, double file_gamma)
   png_byte buf[4];

   png_debug(1, "in png_write_gAMA\n");
-   /* file_gamma is saved in 1/100,000ths */
+   /* file_gamma is saved in 1/1000000ths */
   igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
   png_save_uint_32(buf, igamma);
   png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
@@ -426,7 +426,7 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
   png_byte buf[32];

   png_debug(1, "in png_write_cHRM\n");
-   /* each value is saved int 1/100,000ths */
+   /* each value is saved int 1/1000000ths */
   if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||
       white_x + white_y > 1.0)
   {
@@ -1383,10 +1383,10 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 * been specified by the application, and then writes the row out with the
 * chosen filter.
 */
-#define PNG_MAXSUM (png_uint_32)(~0x0UL >> 1)
+#define PNG_MAXSUM (~((png_uint_32)0) >> 1)
 #define PNG_HISHIFT 10
-#define PNG_LOMASK (png_uint_32)0xffffL
-#define PNG_HIMASK (png_uint_32)(~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)
 {
--- a/scripts/SCOPTIONS.ppc
+++ b/scripts/SCOPTIONS.ppc
@@ -0,0 +1,7 @@
+OPTIMIZE
+OPTPEEP
+OPTTIME
+OPTSCHED
+AUTOREGISTER
+PARMS=REGISTERS
+INCLUDEDIR=hlp:ppc/include
--- 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
@@ -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.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
@@ -21,8 +21,10 @@ LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm
 RANLIB=ranlib
 #RANLIB=echo

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

 # where make install puts libpng.a, libpng.so*, and png.h
@@ -54,7 +56,7 @@ libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
 	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)

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

 pngtest: pngtest.o libpng.so
--- 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
--- 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,104 @@
+# 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
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+         -Wmissing-declarations -Wtraditional -Wcast-align \
+         -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CFLAGS=-I$(ZLIBINC) -Wall -O3 \
+      #$(WARNMORE) -g -DPNG_DEBUG=5
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
+PNGMAJ = 2
+PNGMIN = 1.0
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+# where make install puts libpng.a, libpng.so*, and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.pic.o:
+	$(CC) -c $(CFLAGS) -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$(ZLIBLIB) -R$(ZLIBLIB) -h libpng.so.$(PNGMAJ) \
+	 -o libpng.so.$(PNGVER) $(OBJSDLL) -lz
+
+pngtest: pngtest.o libpng.so
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a libpng.so.$(PNGVER)
+	-@mkdir $(INCPATH) $(LIBPATH)
+	cp png.h pngconf.h $(INCPATH)
+	chmod 644 $(INCPATH)/png.h $(INCPATH)/pngconf.h
+	cp libpng.a libpng.so.$(PNGVER) $(LIBPATH)
+	chmod 755 $(LIBPATH)/libpng.so.$(PNGVER)
+	-@/bin/rm -f $(LIBPATH)/libpng.so.$(PNGMAJ) $(LIBPATH)/libpng.so
+	(cd $(LIBPATH); ln -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
@@ -30,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
@@ -9,8 +9,9 @@ CFLAGS=-O2 -Z $(MODEL) -I..\zlib
 CC=tcc
 LD=tcc
 LIB=tlib
-LDFLAGS=$(MODEL)
+LDFLAGS=$(MODEL) -L..\zlib
 O=.obj
+E=.exe

 # variables
 OBJS1 = png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O)
@@ -20,7 +21,7 @@ OBJSL1 = +png$(O) +pngset$(O) +pngget$(O) +pngrutil$(O) +pngtrans$(O)
 OBJSL2 = +pngwutil$(O) +pngmem$(O) +pngpread$(O) +pngread$(O) +pngerror$(O)
 OBJSL3 = +pngwrite$(O) +pngrtran$(O) +pngwtran$(O) +pngrio$(O) +pngwio$(O)

-all: libpng.lib
+all: libpng.lib pngtest.exe

 png$(O): png.h pngconf.h
 		  $(CC) -c $(CFLAGS) $*.c
@@ -75,4 +76,7 @@ libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
        $(LIB) libpng +$(OBJSL2)
        $(LIB) libpng +$(OBJSL3)

+pngtest$(E): pngtest$(O) libpng.lib
+        $(CC) $(LDFLAGS) pngtest.obj libpng.lib zlib.lib
+
 # End of makefile for libpng
--- a/scripts/makefile.wat
+++ b/scripts/makefile.wat
@@ -0,0 +1,88 @@
+# Makefile for libpng
+# Watcom 10a and later 32-bit protected mode flat memory model
+
+# Adapted by Pawel Mrochen, based on makefile.msc
+# For conditions of distribution and use, see copyright notice in png.h
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+
+# To use, do "wmake -f makefile.wat"
+
+# ------------- Watcom 10a and later -------------
+MODEL=-mf
+CFLAGS= $(MODEL) -fpi87 -fp5 -5r -oaeilmnrt -s -zp4 -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
--- a/scripts/smakefile.ppc
+++ b/scripts/smakefile.ppc
@@ -0,0 +1,29 @@
+# Amiga powerUP (TM) Makefile
+# makefile for libpng and SAS C V6.58/7.00 PPC compiler
+# Copyright (C) 1998 by Andreas R. Kleinert
+
+CC       = scppc
+CFLAGS   = NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL IDIR /zlib \
+           OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8
+LIBNAME  = libpng.a
+AR       = ppc-amigaos-ar
+AR_FLAGS = cr
+RANLIB   = ppc-amigaos-ranlib
+LDFLAGS  = -r -o
+LDLIBS   =  ../zlib/libzip.a LIB:scppc.a
+LN       = ppc-amigaos-ld
+RM       = delete quiet
+MKDIR    = makedir
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o pngread.o \
+pngerror.o pngpread.o pngwrite.o pngrtran.o pngwtran.o pngrio.o pngwio.o pngmem.o
+
+all: $(LIBNAME) pngtest
+
+$(LIBNAME): $(OBJS)
+            $(AR) $(AR_FLAGS) $@ $(OBJS)
+            $(RANLIB) $@
+
+pngtest: pngtest.o $(LIBNAME)
+        $(LN) $(LDFLAGS) pngtest LIB:c_ppc.o pngtest.o $(LIBNAME) $(LDLIBS) \
+LIB:end.o
Author	SHA1	Message	Date
Glenn Randers-Pehrson	f9f2fe0ce7	Imported from libpng-1.0.1.tar	2009-04-06 16:04:23 -05:00
Glenn Randers-Pehrson	d12aa50322	Imported from libpng-1.0.0b.tar	2009-04-06 16:04:22 -05:00
Glenn Randers-Pehrson	8f8fb6ae7a	Imported from libpng-1.0.0a.tar	2009-04-06 16:04:21 -05:00
Glenn Randers-Pehrson	0f7202f074	Imported from libpng-1.0.0.tar	2009-04-06 16:04:20 -05:00
Glenn Randers-Pehrson	397100eb8a	Imported from libpng-1.00.tar	2009-04-06 16:04:20 -05:00
Glenn Randers-Pehrson	4922b1b6e9	Imported from libpng-0.99p.tar	2009-04-06 16:04:19 -05:00
Glenn Randers-Pehrson	38d73aff67	Imported from libpng-0.99n.tar	2009-04-06 16:04:18 -05:00
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